xref: /freebsd/sys/kern/kern_sysctl.c (revision 210176ad76ee0f1d1ac9ca8d6d63dc5f5fc66427)
1df8bae1dSRodney W. Grimes /*-
251369649SPedro F. Giffuni  * SPDX-License-Identifier: BSD-3-Clause
351369649SPedro F. Giffuni  *
4df8bae1dSRodney W. Grimes  * Copyright (c) 1982, 1986, 1989, 1993
5df8bae1dSRodney W. Grimes  *	The Regents of the University of California.  All rights reserved.
6df8bae1dSRodney W. Grimes  *
7df8bae1dSRodney W. Grimes  * This code is derived from software contributed to Berkeley by
8df8bae1dSRodney W. Grimes  * Mike Karels at Berkeley Software Design, Inc.
9df8bae1dSRodney W. Grimes  *
10946bb7a2SPoul-Henning Kamp  * Quite extensively rewritten by Poul-Henning Kamp of the FreeBSD
11946bb7a2SPoul-Henning Kamp  * project, to make these variables more userfriendly.
12946bb7a2SPoul-Henning Kamp  *
13df8bae1dSRodney W. Grimes  * Redistribution and use in source and binary forms, with or without
14df8bae1dSRodney W. Grimes  * modification, are permitted provided that the following conditions
15df8bae1dSRodney W. Grimes  * are met:
16df8bae1dSRodney W. Grimes  * 1. Redistributions of source code must retain the above copyright
17df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer.
18df8bae1dSRodney W. Grimes  * 2. Redistributions in binary form must reproduce the above copyright
19df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer in the
20df8bae1dSRodney W. Grimes  *    documentation and/or other materials provided with the distribution.
2169a28758SEd Maste  * 3. Neither the name of the University nor the names of its contributors
22df8bae1dSRodney W. Grimes  *    may be used to endorse or promote products derived from this software
23df8bae1dSRodney W. Grimes  *    without specific prior written permission.
24df8bae1dSRodney W. Grimes  *
25df8bae1dSRodney W. Grimes  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26df8bae1dSRodney W. Grimes  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27df8bae1dSRodney W. Grimes  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28df8bae1dSRodney W. Grimes  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29df8bae1dSRodney W. Grimes  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30df8bae1dSRodney W. Grimes  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31df8bae1dSRodney W. Grimes  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32df8bae1dSRodney W. Grimes  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33df8bae1dSRodney W. Grimes  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34df8bae1dSRodney W. Grimes  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35df8bae1dSRodney W. Grimes  * SUCH DAMAGE.
36df8bae1dSRodney W. Grimes  *
37df8bae1dSRodney W. Grimes  *	@(#)kern_sysctl.c	8.4 (Berkeley) 4/14/94
38df8bae1dSRodney W. Grimes  */
39df8bae1dSRodney W. Grimes 
40677b542eSDavid E. O'Brien #include <sys/cdefs.h>
41677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$");
42677b542eSDavid E. O'Brien 
43ff66f6a4SRobert Watson #include "opt_capsicum.h"
44088c17b4SConrad Meyer #include "opt_ddb.h"
45a56be37eSJohn Baldwin #include "opt_ktrace.h"
4691c4b68fSPawel Biernacki #include "opt_sysctl.h"
475591b823SEivind Eklund 
48df8bae1dSRodney W. Grimes #include <sys/param.h>
49ccecef29SMatthew D Fleming #include <sys/fail.h>
50e96c1fdcSPeter Wemm #include <sys/systm.h>
514a144410SRobert Watson #include <sys/capsicum.h>
52df8bae1dSRodney W. Grimes #include <sys/kernel.h>
53088c17b4SConrad Meyer #include <sys/limits.h>
54df8bae1dSRodney W. Grimes #include <sys/sysctl.h>
55946bb7a2SPoul-Henning Kamp #include <sys/malloc.h>
56acd3428bSRobert Watson #include <sys/priv.h>
57efeaf95aSDavid Greenman #include <sys/proc.h>
58ebd8672cSBjoern A. Zeeb #include <sys/jail.h>
597d0658adSConrad Meyer #include <sys/kdb.h>
60fb99ab88SMatthew Dillon #include <sys/lock.h>
61fb99ab88SMatthew Dillon #include <sys/mutex.h>
627665e341SMateusz Guzik #include <sys/rmlock.h>
634e657159SMatthew D Fleming #include <sys/sbuf.h>
6429a2c0cdSAlfred Perlstein #include <sys/sx.h>
6545ec3b38SPoul-Henning Kamp #include <sys/sysproto.h>
66af80b2c9SKonstantin Belousov #include <sys/uio.h>
67a56be37eSJohn Baldwin #ifdef KTRACE
68a56be37eSJohn Baldwin #include <sys/ktrace.h>
69a56be37eSJohn Baldwin #endif
70aed55708SRobert Watson 
71088c17b4SConrad Meyer #ifdef DDB
72088c17b4SConrad Meyer #include <ddb/ddb.h>
73088c17b4SConrad Meyer #include <ddb/db_lex.h>
74088c17b4SConrad Meyer #endif
75088c17b4SConrad Meyer 
76eddfbb76SRobert Watson #include <net/vnet.h>
77eddfbb76SRobert Watson 
78aed55708SRobert Watson #include <security/mac/mac_framework.h>
79aed55708SRobert Watson 
804cb03b1bSBruce Evans #include <vm/vm.h>
81efeaf95aSDavid Greenman #include <vm/vm_extern.h>
824cb03b1bSBruce Evans 
83a1c995b6SPoul-Henning Kamp static MALLOC_DEFINE(M_SYSCTL, "sysctl", "sysctl internal magic");
84bd3cdc31SAndrzej Bialecki static MALLOC_DEFINE(M_SYSCTLOID, "sysctloid", "sysctl dynamic oids");
859e74cba3SDon Lewis static MALLOC_DEFINE(M_SYSCTLTMP, "sysctltmp", "sysctl temp output buffer");
8655166637SPoul-Henning Kamp 
874b2af45fSPoul-Henning Kamp /*
88875b66a0SJohn Baldwin  * The sysctllock protects the MIB tree.  It also protects sysctl
89875b66a0SJohn Baldwin  * contexts used with dynamic sysctls.  The sysctl_register_oid() and
90875b66a0SJohn Baldwin  * sysctl_unregister_oid() routines require the sysctllock to already
917665e341SMateusz Guzik  * be held, so the sysctl_wlock() and sysctl_wunlock() routines are
92875b66a0SJohn Baldwin  * provided for the few places in the kernel which need to use that
93875b66a0SJohn Baldwin  * API rather than using the dynamic API.  Use of the dynamic API is
94875b66a0SJohn Baldwin  * strongly encouraged for most code.
95875b66a0SJohn Baldwin  *
963e829b18SJohn Baldwin  * The sysctlmemlock is used to limit the amount of user memory wired for
973e829b18SJohn Baldwin  * sysctl requests.  This is implemented by serializing any userland
983e829b18SJohn Baldwin  * sysctl requests larger than a single page via an exclusive lock.
99*210176adSPawel Biernacki  *
100*210176adSPawel Biernacki  * The sysctlstringlock is used to protect concurrent access to writable
101*210176adSPawel Biernacki  * string nodes in sysctl_handle_string().
1024b2af45fSPoul-Henning Kamp  */
1037665e341SMateusz Guzik static struct rmlock sysctllock;
104956713cbSMateusz Guzik static struct sx __exclusive_cache_line sysctlmemlock;
105*210176adSPawel Biernacki static struct sx sysctlstringlock;
10629a2c0cdSAlfred Perlstein 
1077665e341SMateusz Guzik #define	SYSCTL_WLOCK()		rm_wlock(&sysctllock)
1087665e341SMateusz Guzik #define	SYSCTL_WUNLOCK()	rm_wunlock(&sysctllock)
1097665e341SMateusz Guzik #define	SYSCTL_RLOCK(tracker)	rm_rlock(&sysctllock, (tracker))
1107665e341SMateusz Guzik #define	SYSCTL_RUNLOCK(tracker)	rm_runlock(&sysctllock, (tracker))
1117665e341SMateusz Guzik #define	SYSCTL_WLOCKED()	rm_wowned(&sysctllock)
1127665e341SMateusz Guzik #define	SYSCTL_ASSERT_LOCKED()	rm_assert(&sysctllock, RA_LOCKED)
1137665e341SMateusz Guzik #define	SYSCTL_ASSERT_WLOCKED()	rm_assert(&sysctllock, RA_WLOCKED)
1147665e341SMateusz Guzik #define	SYSCTL_ASSERT_RLOCKED()	rm_assert(&sysctllock, RA_RLOCKED)
1157665e341SMateusz Guzik #define	SYSCTL_INIT()		rm_init_flags(&sysctllock, "sysctl lock", \
1167665e341SMateusz Guzik 				    RM_SLEEPABLE)
117ccecef29SMatthew D Fleming #define	SYSCTL_SLEEP(ch, wmesg, timo)					\
1187665e341SMateusz Guzik 				rm_sleep(ch, &sysctllock, 0, wmesg, timo)
1194b2af45fSPoul-Henning Kamp 
12082d9ae4eSPoul-Henning Kamp static int sysctl_root(SYSCTL_HANDLER_ARGS);
1214b2af45fSPoul-Henning Kamp 
122af3b2549SHans Petter Selasky /* Root list */
123af3b2549SHans Petter Selasky struct sysctl_oid_list sysctl__children = SLIST_HEAD_INITIALIZER(&sysctl__children);
124787d58f2SPoul-Henning Kamp 
125875b66a0SJohn Baldwin static int	sysctl_remove_oid_locked(struct sysctl_oid *oidp, int del,
126875b66a0SJohn Baldwin 		    int recurse);
127af3b2549SHans Petter Selasky static int	sysctl_old_kernel(struct sysctl_req *, const void *, size_t);
128af3b2549SHans Petter Selasky static int	sysctl_new_kernel(struct sysctl_req *, void *, size_t);
129875b66a0SJohn Baldwin 
130bd3cdc31SAndrzej Bialecki static struct sysctl_oid *
131bd3cdc31SAndrzej Bialecki sysctl_find_oidname(const char *name, struct sysctl_oid_list *list)
132bd3cdc31SAndrzej Bialecki {
133bd3cdc31SAndrzej Bialecki 	struct sysctl_oid *oidp;
134bd3cdc31SAndrzej Bialecki 
135efe0abddSMateusz Guzik 	SYSCTL_ASSERT_LOCKED();
136bd3cdc31SAndrzej Bialecki 	SLIST_FOREACH(oidp, list, oid_link) {
137bd3cdc31SAndrzej Bialecki 		if (strcmp(oidp->oid_name, name) == 0) {
138bd3cdc31SAndrzej Bialecki 			return (oidp);
139bd3cdc31SAndrzej Bialecki 		}
140bd3cdc31SAndrzej Bialecki 	}
141bd3cdc31SAndrzej Bialecki 	return (NULL);
142bd3cdc31SAndrzej Bialecki }
143bd3cdc31SAndrzej Bialecki 
144946bb7a2SPoul-Henning Kamp /*
145946bb7a2SPoul-Henning Kamp  * Initialization of the MIB tree.
146946bb7a2SPoul-Henning Kamp  *
147ce02431fSDoug Rabson  * Order by number in each list.
148946bb7a2SPoul-Henning Kamp  */
149875b66a0SJohn Baldwin void
1507665e341SMateusz Guzik sysctl_wlock(void)
151875b66a0SJohn Baldwin {
152875b66a0SJohn Baldwin 
1537665e341SMateusz Guzik 	SYSCTL_WLOCK();
154875b66a0SJohn Baldwin }
155875b66a0SJohn Baldwin 
156875b66a0SJohn Baldwin void
1577665e341SMateusz Guzik sysctl_wunlock(void)
158875b66a0SJohn Baldwin {
159875b66a0SJohn Baldwin 
1607665e341SMateusz Guzik 	SYSCTL_WUNLOCK();
161875b66a0SJohn Baldwin }
1624b2af45fSPoul-Henning Kamp 
163af3b2549SHans Petter Selasky static int
164e072f955SConrad Meyer sysctl_root_handler_locked(struct sysctl_oid *oid, void *arg1, intmax_t arg2,
1657665e341SMateusz Guzik     struct sysctl_req *req, struct rm_priotracker *tracker)
166af3b2549SHans Petter Selasky {
167af3b2549SHans Petter Selasky 	int error;
168af3b2549SHans Petter Selasky 
16984267cacSMateusz Guzik 	if (oid->oid_kind & CTLFLAG_DYN)
170efe0abddSMateusz Guzik 		atomic_add_int(&oid->oid_running, 1);
1717665e341SMateusz Guzik 
1727665e341SMateusz Guzik 	if (tracker != NULL)
1737665e341SMateusz Guzik 		SYSCTL_RUNLOCK(tracker);
1747665e341SMateusz Guzik 	else
1757665e341SMateusz Guzik 		SYSCTL_WUNLOCK();
176af3b2549SHans Petter Selasky 
177*210176adSPawel Biernacki 	/*
178*210176adSPawel Biernacki 	 * Treat set CTLFLAG_NEEDGIANT and unset CTLFLAG_MPSAFE flags the same,
179*210176adSPawel Biernacki 	 * untill we're ready to remove all traces of Giant from sysctl(9).
180*210176adSPawel Biernacki 	 */
181*210176adSPawel Biernacki 	if ((oid->oid_kind & CTLFLAG_NEEDGIANT) ||
182*210176adSPawel Biernacki 	    (!(oid->oid_kind & CTLFLAG_MPSAFE)))
183af3b2549SHans Petter Selasky 		mtx_lock(&Giant);
184af3b2549SHans Petter Selasky 	error = oid->oid_handler(oid, arg1, arg2, req);
185*210176adSPawel Biernacki 	if ((oid->oid_kind & CTLFLAG_NEEDGIANT) ||
186*210176adSPawel Biernacki 	    (!(oid->oid_kind & CTLFLAG_MPSAFE)))
187af3b2549SHans Petter Selasky 		mtx_unlock(&Giant);
188af3b2549SHans Petter Selasky 
18987b87bb8SMark Johnston 	KFAIL_POINT_ERROR(_debug_fail_point, sysctl_running, error);
19087b87bb8SMark Johnston 
1917665e341SMateusz Guzik 	if (tracker != NULL)
1927665e341SMateusz Guzik 		SYSCTL_RLOCK(tracker);
1937665e341SMateusz Guzik 	else
1947665e341SMateusz Guzik 		SYSCTL_WLOCK();
1957665e341SMateusz Guzik 
19684267cacSMateusz Guzik 	if (oid->oid_kind & CTLFLAG_DYN) {
197efe0abddSMateusz Guzik 		if (atomic_fetchadd_int(&oid->oid_running, -1) == 1 &&
198efe0abddSMateusz Guzik 		    (oid->oid_kind & CTLFLAG_DYING) != 0)
199af3b2549SHans Petter Selasky 			wakeup(&oid->oid_running);
20084267cacSMateusz Guzik 	}
201af3b2549SHans Petter Selasky 
202af3b2549SHans Petter Selasky 	return (error);
203af3b2549SHans Petter Selasky }
204af3b2549SHans Petter Selasky 
205af3b2549SHans Petter Selasky static void
206af3b2549SHans Petter Selasky sysctl_load_tunable_by_oid_locked(struct sysctl_oid *oidp)
207af3b2549SHans Petter Selasky {
208af3b2549SHans Petter Selasky 	struct sysctl_req req;
209af3b2549SHans Petter Selasky 	struct sysctl_oid *curr;
210604bf9d3SHans Petter Selasky 	char *penv = NULL;
21164282a12SHans Petter Selasky 	char path[96];
212af3b2549SHans Petter Selasky 	ssize_t rem = sizeof(path);
213af3b2549SHans Petter Selasky 	ssize_t len;
214ce70c572SHans Petter Selasky 	uint8_t data[512] __aligned(sizeof(uint64_t));
215ce70c572SHans Petter Selasky 	int size;
216af3b2549SHans Petter Selasky 	int error;
217af3b2549SHans Petter Selasky 
218af3b2549SHans Petter Selasky 	path[--rem] = 0;
219af3b2549SHans Petter Selasky 
220af3b2549SHans Petter Selasky 	for (curr = oidp; curr != NULL; curr = SYSCTL_PARENT(curr)) {
221af3b2549SHans Petter Selasky 		len = strlen(curr->oid_name);
222af3b2549SHans Petter Selasky 		rem -= len;
223af3b2549SHans Petter Selasky 		if (curr != oidp)
224af3b2549SHans Petter Selasky 			rem -= 1;
225af3b2549SHans Petter Selasky 		if (rem < 0) {
226af3b2549SHans Petter Selasky 			printf("OID path exceeds %d bytes\n", (int)sizeof(path));
227af3b2549SHans Petter Selasky 			return;
228af3b2549SHans Petter Selasky 		}
229af3b2549SHans Petter Selasky 		memcpy(path + rem, curr->oid_name, len);
230af3b2549SHans Petter Selasky 		if (curr != oidp)
231af3b2549SHans Petter Selasky 			path[rem + len] = '.';
232af3b2549SHans Petter Selasky 	}
233af3b2549SHans Petter Selasky 
234af3b2549SHans Petter Selasky 	memset(&req, 0, sizeof(req));
235af3b2549SHans Petter Selasky 
236af3b2549SHans Petter Selasky 	req.td = curthread;
237af3b2549SHans Petter Selasky 	req.oldfunc = sysctl_old_kernel;
238af3b2549SHans Petter Selasky 	req.newfunc = sysctl_new_kernel;
239af3b2549SHans Petter Selasky 	req.lock = REQ_UNWIRED;
240af3b2549SHans Petter Selasky 
241af3b2549SHans Petter Selasky 	switch (oidp->oid_kind & CTLTYPE) {
242af3b2549SHans Petter Selasky 	case CTLTYPE_INT:
243ce70c572SHans Petter Selasky 		if (getenv_array(path + rem, data, sizeof(data), &size,
244ce70c572SHans Petter Selasky 		    sizeof(int), GETENV_SIGNED) == 0)
245604bf9d3SHans Petter Selasky 			return;
246ce70c572SHans Petter Selasky 		req.newlen = size;
247ce70c572SHans Petter Selasky 		req.newptr = data;
248af3b2549SHans Petter Selasky 		break;
249af3b2549SHans Petter Selasky 	case CTLTYPE_UINT:
250ce70c572SHans Petter Selasky 		if (getenv_array(path + rem, data, sizeof(data), &size,
251ce70c572SHans Petter Selasky 		    sizeof(int), GETENV_UNSIGNED) == 0)
252604bf9d3SHans Petter Selasky 			return;
253ce70c572SHans Petter Selasky 		req.newlen = size;
254ce70c572SHans Petter Selasky 		req.newptr = data;
255af3b2549SHans Petter Selasky 		break;
256af3b2549SHans Petter Selasky 	case CTLTYPE_LONG:
257ce70c572SHans Petter Selasky 		if (getenv_array(path + rem, data, sizeof(data), &size,
258ce70c572SHans Petter Selasky 		    sizeof(long), GETENV_SIGNED) == 0)
259604bf9d3SHans Petter Selasky 			return;
260ce70c572SHans Petter Selasky 		req.newlen = size;
261ce70c572SHans Petter Selasky 		req.newptr = data;
262af3b2549SHans Petter Selasky 		break;
263af3b2549SHans Petter Selasky 	case CTLTYPE_ULONG:
264ce70c572SHans Petter Selasky 		if (getenv_array(path + rem, data, sizeof(data), &size,
265ce70c572SHans Petter Selasky 		    sizeof(long), GETENV_UNSIGNED) == 0)
266604bf9d3SHans Petter Selasky 			return;
267ce70c572SHans Petter Selasky 		req.newlen = size;
268ce70c572SHans Petter Selasky 		req.newptr = data;
269af3b2549SHans Petter Selasky 		break;
270e072f955SConrad Meyer 	case CTLTYPE_S8:
271ce70c572SHans Petter Selasky 		if (getenv_array(path + rem, data, sizeof(data), &size,
272ce70c572SHans Petter Selasky 		    sizeof(int8_t), GETENV_SIGNED) == 0)
273e072f955SConrad Meyer 			return;
274ce70c572SHans Petter Selasky 		req.newlen = size;
275ce70c572SHans Petter Selasky 		req.newptr = data;
276e072f955SConrad Meyer 		break;
277e072f955SConrad Meyer 	case CTLTYPE_S16:
278ce70c572SHans Petter Selasky 		if (getenv_array(path + rem, data, sizeof(data), &size,
279ce70c572SHans Petter Selasky 		    sizeof(int16_t), GETENV_SIGNED) == 0)
280e072f955SConrad Meyer 			return;
281ce70c572SHans Petter Selasky 		req.newlen = size;
282ce70c572SHans Petter Selasky 		req.newptr = data;
283e072f955SConrad Meyer 		break;
284e072f955SConrad Meyer 	case CTLTYPE_S32:
285ce70c572SHans Petter Selasky 		if (getenv_array(path + rem, data, sizeof(data), &size,
286ce70c572SHans Petter Selasky 		    sizeof(int32_t), GETENV_SIGNED) == 0)
287e072f955SConrad Meyer 			return;
288ce70c572SHans Petter Selasky 		req.newlen = size;
289ce70c572SHans Petter Selasky 		req.newptr = data;
290e072f955SConrad Meyer 		break;
291af3b2549SHans Petter Selasky 	case CTLTYPE_S64:
292ce70c572SHans Petter Selasky 		if (getenv_array(path + rem, data, sizeof(data), &size,
293ce70c572SHans Petter Selasky 		    sizeof(int64_t), GETENV_SIGNED) == 0)
294604bf9d3SHans Petter Selasky 			return;
295ce70c572SHans Petter Selasky 		req.newlen = size;
296ce70c572SHans Petter Selasky 		req.newptr = data;
297af3b2549SHans Petter Selasky 		break;
298e072f955SConrad Meyer 	case CTLTYPE_U8:
299ce70c572SHans Petter Selasky 		if (getenv_array(path + rem, data, sizeof(data), &size,
300ce70c572SHans Petter Selasky 		    sizeof(uint8_t), GETENV_UNSIGNED) == 0)
301e072f955SConrad Meyer 			return;
302ce70c572SHans Petter Selasky 		req.newlen = size;
303ce70c572SHans Petter Selasky 		req.newptr = data;
304e072f955SConrad Meyer 		break;
305e072f955SConrad Meyer 	case CTLTYPE_U16:
306ce70c572SHans Petter Selasky 		if (getenv_array(path + rem, data, sizeof(data), &size,
307ce70c572SHans Petter Selasky 		    sizeof(uint16_t), GETENV_UNSIGNED) == 0)
308e072f955SConrad Meyer 			return;
309ce70c572SHans Petter Selasky 		req.newlen = size;
310ce70c572SHans Petter Selasky 		req.newptr = data;
311e072f955SConrad Meyer 		break;
312e072f955SConrad Meyer 	case CTLTYPE_U32:
313ce70c572SHans Petter Selasky 		if (getenv_array(path + rem, data, sizeof(data), &size,
314ce70c572SHans Petter Selasky 		    sizeof(uint32_t), GETENV_UNSIGNED) == 0)
315e072f955SConrad Meyer 			return;
316ce70c572SHans Petter Selasky 		req.newlen = size;
317ce70c572SHans Petter Selasky 		req.newptr = data;
318e072f955SConrad Meyer 		break;
319af3b2549SHans Petter Selasky 	case CTLTYPE_U64:
320ce70c572SHans Petter Selasky 		if (getenv_array(path + rem, data, sizeof(data), &size,
321ce70c572SHans Petter Selasky 		    sizeof(uint64_t), GETENV_UNSIGNED) == 0)
322604bf9d3SHans Petter Selasky 			return;
323ce70c572SHans Petter Selasky 		req.newlen = size;
324ce70c572SHans Petter Selasky 		req.newptr = data;
325af3b2549SHans Petter Selasky 		break;
326af3b2549SHans Petter Selasky 	case CTLTYPE_STRING:
3272be111bfSDavide Italiano 		penv = kern_getenv(path + rem);
328604bf9d3SHans Petter Selasky 		if (penv == NULL)
329604bf9d3SHans Petter Selasky 			return;
330af3b2549SHans Petter Selasky 		req.newlen = strlen(penv);
331af3b2549SHans Petter Selasky 		req.newptr = penv;
332af3b2549SHans Petter Selasky 		break;
333af3b2549SHans Petter Selasky 	default:
334af3b2549SHans Petter Selasky 		return;
335af3b2549SHans Petter Selasky 	}
336af3b2549SHans Petter Selasky 	error = sysctl_root_handler_locked(oidp, oidp->oid_arg1,
3377665e341SMateusz Guzik 	    oidp->oid_arg2, &req, NULL);
338b0d69dfaSDag-Erling Smørgrav 	if (error != 0)
339ab91c9a7SHans Petter Selasky 		printf("Setting sysctl %s failed: %d\n", path + rem, error);
340b0d69dfaSDag-Erling Smørgrav 	if (penv != NULL)
341af3b2549SHans Petter Selasky 		freeenv(penv);
342af3b2549SHans Petter Selasky }
343af3b2549SHans Petter Selasky 
3444ae2ade1SConrad Meyer /*
3454ae2ade1SConrad Meyer  * Locate the path to a given oid.  Returns the length of the resulting path,
3464ae2ade1SConrad Meyer  * or -1 if the oid was not found.  nodes must have room for CTL_MAXNAME
3474ae2ade1SConrad Meyer  * elements and be NULL initialized.
3484ae2ade1SConrad Meyer  */
3494ae2ade1SConrad Meyer static int
3504ae2ade1SConrad Meyer sysctl_search_oid(struct sysctl_oid **nodes, struct sysctl_oid *needle)
3514ae2ade1SConrad Meyer {
3524ae2ade1SConrad Meyer 	int indx;
3534ae2ade1SConrad Meyer 
3544ae2ade1SConrad Meyer 	SYSCTL_ASSERT_LOCKED();
3554ae2ade1SConrad Meyer 	indx = 0;
3564ae2ade1SConrad Meyer 	while (indx < CTL_MAXNAME && indx >= 0) {
3574ae2ade1SConrad Meyer 		if (nodes[indx] == NULL && indx == 0)
3584ae2ade1SConrad Meyer 			nodes[indx] = SLIST_FIRST(&sysctl__children);
3594ae2ade1SConrad Meyer 		else if (nodes[indx] == NULL)
3604ae2ade1SConrad Meyer 			nodes[indx] = SLIST_FIRST(&nodes[indx - 1]->oid_children);
3614ae2ade1SConrad Meyer 		else
3624ae2ade1SConrad Meyer 			nodes[indx] = SLIST_NEXT(nodes[indx], oid_link);
3634ae2ade1SConrad Meyer 
3644ae2ade1SConrad Meyer 		if (nodes[indx] == needle)
3654ae2ade1SConrad Meyer 			return (indx + 1);
3664ae2ade1SConrad Meyer 
3674ae2ade1SConrad Meyer 		if (nodes[indx] == NULL) {
3684ae2ade1SConrad Meyer 			indx--;
3694ae2ade1SConrad Meyer 			continue;
3704ae2ade1SConrad Meyer 		}
3714ae2ade1SConrad Meyer 
3724ae2ade1SConrad Meyer 		if ((nodes[indx]->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
3734ae2ade1SConrad Meyer 			indx++;
3744ae2ade1SConrad Meyer 			continue;
3754ae2ade1SConrad Meyer 		}
3764ae2ade1SConrad Meyer 	}
3774ae2ade1SConrad Meyer 	return (-1);
3784ae2ade1SConrad Meyer }
3794ae2ade1SConrad Meyer 
3804ae2ade1SConrad Meyer static void
3814ae2ade1SConrad Meyer sysctl_warn_reuse(const char *func, struct sysctl_oid *leaf)
3824ae2ade1SConrad Meyer {
3834ae2ade1SConrad Meyer 	struct sysctl_oid *nodes[CTL_MAXNAME];
3844ae2ade1SConrad Meyer 	char buf[128];
3854ae2ade1SConrad Meyer 	struct sbuf sb;
3864ae2ade1SConrad Meyer 	int rc, i;
3874ae2ade1SConrad Meyer 
3884ae2ade1SConrad Meyer 	(void)sbuf_new(&sb, buf, sizeof(buf), SBUF_FIXEDLEN | SBUF_INCLUDENUL);
3894ae2ade1SConrad Meyer 	sbuf_set_drain(&sb, sbuf_printf_drain, NULL);
3904ae2ade1SConrad Meyer 
3914ae2ade1SConrad Meyer 	sbuf_printf(&sb, "%s: can't re-use a leaf (", __func__);
3924ae2ade1SConrad Meyer 
3934ae2ade1SConrad Meyer 	memset(nodes, 0, sizeof(nodes));
3944ae2ade1SConrad Meyer 	rc = sysctl_search_oid(nodes, leaf);
3954ae2ade1SConrad Meyer 	if (rc > 0) {
3964ae2ade1SConrad Meyer 		for (i = 0; i < rc; i++)
3974ae2ade1SConrad Meyer 			sbuf_printf(&sb, "%s%.*s", nodes[i]->oid_name,
3984ae2ade1SConrad Meyer 			    i != (rc - 1), ".");
3994ae2ade1SConrad Meyer 	} else {
4004ae2ade1SConrad Meyer 		sbuf_printf(&sb, "%s", leaf->oid_name);
4014ae2ade1SConrad Meyer 	}
4024ae2ade1SConrad Meyer 	sbuf_printf(&sb, ")!\n");
4034ae2ade1SConrad Meyer 
4044ae2ade1SConrad Meyer 	(void)sbuf_finish(&sb);
4054ae2ade1SConrad Meyer }
4064ae2ade1SConrad Meyer 
4074ae2ade1SConrad Meyer #ifdef SYSCTL_DEBUG
4084ae2ade1SConrad Meyer static int
4094ae2ade1SConrad Meyer sysctl_reuse_test(SYSCTL_HANDLER_ARGS)
4104ae2ade1SConrad Meyer {
4114ae2ade1SConrad Meyer 	struct rm_priotracker tracker;
4124ae2ade1SConrad Meyer 
4134ae2ade1SConrad Meyer 	SYSCTL_RLOCK(&tracker);
4144ae2ade1SConrad Meyer 	sysctl_warn_reuse(__func__, oidp);
4154ae2ade1SConrad Meyer 	SYSCTL_RUNLOCK(&tracker);
4164ae2ade1SConrad Meyer 	return (0);
4174ae2ade1SConrad Meyer }
41891c4b68fSPawel Biernacki SYSCTL_PROC(_sysctl, OID_AUTO, reuse_test,
41991c4b68fSPawel Biernacki     CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, 0, 0, sysctl_reuse_test, "-",
42091c4b68fSPawel Biernacki     "");
4214ae2ade1SConrad Meyer #endif
4224ae2ade1SConrad Meyer 
423550374efSAndriy Gapon void
424550374efSAndriy Gapon sysctl_register_oid(struct sysctl_oid *oidp)
425787d58f2SPoul-Henning Kamp {
426ce02431fSDoug Rabson 	struct sysctl_oid_list *parent = oidp->oid_parent;
427ce02431fSDoug Rabson 	struct sysctl_oid *p;
428ce02431fSDoug Rabson 	struct sysctl_oid *q;
42938668c60SHans Petter Selasky 	int oid_number;
43038668c60SHans Petter Selasky 	int timeout = 2;
4313c8e79ddSBruce Evans 
432ce02431fSDoug Rabson 	/*
433bd3cdc31SAndrzej Bialecki 	 * First check if another oid with the same name already
434bd3cdc31SAndrzej Bialecki 	 * exists in the parent's list.
435bd3cdc31SAndrzej Bialecki 	 */
4367665e341SMateusz Guzik 	SYSCTL_ASSERT_WLOCKED();
437bd3cdc31SAndrzej Bialecki 	p = sysctl_find_oidname(oidp->oid_name, parent);
438bd3cdc31SAndrzej Bialecki 	if (p != NULL) {
439bd3cdc31SAndrzej Bialecki 		if ((p->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
440bd3cdc31SAndrzej Bialecki 			p->oid_refcnt++;
441bd3cdc31SAndrzej Bialecki 			return;
442bd3cdc31SAndrzej Bialecki 		} else {
4434ae2ade1SConrad Meyer 			sysctl_warn_reuse(__func__, p);
444bd3cdc31SAndrzej Bialecki 			return;
445bd3cdc31SAndrzej Bialecki 		}
446bd3cdc31SAndrzej Bialecki 	}
44738668c60SHans Petter Selasky 	/* get current OID number */
44838668c60SHans Petter Selasky 	oid_number = oidp->oid_number;
44938668c60SHans Petter Selasky 
45038668c60SHans Petter Selasky #if (OID_AUTO >= 0)
45138668c60SHans Petter Selasky #error "OID_AUTO is expected to be a negative value"
45238668c60SHans Petter Selasky #endif
453bd3cdc31SAndrzej Bialecki 	/*
45438668c60SHans Petter Selasky 	 * Any negative OID number qualifies as OID_AUTO. Valid OID
45538668c60SHans Petter Selasky 	 * numbers should always be positive.
45638668c60SHans Petter Selasky 	 *
4577ca4d05fSPeter Pentchev 	 * NOTE: DO NOT change the starting value here, change it in
4587ca4d05fSPeter Pentchev 	 * <sys/sysctl.h>, and make sure it is at least 256 to
459e3043798SPedro F. Giffuni 	 * accommodate e.g. net.inet.raw as a static sysctl node.
460ce02431fSDoug Rabson 	 */
46138668c60SHans Petter Selasky 	if (oid_number < 0) {
46238668c60SHans Petter Selasky 		static int newoid;
463787d58f2SPoul-Henning Kamp 
464ce02431fSDoug Rabson 		/*
46538668c60SHans Petter Selasky 		 * By decrementing the next OID number we spend less
46638668c60SHans Petter Selasky 		 * time inserting the OIDs into a sorted list.
467ce02431fSDoug Rabson 		 */
46838668c60SHans Petter Selasky 		if (--newoid < CTL_AUTO_START)
46938668c60SHans Petter Selasky 			newoid = 0x7fffffff;
47038668c60SHans Petter Selasky 
47138668c60SHans Petter Selasky 		oid_number = newoid;
47238668c60SHans Petter Selasky 	}
47338668c60SHans Petter Selasky 
47438668c60SHans Petter Selasky 	/*
47538668c60SHans Petter Selasky 	 * Insert the OID into the parent's list sorted by OID number.
47638668c60SHans Petter Selasky 	 */
47738668c60SHans Petter Selasky retry:
478ce02431fSDoug Rabson 	q = NULL;
479ce02431fSDoug Rabson 	SLIST_FOREACH(p, parent, oid_link) {
48038668c60SHans Petter Selasky 		/* check if the current OID number is in use */
48138668c60SHans Petter Selasky 		if (oid_number == p->oid_number) {
48238668c60SHans Petter Selasky 			/* get the next valid OID number */
48338668c60SHans Petter Selasky 			if (oid_number < CTL_AUTO_START ||
48438668c60SHans Petter Selasky 			    oid_number == 0x7fffffff) {
48538668c60SHans Petter Selasky 				/* wraparound - restart */
48638668c60SHans Petter Selasky 				oid_number = CTL_AUTO_START;
48738668c60SHans Petter Selasky 				/* don't loop forever */
48838668c60SHans Petter Selasky 				if (!timeout--)
48938668c60SHans Petter Selasky 					panic("sysctl: Out of OID numbers\n");
49038668c60SHans Petter Selasky 				goto retry;
49138668c60SHans Petter Selasky 			} else {
49238668c60SHans Petter Selasky 				oid_number++;
49338668c60SHans Petter Selasky 			}
49438668c60SHans Petter Selasky 		} else if (oid_number < p->oid_number)
495ce02431fSDoug Rabson 			break;
496ce02431fSDoug Rabson 		q = p;
497ce02431fSDoug Rabson 	}
49838668c60SHans Petter Selasky 	/* check for non-auto OID number collision */
49938668c60SHans Petter Selasky 	if (oidp->oid_number >= 0 && oidp->oid_number < CTL_AUTO_START &&
50038668c60SHans Petter Selasky 	    oid_number >= CTL_AUTO_START) {
50138668c60SHans Petter Selasky 		printf("sysctl: OID number(%d) is already in use for '%s'\n",
50238668c60SHans Petter Selasky 		    oidp->oid_number, oidp->oid_name);
50338668c60SHans Petter Selasky 	}
50438668c60SHans Petter Selasky 	/* update the OID number, if any */
50538668c60SHans Petter Selasky 	oidp->oid_number = oid_number;
50638668c60SHans Petter Selasky 	if (q != NULL)
507ce02431fSDoug Rabson 		SLIST_INSERT_AFTER(q, oidp, oid_link);
508ce02431fSDoug Rabson 	else
509ce02431fSDoug Rabson 		SLIST_INSERT_HEAD(parent, oidp, oid_link);
510af3b2549SHans Petter Selasky 
511af3b2549SHans Petter Selasky 	if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE &&
512af3b2549SHans Petter Selasky #ifdef VIMAGE
513af3b2549SHans Petter Selasky 	    (oidp->oid_kind & CTLFLAG_VNET) == 0 &&
514af3b2549SHans Petter Selasky #endif
515af3b2549SHans Petter Selasky 	    (oidp->oid_kind & CTLFLAG_TUN) != 0 &&
516af3b2549SHans Petter Selasky 	    (oidp->oid_kind & CTLFLAG_NOFETCH) == 0) {
517502702c6SHans Petter Selasky 		/* only fetch value once */
518502702c6SHans Petter Selasky 		oidp->oid_kind |= CTLFLAG_NOFETCH;
519502702c6SHans Petter Selasky 		/* try to fetch value from kernel environment */
520af3b2549SHans Petter Selasky 		sysctl_load_tunable_by_oid_locked(oidp);
521af3b2549SHans Petter Selasky 	}
522ce02431fSDoug Rabson }
523ce02431fSDoug Rabson 
524107e7dc5SPeter Pentchev void
525693593b6SAndriy Gapon sysctl_register_disabled_oid(struct sysctl_oid *oidp)
526693593b6SAndriy Gapon {
527693593b6SAndriy Gapon 
528693593b6SAndriy Gapon 	/*
529693593b6SAndriy Gapon 	 * Mark the leaf as dormant if it's not to be immediately enabled.
530693593b6SAndriy Gapon 	 * We do not disable nodes as they can be shared between modules
531693593b6SAndriy Gapon 	 * and it is always safe to access a node.
532693593b6SAndriy Gapon 	 */
533693593b6SAndriy Gapon 	KASSERT((oidp->oid_kind & CTLFLAG_DORMANT) == 0,
534693593b6SAndriy Gapon 	    ("internal flag is set in oid_kind"));
535693593b6SAndriy Gapon 	if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
536693593b6SAndriy Gapon 		oidp->oid_kind |= CTLFLAG_DORMANT;
537693593b6SAndriy Gapon 	sysctl_register_oid(oidp);
538693593b6SAndriy Gapon }
539693593b6SAndriy Gapon 
540693593b6SAndriy Gapon void
541693593b6SAndriy Gapon sysctl_enable_oid(struct sysctl_oid *oidp)
542693593b6SAndriy Gapon {
543693593b6SAndriy Gapon 
544693593b6SAndriy Gapon 	SYSCTL_ASSERT_WLOCKED();
545693593b6SAndriy Gapon 	if ((oidp->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
546693593b6SAndriy Gapon 		KASSERT((oidp->oid_kind & CTLFLAG_DORMANT) == 0,
547693593b6SAndriy Gapon 		    ("sysctl node is marked as dormant"));
548693593b6SAndriy Gapon 		return;
549693593b6SAndriy Gapon 	}
550693593b6SAndriy Gapon 	KASSERT((oidp->oid_kind & CTLFLAG_DORMANT) != 0,
551693593b6SAndriy Gapon 	    ("enabling already enabled sysctl oid"));
552693593b6SAndriy Gapon 	oidp->oid_kind &= ~CTLFLAG_DORMANT;
553693593b6SAndriy Gapon }
554693593b6SAndriy Gapon 
555693593b6SAndriy Gapon void
556107e7dc5SPeter Pentchev sysctl_unregister_oid(struct sysctl_oid *oidp)
557787d58f2SPoul-Henning Kamp {
558193f2edbSMaxime Henrion 	struct sysctl_oid *p;
559193f2edbSMaxime Henrion 	int error;
560193f2edbSMaxime Henrion 
5617665e341SMateusz Guzik 	SYSCTL_ASSERT_WLOCKED();
562193f2edbSMaxime Henrion 	if (oidp->oid_number == OID_AUTO) {
563193f2edbSMaxime Henrion 		error = EINVAL;
564193f2edbSMaxime Henrion 	} else {
56590acd1d1SHans Petter Selasky 		error = ENOENT;
566193f2edbSMaxime Henrion 		SLIST_FOREACH(p, oidp->oid_parent, oid_link) {
567193f2edbSMaxime Henrion 			if (p == oidp) {
568193f2edbSMaxime Henrion 				SLIST_REMOVE(oidp->oid_parent, oidp,
569193f2edbSMaxime Henrion 				    sysctl_oid, oid_link);
570193f2edbSMaxime Henrion 				error = 0;
571193f2edbSMaxime Henrion 				break;
572193f2edbSMaxime Henrion 			}
573193f2edbSMaxime Henrion 		}
574193f2edbSMaxime Henrion 	}
575193f2edbSMaxime Henrion 
576193f2edbSMaxime Henrion 	/*
577193f2edbSMaxime Henrion 	 * This can happen when a module fails to register and is
578193f2edbSMaxime Henrion 	 * being unloaded afterwards.  It should not be a panic()
579193f2edbSMaxime Henrion 	 * for normal use.
580193f2edbSMaxime Henrion 	 */
5812205f61aSHans Petter Selasky 	if (error) {
5822205f61aSHans Petter Selasky 		printf("%s: failed(%d) to unregister sysctl(%s)\n",
5832205f61aSHans Petter Selasky 		    __func__, error, oidp->oid_name);
5842205f61aSHans Petter Selasky 	}
58561220614SPoul-Henning Kamp }
586946bb7a2SPoul-Henning Kamp 
587bd3cdc31SAndrzej Bialecki /* Initialize a new context to keep track of dynamically added sysctls. */
588bd3cdc31SAndrzej Bialecki int
589bd3cdc31SAndrzej Bialecki sysctl_ctx_init(struct sysctl_ctx_list *c)
590bd3cdc31SAndrzej Bialecki {
591bd3cdc31SAndrzej Bialecki 
592bd3cdc31SAndrzej Bialecki 	if (c == NULL) {
593bd3cdc31SAndrzej Bialecki 		return (EINVAL);
594bd3cdc31SAndrzej Bialecki 	}
595875b66a0SJohn Baldwin 
596875b66a0SJohn Baldwin 	/*
597875b66a0SJohn Baldwin 	 * No locking here, the caller is responsible for not adding
598875b66a0SJohn Baldwin 	 * new nodes to a context until after this function has
599875b66a0SJohn Baldwin 	 * returned.
600875b66a0SJohn Baldwin 	 */
601bd3cdc31SAndrzej Bialecki 	TAILQ_INIT(c);
602bd3cdc31SAndrzej Bialecki 	return (0);
603bd3cdc31SAndrzej Bialecki }
604bd3cdc31SAndrzej Bialecki 
605bd3cdc31SAndrzej Bialecki /* Free the context, and destroy all dynamic oids registered in this context */
606bd3cdc31SAndrzej Bialecki int
607bd3cdc31SAndrzej Bialecki sysctl_ctx_free(struct sysctl_ctx_list *clist)
608bd3cdc31SAndrzej Bialecki {
609bd3cdc31SAndrzej Bialecki 	struct sysctl_ctx_entry *e, *e1;
610bd3cdc31SAndrzej Bialecki 	int error;
611bd3cdc31SAndrzej Bialecki 
612bd3cdc31SAndrzej Bialecki 	error = 0;
613bd3cdc31SAndrzej Bialecki 	/*
614bd3cdc31SAndrzej Bialecki 	 * First perform a "dry run" to check if it's ok to remove oids.
615bd3cdc31SAndrzej Bialecki 	 * XXX FIXME
616bd3cdc31SAndrzej Bialecki 	 * XXX This algorithm is a hack. But I don't know any
617bd3cdc31SAndrzej Bialecki 	 * XXX better solution for now...
618bd3cdc31SAndrzej Bialecki 	 */
6197665e341SMateusz Guzik 	SYSCTL_WLOCK();
620bd3cdc31SAndrzej Bialecki 	TAILQ_FOREACH(e, clist, link) {
621875b66a0SJohn Baldwin 		error = sysctl_remove_oid_locked(e->entry, 0, 0);
622bd3cdc31SAndrzej Bialecki 		if (error)
623bd3cdc31SAndrzej Bialecki 			break;
624bd3cdc31SAndrzej Bialecki 	}
625bd3cdc31SAndrzej Bialecki 	/*
626bd3cdc31SAndrzej Bialecki 	 * Restore deregistered entries, either from the end,
627e3043798SPedro F. Giffuni 	 * or from the place where error occurred.
628bd3cdc31SAndrzej Bialecki 	 * e contains the entry that was not unregistered
629bd3cdc31SAndrzej Bialecki 	 */
630bd3cdc31SAndrzej Bialecki 	if (error)
631bd3cdc31SAndrzej Bialecki 		e1 = TAILQ_PREV(e, sysctl_ctx_list, link);
632bd3cdc31SAndrzej Bialecki 	else
633bd3cdc31SAndrzej Bialecki 		e1 = TAILQ_LAST(clist, sysctl_ctx_list);
634bd3cdc31SAndrzej Bialecki 	while (e1 != NULL) {
635bd3cdc31SAndrzej Bialecki 		sysctl_register_oid(e1->entry);
636bd3cdc31SAndrzej Bialecki 		e1 = TAILQ_PREV(e1, sysctl_ctx_list, link);
637bd3cdc31SAndrzej Bialecki 	}
638875b66a0SJohn Baldwin 	if (error) {
6397665e341SMateusz Guzik 		SYSCTL_WUNLOCK();
640bd3cdc31SAndrzej Bialecki 		return(EBUSY);
641875b66a0SJohn Baldwin 	}
642bd3cdc31SAndrzej Bialecki 	/* Now really delete the entries */
643bd3cdc31SAndrzej Bialecki 	e = TAILQ_FIRST(clist);
644bd3cdc31SAndrzej Bialecki 	while (e != NULL) {
645bd3cdc31SAndrzej Bialecki 		e1 = TAILQ_NEXT(e, link);
646875b66a0SJohn Baldwin 		error = sysctl_remove_oid_locked(e->entry, 1, 0);
647bd3cdc31SAndrzej Bialecki 		if (error)
648bd3cdc31SAndrzej Bialecki 			panic("sysctl_remove_oid: corrupt tree, entry: %s",
649bd3cdc31SAndrzej Bialecki 			    e->entry->oid_name);
650bd3cdc31SAndrzej Bialecki 		free(e, M_SYSCTLOID);
651bd3cdc31SAndrzej Bialecki 		e = e1;
652bd3cdc31SAndrzej Bialecki 	}
6537665e341SMateusz Guzik 	SYSCTL_WUNLOCK();
654bd3cdc31SAndrzej Bialecki 	return (error);
655bd3cdc31SAndrzej Bialecki }
656bd3cdc31SAndrzej Bialecki 
657bd3cdc31SAndrzej Bialecki /* Add an entry to the context */
658bd3cdc31SAndrzej Bialecki struct sysctl_ctx_entry *
659bd3cdc31SAndrzej Bialecki sysctl_ctx_entry_add(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp)
660bd3cdc31SAndrzej Bialecki {
661bd3cdc31SAndrzej Bialecki 	struct sysctl_ctx_entry *e;
662bd3cdc31SAndrzej Bialecki 
6637665e341SMateusz Guzik 	SYSCTL_ASSERT_WLOCKED();
664bd3cdc31SAndrzej Bialecki 	if (clist == NULL || oidp == NULL)
665bd3cdc31SAndrzej Bialecki 		return(NULL);
666a163d034SWarner Losh 	e = malloc(sizeof(struct sysctl_ctx_entry), M_SYSCTLOID, M_WAITOK);
667bd3cdc31SAndrzej Bialecki 	e->entry = oidp;
668bd3cdc31SAndrzej Bialecki 	TAILQ_INSERT_HEAD(clist, e, link);
669bd3cdc31SAndrzej Bialecki 	return (e);
670bd3cdc31SAndrzej Bialecki }
671bd3cdc31SAndrzej Bialecki 
672bd3cdc31SAndrzej Bialecki /* Find an entry in the context */
673bd3cdc31SAndrzej Bialecki struct sysctl_ctx_entry *
674bd3cdc31SAndrzej Bialecki sysctl_ctx_entry_find(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp)
675bd3cdc31SAndrzej Bialecki {
676bd3cdc31SAndrzej Bialecki 	struct sysctl_ctx_entry *e;
677bd3cdc31SAndrzej Bialecki 
6787665e341SMateusz Guzik 	SYSCTL_ASSERT_WLOCKED();
679bd3cdc31SAndrzej Bialecki 	if (clist == NULL || oidp == NULL)
680bd3cdc31SAndrzej Bialecki 		return(NULL);
681fc2ffbe6SPoul-Henning Kamp 	TAILQ_FOREACH(e, clist, link) {
682bd3cdc31SAndrzej Bialecki 		if(e->entry == oidp)
683bd3cdc31SAndrzej Bialecki 			return(e);
684bd3cdc31SAndrzej Bialecki 	}
685bd3cdc31SAndrzej Bialecki 	return (e);
686bd3cdc31SAndrzej Bialecki }
687bd3cdc31SAndrzej Bialecki 
688bd3cdc31SAndrzej Bialecki /*
689bd3cdc31SAndrzej Bialecki  * Delete an entry from the context.
690bd3cdc31SAndrzej Bialecki  * NOTE: this function doesn't free oidp! You have to remove it
691bd3cdc31SAndrzej Bialecki  * with sysctl_remove_oid().
692bd3cdc31SAndrzej Bialecki  */
693bd3cdc31SAndrzej Bialecki int
694bd3cdc31SAndrzej Bialecki sysctl_ctx_entry_del(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp)
695bd3cdc31SAndrzej Bialecki {
696bd3cdc31SAndrzej Bialecki 	struct sysctl_ctx_entry *e;
697bd3cdc31SAndrzej Bialecki 
698bd3cdc31SAndrzej Bialecki 	if (clist == NULL || oidp == NULL)
699bd3cdc31SAndrzej Bialecki 		return (EINVAL);
7007665e341SMateusz Guzik 	SYSCTL_WLOCK();
701bd3cdc31SAndrzej Bialecki 	e = sysctl_ctx_entry_find(clist, oidp);
702bd3cdc31SAndrzej Bialecki 	if (e != NULL) {
703bd3cdc31SAndrzej Bialecki 		TAILQ_REMOVE(clist, e, link);
7047665e341SMateusz Guzik 		SYSCTL_WUNLOCK();
705bd3cdc31SAndrzej Bialecki 		free(e, M_SYSCTLOID);
706bd3cdc31SAndrzej Bialecki 		return (0);
707875b66a0SJohn Baldwin 	} else {
7087665e341SMateusz Guzik 		SYSCTL_WUNLOCK();
709bd3cdc31SAndrzej Bialecki 		return (ENOENT);
710bd3cdc31SAndrzej Bialecki 	}
711875b66a0SJohn Baldwin }
712bd3cdc31SAndrzej Bialecki 
713bd3cdc31SAndrzej Bialecki /*
714bd3cdc31SAndrzej Bialecki  * Remove dynamically created sysctl trees.
715bd3cdc31SAndrzej Bialecki  * oidp - top of the tree to be removed
716bd3cdc31SAndrzej Bialecki  * del - if 0 - just deregister, otherwise free up entries as well
717bd3cdc31SAndrzej Bialecki  * recurse - if != 0 traverse the subtree to be deleted
718bd3cdc31SAndrzej Bialecki  */
719bd3cdc31SAndrzej Bialecki int
720bd3cdc31SAndrzej Bialecki sysctl_remove_oid(struct sysctl_oid *oidp, int del, int recurse)
721bd3cdc31SAndrzej Bialecki {
722875b66a0SJohn Baldwin 	int error;
723875b66a0SJohn Baldwin 
7247665e341SMateusz Guzik 	SYSCTL_WLOCK();
725875b66a0SJohn Baldwin 	error = sysctl_remove_oid_locked(oidp, del, recurse);
7267665e341SMateusz Guzik 	SYSCTL_WUNLOCK();
727875b66a0SJohn Baldwin 	return (error);
728875b66a0SJohn Baldwin }
729875b66a0SJohn Baldwin 
730e4cd31ddSJeff Roberson int
731e4cd31ddSJeff Roberson sysctl_remove_name(struct sysctl_oid *parent, const char *name,
732e4cd31ddSJeff Roberson     int del, int recurse)
733e4cd31ddSJeff Roberson {
734e4cd31ddSJeff Roberson 	struct sysctl_oid *p, *tmp;
735e4cd31ddSJeff Roberson 	int error;
736e4cd31ddSJeff Roberson 
737e4cd31ddSJeff Roberson 	error = ENOENT;
7387665e341SMateusz Guzik 	SYSCTL_WLOCK();
739e4cd31ddSJeff Roberson 	SLIST_FOREACH_SAFE(p, SYSCTL_CHILDREN(parent), oid_link, tmp) {
740e4cd31ddSJeff Roberson 		if (strcmp(p->oid_name, name) == 0) {
741e4cd31ddSJeff Roberson 			error = sysctl_remove_oid_locked(p, del, recurse);
742e4cd31ddSJeff Roberson 			break;
743e4cd31ddSJeff Roberson 		}
744e4cd31ddSJeff Roberson 	}
7457665e341SMateusz Guzik 	SYSCTL_WUNLOCK();
746e4cd31ddSJeff Roberson 
747e4cd31ddSJeff Roberson 	return (error);
748e4cd31ddSJeff Roberson }
749e4cd31ddSJeff Roberson 
750875b66a0SJohn Baldwin static int
751875b66a0SJohn Baldwin sysctl_remove_oid_locked(struct sysctl_oid *oidp, int del, int recurse)
752875b66a0SJohn Baldwin {
753e4cd31ddSJeff Roberson 	struct sysctl_oid *p, *tmp;
754bd3cdc31SAndrzej Bialecki 	int error;
755bd3cdc31SAndrzej Bialecki 
7567665e341SMateusz Guzik 	SYSCTL_ASSERT_WLOCKED();
757bd3cdc31SAndrzej Bialecki 	if (oidp == NULL)
758bd3cdc31SAndrzej Bialecki 		return(EINVAL);
759bd3cdc31SAndrzej Bialecki 	if ((oidp->oid_kind & CTLFLAG_DYN) == 0) {
7608b69c3e7SEnji Cooper 		printf("Warning: can't remove non-dynamic nodes (%s)!\n",
7618b69c3e7SEnji Cooper 		    oidp->oid_name);
762bd3cdc31SAndrzej Bialecki 		return (EINVAL);
763bd3cdc31SAndrzej Bialecki 	}
764bd3cdc31SAndrzej Bialecki 	/*
765bd3cdc31SAndrzej Bialecki 	 * WARNING: normal method to do this should be through
766bd3cdc31SAndrzej Bialecki 	 * sysctl_ctx_free(). Use recursing as the last resort
767bd3cdc31SAndrzej Bialecki 	 * method to purge your sysctl tree of leftovers...
768bd3cdc31SAndrzej Bialecki 	 * However, if some other code still references these nodes,
769bd3cdc31SAndrzej Bialecki 	 * it will panic.
770bd3cdc31SAndrzej Bialecki 	 */
771bd3cdc31SAndrzej Bialecki 	if ((oidp->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
772bd3cdc31SAndrzej Bialecki 		if (oidp->oid_refcnt == 1) {
773e4cd31ddSJeff Roberson 			SLIST_FOREACH_SAFE(p,
774e4cd31ddSJeff Roberson 			    SYSCTL_CHILDREN(oidp), oid_link, tmp) {
775f510415dSScott Long 				if (!recurse) {
776f510415dSScott Long 					printf("Warning: failed attempt to "
777f510415dSScott Long 					    "remove oid %s with child %s\n",
778f510415dSScott Long 					    oidp->oid_name, p->oid_name);
779bd3cdc31SAndrzej Bialecki 					return (ENOTEMPTY);
780f510415dSScott Long 				}
781875b66a0SJohn Baldwin 				error = sysctl_remove_oid_locked(p, del,
782875b66a0SJohn Baldwin 				    recurse);
783bd3cdc31SAndrzej Bialecki 				if (error)
784bd3cdc31SAndrzej Bialecki 					return (error);
785bd3cdc31SAndrzej Bialecki 			}
786bd3cdc31SAndrzej Bialecki 		}
787bd3cdc31SAndrzej Bialecki 	}
788bd3cdc31SAndrzej Bialecki 	if (oidp->oid_refcnt > 1 ) {
789bd3cdc31SAndrzej Bialecki 		oidp->oid_refcnt--;
790bd3cdc31SAndrzej Bialecki 	} else {
791bd3cdc31SAndrzej Bialecki 		if (oidp->oid_refcnt == 0) {
792bd3cdc31SAndrzej Bialecki 			printf("Warning: bad oid_refcnt=%u (%s)!\n",
793bd3cdc31SAndrzej Bialecki 				oidp->oid_refcnt, oidp->oid_name);
794bd3cdc31SAndrzej Bialecki 			return (EINVAL);
795bd3cdc31SAndrzej Bialecki 		}
796bd3cdc31SAndrzej Bialecki 		sysctl_unregister_oid(oidp);
797bd3cdc31SAndrzej Bialecki 		if (del) {
798ccecef29SMatthew D Fleming 			/*
799ccecef29SMatthew D Fleming 			 * Wait for all threads running the handler to drain.
800ccecef29SMatthew D Fleming 			 * This preserves the previous behavior when the
801ccecef29SMatthew D Fleming 			 * sysctl lock was held across a handler invocation,
802ccecef29SMatthew D Fleming 			 * and is necessary for module unload correctness.
803ccecef29SMatthew D Fleming 			 */
804ccecef29SMatthew D Fleming 			while (oidp->oid_running > 0) {
805ccecef29SMatthew D Fleming 				oidp->oid_kind |= CTLFLAG_DYING;
806ccecef29SMatthew D Fleming 				SYSCTL_SLEEP(&oidp->oid_running, "oidrm", 0);
807ccecef29SMatthew D Fleming 			}
8085937226dSPoul-Henning Kamp 			if (oidp->oid_descr)
809db9066f7SMarius Strobl 				free(__DECONST(char *, oidp->oid_descr),
81093e8459aSPeter Wemm 				    M_SYSCTLOID);
8111e1f3941SEd Schouten 			if (oidp->oid_label)
8121e1f3941SEd Schouten 				free(__DECONST(char *, oidp->oid_label),
8131e1f3941SEd Schouten 				    M_SYSCTLOID);
814db9066f7SMarius Strobl 			free(__DECONST(char *, oidp->oid_name), M_SYSCTLOID);
815bd3cdc31SAndrzej Bialecki 			free(oidp, M_SYSCTLOID);
816bd3cdc31SAndrzej Bialecki 		}
817bd3cdc31SAndrzej Bialecki 	}
818bd3cdc31SAndrzej Bialecki 	return (0);
819bd3cdc31SAndrzej Bialecki }
820bd3cdc31SAndrzej Bialecki /*
821bd3cdc31SAndrzej Bialecki  * Create new sysctls at run time.
822bd3cdc31SAndrzej Bialecki  * clist may point to a valid context initialized with sysctl_ctx_init().
823bd3cdc31SAndrzej Bialecki  */
824bd3cdc31SAndrzej Bialecki struct sysctl_oid *
825bd3cdc31SAndrzej Bialecki sysctl_add_oid(struct sysctl_ctx_list *clist, struct sysctl_oid_list *parent,
826be87839eSConrad Meyer 	int number, const char *name, int kind, void *arg1, intmax_t arg2,
8271e1f3941SEd Schouten 	int (*handler)(SYSCTL_HANDLER_ARGS), const char *fmt, const char *descr,
8281e1f3941SEd Schouten 	const char *label)
829bd3cdc31SAndrzej Bialecki {
830bd3cdc31SAndrzej Bialecki 	struct sysctl_oid *oidp;
831bd3cdc31SAndrzej Bialecki 
832bd3cdc31SAndrzej Bialecki 	/* You have to hook up somewhere.. */
833bd3cdc31SAndrzej Bialecki 	if (parent == NULL)
834bd3cdc31SAndrzej Bialecki 		return(NULL);
835bd3cdc31SAndrzej Bialecki 	/* Check if the node already exists, otherwise create it */
8367665e341SMateusz Guzik 	SYSCTL_WLOCK();
837bd3cdc31SAndrzej Bialecki 	oidp = sysctl_find_oidname(name, parent);
838bd3cdc31SAndrzej Bialecki 	if (oidp != NULL) {
839bd3cdc31SAndrzej Bialecki 		if ((oidp->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
840bd3cdc31SAndrzej Bialecki 			oidp->oid_refcnt++;
841bd3cdc31SAndrzej Bialecki 			/* Update the context */
842bd3cdc31SAndrzej Bialecki 			if (clist != NULL)
843bd3cdc31SAndrzej Bialecki 				sysctl_ctx_entry_add(clist, oidp);
8447665e341SMateusz Guzik 			SYSCTL_WUNLOCK();
845bd3cdc31SAndrzej Bialecki 			return (oidp);
846bd3cdc31SAndrzej Bialecki 		} else {
8474ae2ade1SConrad Meyer 			sysctl_warn_reuse(__func__, oidp);
8487665e341SMateusz Guzik 			SYSCTL_WUNLOCK();
849bd3cdc31SAndrzej Bialecki 			return (NULL);
850bd3cdc31SAndrzej Bialecki 		}
851bd3cdc31SAndrzej Bialecki 	}
852a163d034SWarner Losh 	oidp = malloc(sizeof(struct sysctl_oid), M_SYSCTLOID, M_WAITOK|M_ZERO);
853bd3cdc31SAndrzej Bialecki 	oidp->oid_parent = parent;
854af3b2549SHans Petter Selasky 	SLIST_INIT(&oidp->oid_children);
855bd3cdc31SAndrzej Bialecki 	oidp->oid_number = number;
856bd3cdc31SAndrzej Bialecki 	oidp->oid_refcnt = 1;
857db9066f7SMarius Strobl 	oidp->oid_name = strdup(name, M_SYSCTLOID);
858bd3cdc31SAndrzej Bialecki 	oidp->oid_handler = handler;
859bd3cdc31SAndrzej Bialecki 	oidp->oid_kind = CTLFLAG_DYN | kind;
860bd3cdc31SAndrzej Bialecki 	oidp->oid_arg1 = arg1;
861bd3cdc31SAndrzej Bialecki 	oidp->oid_arg2 = arg2;
862bd3cdc31SAndrzej Bialecki 	oidp->oid_fmt = fmt;
863af3b2549SHans Petter Selasky 	if (descr != NULL)
864db9066f7SMarius Strobl 		oidp->oid_descr = strdup(descr, M_SYSCTLOID);
8651e1f3941SEd Schouten 	if (label != NULL)
8661e1f3941SEd Schouten 		oidp->oid_label = strdup(label, M_SYSCTLOID);
867bd3cdc31SAndrzej Bialecki 	/* Update the context, if used */
868bd3cdc31SAndrzej Bialecki 	if (clist != NULL)
869bd3cdc31SAndrzej Bialecki 		sysctl_ctx_entry_add(clist, oidp);
870bd3cdc31SAndrzej Bialecki 	/* Register this oid */
871bd3cdc31SAndrzej Bialecki 	sysctl_register_oid(oidp);
8727665e341SMateusz Guzik 	SYSCTL_WUNLOCK();
873bd3cdc31SAndrzej Bialecki 	return (oidp);
874bd3cdc31SAndrzej Bialecki }
875bd3cdc31SAndrzej Bialecki 
876ce02431fSDoug Rabson /*
877cd17ceaaSPeter Wemm  * Rename an existing oid.
878cd17ceaaSPeter Wemm  */
879cd17ceaaSPeter Wemm void
880cd17ceaaSPeter Wemm sysctl_rename_oid(struct sysctl_oid *oidp, const char *name)
881cd17ceaaSPeter Wemm {
882cd17ceaaSPeter Wemm 	char *newname;
883db9066f7SMarius Strobl 	char *oldname;
884cd17ceaaSPeter Wemm 
885db9066f7SMarius Strobl 	newname = strdup(name, M_SYSCTLOID);
8867665e341SMateusz Guzik 	SYSCTL_WLOCK();
887db9066f7SMarius Strobl 	oldname = __DECONST(char *, oidp->oid_name);
888cd17ceaaSPeter Wemm 	oidp->oid_name = newname;
8897665e341SMateusz Guzik 	SYSCTL_WUNLOCK();
890cd17ceaaSPeter Wemm 	free(oldname, M_SYSCTLOID);
891cd17ceaaSPeter Wemm }
892cd17ceaaSPeter Wemm 
893cd17ceaaSPeter Wemm /*
89421885af5SDag-Erling Smørgrav  * Reparent an existing oid.
89521885af5SDag-Erling Smørgrav  */
89621885af5SDag-Erling Smørgrav int
89721885af5SDag-Erling Smørgrav sysctl_move_oid(struct sysctl_oid *oid, struct sysctl_oid_list *parent)
89821885af5SDag-Erling Smørgrav {
89921885af5SDag-Erling Smørgrav 	struct sysctl_oid *oidp;
90021885af5SDag-Erling Smørgrav 
9017665e341SMateusz Guzik 	SYSCTL_WLOCK();
902875b66a0SJohn Baldwin 	if (oid->oid_parent == parent) {
9037665e341SMateusz Guzik 		SYSCTL_WUNLOCK();
90421885af5SDag-Erling Smørgrav 		return (0);
905875b66a0SJohn Baldwin 	}
90621885af5SDag-Erling Smørgrav 	oidp = sysctl_find_oidname(oid->oid_name, parent);
907875b66a0SJohn Baldwin 	if (oidp != NULL) {
9087665e341SMateusz Guzik 		SYSCTL_WUNLOCK();
90921885af5SDag-Erling Smørgrav 		return (EEXIST);
910875b66a0SJohn Baldwin 	}
91121885af5SDag-Erling Smørgrav 	sysctl_unregister_oid(oid);
91221885af5SDag-Erling Smørgrav 	oid->oid_parent = parent;
91321885af5SDag-Erling Smørgrav 	oid->oid_number = OID_AUTO;
91421885af5SDag-Erling Smørgrav 	sysctl_register_oid(oid);
9157665e341SMateusz Guzik 	SYSCTL_WUNLOCK();
91621885af5SDag-Erling Smørgrav 	return (0);
91721885af5SDag-Erling Smørgrav }
91821885af5SDag-Erling Smørgrav 
91921885af5SDag-Erling Smørgrav /*
920ce02431fSDoug Rabson  * Register the kernel's oids on startup.
921ce02431fSDoug Rabson  */
922f41325dbSPeter Wemm SET_DECLARE(sysctl_set, struct sysctl_oid);
923ce02431fSDoug Rabson 
924107e7dc5SPeter Pentchev static void
925107e7dc5SPeter Pentchev sysctl_register_all(void *arg)
926ce02431fSDoug Rabson {
927f41325dbSPeter Wemm 	struct sysctl_oid **oidp;
928ce02431fSDoug Rabson 
9293e829b18SJohn Baldwin 	sx_init(&sysctlmemlock, "sysctl mem");
930*210176adSPawel Biernacki 	sx_init(&sysctlstringlock, "sysctl string handler");
9313bd1da29SRobert Watson 	SYSCTL_INIT();
9327665e341SMateusz Guzik 	SYSCTL_WLOCK();
933f41325dbSPeter Wemm 	SET_FOREACH(oidp, sysctl_set)
934f41325dbSPeter Wemm 		sysctl_register_oid(*oidp);
9357665e341SMateusz Guzik 	SYSCTL_WUNLOCK();
936f41325dbSPeter Wemm }
937891cf3edSEd Maste SYSINIT(sysctl, SI_SUB_KMEM, SI_ORDER_FIRST, sysctl_register_all, NULL);
938ce02431fSDoug Rabson 
939946bb7a2SPoul-Henning Kamp /*
940946bb7a2SPoul-Henning Kamp  * "Staff-functions"
941946bb7a2SPoul-Henning Kamp  *
94265d0bc13SPoul-Henning Kamp  * These functions implement a presently undocumented interface
94365d0bc13SPoul-Henning Kamp  * used by the sysctl program to walk the tree, and get the type
94465d0bc13SPoul-Henning Kamp  * so it can print the value.
94565d0bc13SPoul-Henning Kamp  * This interface is under work and consideration, and should probably
94665d0bc13SPoul-Henning Kamp  * be killed with a big axe by the first person who can find the time.
94765d0bc13SPoul-Henning Kamp  * (be aware though, that the proper interface isn't as obvious as it
94865d0bc13SPoul-Henning Kamp  * may seem, there are various conflicting requirements.
94965d0bc13SPoul-Henning Kamp  *
950382e01c8SKonstantin Belousov  * {CTL_SYSCTL, CTL_SYSCTL_DEBUG}		printf the entire MIB-tree.
951382e01c8SKonstantin Belousov  * {CTL_SYSCTL, CTL_SYSCTL_NAME, ...}		return the name of the "..."
952382e01c8SKonstantin Belousov  *						OID.
953382e01c8SKonstantin Belousov  * {CTL_SYSCTL, CTL_SYSCTL_NEXT, ...}		return the next OID.
954382e01c8SKonstantin Belousov  * {CTL_SYSCTL, CTL_SYSCTL_NAME2OID}		return the OID of the name in
955382e01c8SKonstantin Belousov  *						"new"
956382e01c8SKonstantin Belousov  * {CTL_SYSCTL, CTL_SYSCTL_OIDFMT, ...}		return the kind & format info
957382e01c8SKonstantin Belousov  *						for the "..." OID.
958382e01c8SKonstantin Belousov  * {CTL_SYSCTL, CTL_SYSCTL_OIDDESCR, ...}	return the description of the
959382e01c8SKonstantin Belousov  *						"..." OID.
960382e01c8SKonstantin Belousov  * {CTL_SYSCTL, CTL_SYSCTL_OIDLABEL, ...}	return the aggregation label of
961382e01c8SKonstantin Belousov  *						the "..." OID.
962946bb7a2SPoul-Henning Kamp  */
963946bb7a2SPoul-Henning Kamp 
964df970488SRobert Watson #ifdef SYSCTL_DEBUG
965787d58f2SPoul-Henning Kamp static void
966ce02431fSDoug Rabson sysctl_sysctl_debug_dump_node(struct sysctl_oid_list *l, int i)
967787d58f2SPoul-Henning Kamp {
968ce02431fSDoug Rabson 	int k;
969ce02431fSDoug Rabson 	struct sysctl_oid *oidp;
970787d58f2SPoul-Henning Kamp 
971fca77320SMateusz Guzik 	SYSCTL_ASSERT_LOCKED();
972ce02431fSDoug Rabson 	SLIST_FOREACH(oidp, l, oid_link) {
973787d58f2SPoul-Henning Kamp 
974787d58f2SPoul-Henning Kamp 		for (k=0; k<i; k++)
975787d58f2SPoul-Henning Kamp 			printf(" ");
976787d58f2SPoul-Henning Kamp 
977ce02431fSDoug Rabson 		printf("%d %s ", oidp->oid_number, oidp->oid_name);
978787d58f2SPoul-Henning Kamp 
979787d58f2SPoul-Henning Kamp 		printf("%c%c",
980ce02431fSDoug Rabson 			oidp->oid_kind & CTLFLAG_RD ? 'R':' ',
981ce02431fSDoug Rabson 			oidp->oid_kind & CTLFLAG_WR ? 'W':' ');
982787d58f2SPoul-Henning Kamp 
983ce02431fSDoug Rabson 		if (oidp->oid_handler)
98461220614SPoul-Henning Kamp 			printf(" *Handler");
98561220614SPoul-Henning Kamp 
986ce02431fSDoug Rabson 		switch (oidp->oid_kind & CTLTYPE) {
987787d58f2SPoul-Henning Kamp 			case CTLTYPE_NODE:
988787d58f2SPoul-Henning Kamp 				printf(" Node\n");
989ce02431fSDoug Rabson 				if (!oidp->oid_handler) {
990787d58f2SPoul-Henning Kamp 					sysctl_sysctl_debug_dump_node(
991af3b2549SHans Petter Selasky 					    SYSCTL_CHILDREN(oidp), i + 2);
992787d58f2SPoul-Henning Kamp 				}
993787d58f2SPoul-Henning Kamp 				break;
994787d58f2SPoul-Henning Kamp 			case CTLTYPE_INT:    printf(" Int\n"); break;
995cbc134adSMatthew D Fleming 			case CTLTYPE_UINT:   printf(" u_int\n"); break;
996cbc134adSMatthew D Fleming 			case CTLTYPE_LONG:   printf(" Long\n"); break;
997cbc134adSMatthew D Fleming 			case CTLTYPE_ULONG:  printf(" u_long\n"); break;
998787d58f2SPoul-Henning Kamp 			case CTLTYPE_STRING: printf(" String\n"); break;
999e072f955SConrad Meyer 			case CTLTYPE_S8:     printf(" int8_t\n"); break;
1000e072f955SConrad Meyer 			case CTLTYPE_S16:    printf(" int16_t\n"); break;
1001e072f955SConrad Meyer 			case CTLTYPE_S32:    printf(" int32_t\n"); break;
1002cbc134adSMatthew D Fleming 			case CTLTYPE_S64:    printf(" int64_t\n"); break;
1003e072f955SConrad Meyer 			case CTLTYPE_U8:     printf(" uint8_t\n"); break;
1004e072f955SConrad Meyer 			case CTLTYPE_U16:    printf(" uint16_t\n"); break;
1005e072f955SConrad Meyer 			case CTLTYPE_U32:    printf(" uint32_t\n"); break;
1006e072f955SConrad Meyer 			case CTLTYPE_U64:    printf(" uint64_t\n"); break;
1007787d58f2SPoul-Henning Kamp 			case CTLTYPE_OPAQUE: printf(" Opaque/struct\n"); break;
1008787d58f2SPoul-Henning Kamp 			default:	     printf("\n");
1009787d58f2SPoul-Henning Kamp 		}
1010787d58f2SPoul-Henning Kamp 
1011787d58f2SPoul-Henning Kamp 	}
1012787d58f2SPoul-Henning Kamp }
1013787d58f2SPoul-Henning Kamp 
1014787d58f2SPoul-Henning Kamp static int
101582d9ae4eSPoul-Henning Kamp sysctl_sysctl_debug(SYSCTL_HANDLER_ARGS)
1016787d58f2SPoul-Henning Kamp {
10177665e341SMateusz Guzik 	struct rm_priotracker tracker;
1018023a0e61SPeter Wemm 	int error;
1019023a0e61SPeter Wemm 
1020acd3428bSRobert Watson 	error = priv_check(req->td, PRIV_SYSCTL_DEBUG);
1021023a0e61SPeter Wemm 	if (error)
102246003fb3SPawel Jakub Dawidek 		return (error);
10237665e341SMateusz Guzik 	SYSCTL_RLOCK(&tracker);
1024ce02431fSDoug Rabson 	sysctl_sysctl_debug_dump_node(&sysctl__children, 0);
10257665e341SMateusz Guzik 	SYSCTL_RUNLOCK(&tracker);
102646003fb3SPawel Jakub Dawidek 	return (ENOENT);
1027787d58f2SPoul-Henning Kamp }
1028787d58f2SPoul-Henning Kamp 
1029382e01c8SKonstantin Belousov SYSCTL_PROC(_sysctl, CTL_SYSCTL_DEBUG, debug, CTLTYPE_STRING | CTLFLAG_RD |
1030382e01c8SKonstantin Belousov     CTLFLAG_MPSAFE, 0, 0, sysctl_sysctl_debug, "-", "");
1031df970488SRobert Watson #endif
10322e210993SPoul-Henning Kamp 
1033946bb7a2SPoul-Henning Kamp static int
103482d9ae4eSPoul-Henning Kamp sysctl_sysctl_name(SYSCTL_HANDLER_ARGS)
1035946bb7a2SPoul-Henning Kamp {
1036946bb7a2SPoul-Henning Kamp 	int *name = (int *) arg1;
1037946bb7a2SPoul-Henning Kamp 	u_int namelen = arg2;
103843cefe8bSRyan Libby 	int error;
1039ce02431fSDoug Rabson 	struct sysctl_oid *oid;
10407f4173ccSPoul-Henning Kamp 	struct sysctl_oid_list *lsp = &sysctl__children, *lsp2;
10417665e341SMateusz Guzik 	struct rm_priotracker tracker;
1042946bb7a2SPoul-Henning Kamp 	char buf[10];
10432e210993SPoul-Henning Kamp 
104443cefe8bSRyan Libby 	error = sysctl_wire_old_buffer(req, 0);
104543cefe8bSRyan Libby 	if (error)
104643cefe8bSRyan Libby 		return (error);
104743cefe8bSRyan Libby 
10487665e341SMateusz Guzik 	SYSCTL_RLOCK(&tracker);
1049946bb7a2SPoul-Henning Kamp 	while (namelen) {
1050946bb7a2SPoul-Henning Kamp 		if (!lsp) {
10512127f260SArchie Cobbs 			snprintf(buf,sizeof(buf),"%d",*name);
1052946bb7a2SPoul-Henning Kamp 			if (req->oldidx)
1053946bb7a2SPoul-Henning Kamp 				error = SYSCTL_OUT(req, ".", 1);
1054946bb7a2SPoul-Henning Kamp 			if (!error)
1055946bb7a2SPoul-Henning Kamp 				error = SYSCTL_OUT(req, buf, strlen(buf));
1056946bb7a2SPoul-Henning Kamp 			if (error)
1057ccecef29SMatthew D Fleming 				goto out;
1058946bb7a2SPoul-Henning Kamp 			namelen--;
1059946bb7a2SPoul-Henning Kamp 			name++;
1060946bb7a2SPoul-Henning Kamp 			continue;
1061946bb7a2SPoul-Henning Kamp 		}
1062b85f65afSPedro F. Giffuni 		lsp2 = NULL;
1063ce02431fSDoug Rabson 		SLIST_FOREACH(oid, lsp, oid_link) {
1064ce02431fSDoug Rabson 			if (oid->oid_number != *name)
1065946bb7a2SPoul-Henning Kamp 				continue;
1066946bb7a2SPoul-Henning Kamp 
1067946bb7a2SPoul-Henning Kamp 			if (req->oldidx)
1068946bb7a2SPoul-Henning Kamp 				error = SYSCTL_OUT(req, ".", 1);
1069946bb7a2SPoul-Henning Kamp 			if (!error)
1070ce02431fSDoug Rabson 				error = SYSCTL_OUT(req, oid->oid_name,
1071ce02431fSDoug Rabson 					strlen(oid->oid_name));
1072946bb7a2SPoul-Henning Kamp 			if (error)
1073ccecef29SMatthew D Fleming 				goto out;
1074946bb7a2SPoul-Henning Kamp 
1075946bb7a2SPoul-Henning Kamp 			namelen--;
1076946bb7a2SPoul-Henning Kamp 			name++;
1077946bb7a2SPoul-Henning Kamp 
1078ce02431fSDoug Rabson 			if ((oid->oid_kind & CTLTYPE) != CTLTYPE_NODE)
1079946bb7a2SPoul-Henning Kamp 				break;
1080946bb7a2SPoul-Henning Kamp 
1081ce02431fSDoug Rabson 			if (oid->oid_handler)
1082946bb7a2SPoul-Henning Kamp 				break;
1083946bb7a2SPoul-Henning Kamp 
10845127ecb8SMatthew D Fleming 			lsp2 = SYSCTL_CHILDREN(oid);
1085946bb7a2SPoul-Henning Kamp 			break;
1086946bb7a2SPoul-Henning Kamp 		}
10877f4173ccSPoul-Henning Kamp 		lsp = lsp2;
1088946bb7a2SPoul-Henning Kamp 	}
1089ccecef29SMatthew D Fleming 	error = SYSCTL_OUT(req, "", 1);
1090ccecef29SMatthew D Fleming  out:
10917665e341SMateusz Guzik 	SYSCTL_RUNLOCK(&tracker);
1092ccecef29SMatthew D Fleming 	return (error);
1093946bb7a2SPoul-Henning Kamp }
1094946bb7a2SPoul-Henning Kamp 
1095ff66f6a4SRobert Watson /*
1096ff66f6a4SRobert Watson  * XXXRW/JA: Shouldn't return name data for nodes that we don't permit in
1097ff66f6a4SRobert Watson  * capability mode.
1098ff66f6a4SRobert Watson  */
1099382e01c8SKonstantin Belousov static SYSCTL_NODE(_sysctl, CTL_SYSCTL_NAME, name, CTLFLAG_RD |
1100382e01c8SKonstantin Belousov     CTLFLAG_MPSAFE | CTLFLAG_CAPRD, sysctl_sysctl_name, "");
1101946bb7a2SPoul-Henning Kamp 
1102946bb7a2SPoul-Henning Kamp static int
1103ce02431fSDoug Rabson sysctl_sysctl_next_ls(struct sysctl_oid_list *lsp, int *name, u_int namelen,
1104ce02431fSDoug Rabson 	int *next, int *len, int level, struct sysctl_oid **oidpp)
1105946bb7a2SPoul-Henning Kamp {
1106ce02431fSDoug Rabson 	struct sysctl_oid *oidp;
1107946bb7a2SPoul-Henning Kamp 
1108efe0abddSMateusz Guzik 	SYSCTL_ASSERT_LOCKED();
1109946bb7a2SPoul-Henning Kamp 	*len = level;
1110ce02431fSDoug Rabson 	SLIST_FOREACH(oidp, lsp, oid_link) {
1111ce02431fSDoug Rabson 		*next = oidp->oid_number;
1112ce02431fSDoug Rabson 		*oidpp = oidp;
1113946bb7a2SPoul-Henning Kamp 
1114693593b6SAndriy Gapon 		if ((oidp->oid_kind & (CTLFLAG_SKIP | CTLFLAG_DORMANT)) != 0)
1115306e6b83SMaxime Henrion 			continue;
1116306e6b83SMaxime Henrion 
1117946bb7a2SPoul-Henning Kamp 		if (!namelen) {
1118ce02431fSDoug Rabson 			if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
111946003fb3SPawel Jakub Dawidek 				return (0);
1120ce02431fSDoug Rabson 			if (oidp->oid_handler)
1121946bb7a2SPoul-Henning Kamp 				/* We really should call the handler here...*/
112246003fb3SPawel Jakub Dawidek 				return (0);
11235127ecb8SMatthew D Fleming 			lsp = SYSCTL_CHILDREN(oidp);
112461220614SPoul-Henning Kamp 			if (!sysctl_sysctl_next_ls(lsp, 0, 0, next+1,
1125ce02431fSDoug Rabson 				len, level+1, oidpp))
112646003fb3SPawel Jakub Dawidek 				return (0);
112790623e1aSRobert Watson 			goto emptynode;
1128946bb7a2SPoul-Henning Kamp 		}
1129946bb7a2SPoul-Henning Kamp 
1130ce02431fSDoug Rabson 		if (oidp->oid_number < *name)
1131946bb7a2SPoul-Henning Kamp 			continue;
1132946bb7a2SPoul-Henning Kamp 
1133ce02431fSDoug Rabson 		if (oidp->oid_number > *name) {
1134ce02431fSDoug Rabson 			if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
113546003fb3SPawel Jakub Dawidek 				return (0);
1136ce02431fSDoug Rabson 			if (oidp->oid_handler)
113746003fb3SPawel Jakub Dawidek 				return (0);
11385127ecb8SMatthew D Fleming 			lsp = SYSCTL_CHILDREN(oidp);
1139946bb7a2SPoul-Henning Kamp 			if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1,
1140ce02431fSDoug Rabson 				next+1, len, level+1, oidpp))
1141946bb7a2SPoul-Henning Kamp 				return (0);
114261220614SPoul-Henning Kamp 			goto next;
1143946bb7a2SPoul-Henning Kamp 		}
1144ce02431fSDoug Rabson 		if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
1145946bb7a2SPoul-Henning Kamp 			continue;
1146946bb7a2SPoul-Henning Kamp 
1147ce02431fSDoug Rabson 		if (oidp->oid_handler)
1148946bb7a2SPoul-Henning Kamp 			continue;
1149946bb7a2SPoul-Henning Kamp 
11505127ecb8SMatthew D Fleming 		lsp = SYSCTL_CHILDREN(oidp);
1151946bb7a2SPoul-Henning Kamp 		if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1, next+1,
1152ce02431fSDoug Rabson 			len, level+1, oidpp))
1153946bb7a2SPoul-Henning Kamp 			return (0);
115461220614SPoul-Henning Kamp 	next:
1155946bb7a2SPoul-Henning Kamp 		namelen = 1;
115690623e1aSRobert Watson 	emptynode:
1157946bb7a2SPoul-Henning Kamp 		*len = level;
1158946bb7a2SPoul-Henning Kamp 	}
115946003fb3SPawel Jakub Dawidek 	return (1);
1160946bb7a2SPoul-Henning Kamp }
1161946bb7a2SPoul-Henning Kamp 
1162946bb7a2SPoul-Henning Kamp static int
116382d9ae4eSPoul-Henning Kamp sysctl_sysctl_next(SYSCTL_HANDLER_ARGS)
1164946bb7a2SPoul-Henning Kamp {
1165946bb7a2SPoul-Henning Kamp 	int *name = (int *) arg1;
1166946bb7a2SPoul-Henning Kamp 	u_int namelen = arg2;
1167946bb7a2SPoul-Henning Kamp 	int i, j, error;
1168946bb7a2SPoul-Henning Kamp 	struct sysctl_oid *oid;
1169ce02431fSDoug Rabson 	struct sysctl_oid_list *lsp = &sysctl__children;
11707665e341SMateusz Guzik 	struct rm_priotracker tracker;
1171946bb7a2SPoul-Henning Kamp 	int newoid[CTL_MAXNAME];
1172946bb7a2SPoul-Henning Kamp 
11737665e341SMateusz Guzik 	SYSCTL_RLOCK(&tracker);
1174946bb7a2SPoul-Henning Kamp 	i = sysctl_sysctl_next_ls(lsp, name, namelen, newoid, &j, 1, &oid);
11757665e341SMateusz Guzik 	SYSCTL_RUNLOCK(&tracker);
1176946bb7a2SPoul-Henning Kamp 	if (i)
117746003fb3SPawel Jakub Dawidek 		return (ENOENT);
1178946bb7a2SPoul-Henning Kamp 	error = SYSCTL_OUT(req, newoid, j * sizeof (int));
1179946bb7a2SPoul-Henning Kamp 	return (error);
1180946bb7a2SPoul-Henning Kamp }
1181946bb7a2SPoul-Henning Kamp 
1182ff66f6a4SRobert Watson /*
1183ff66f6a4SRobert Watson  * XXXRW/JA: Shouldn't return next data for nodes that we don't permit in
1184ff66f6a4SRobert Watson  * capability mode.
1185ff66f6a4SRobert Watson  */
1186382e01c8SKonstantin Belousov static SYSCTL_NODE(_sysctl, CTL_SYSCTL_NEXT, next, CTLFLAG_RD |
1187382e01c8SKonstantin Belousov     CTLFLAG_MPSAFE | CTLFLAG_CAPRD, sysctl_sysctl_next, "");
1188946bb7a2SPoul-Henning Kamp 
1189946bb7a2SPoul-Henning Kamp static int
1190ce02431fSDoug Rabson name2oid(char *name, int *oid, int *len, struct sysctl_oid **oidpp)
1191946bb7a2SPoul-Henning Kamp {
1192ce02431fSDoug Rabson 	struct sysctl_oid *oidp;
1193ce02431fSDoug Rabson 	struct sysctl_oid_list *lsp = &sysctl__children;
1194946bb7a2SPoul-Henning Kamp 	char *p;
1195946bb7a2SPoul-Henning Kamp 
1196efe0abddSMateusz Guzik 	SYSCTL_ASSERT_LOCKED();
1197ddf9d243SEd Schouten 
1198db9066f7SMarius Strobl 	for (*len = 0; *len < CTL_MAXNAME;) {
1199db9066f7SMarius Strobl 		p = strsep(&name, ".");
1200946bb7a2SPoul-Henning Kamp 
1201ce02431fSDoug Rabson 		oidp = SLIST_FIRST(lsp);
1202db9066f7SMarius Strobl 		for (;; oidp = SLIST_NEXT(oidp, oid_link)) {
1203db9066f7SMarius Strobl 			if (oidp == NULL)
1204db9066f7SMarius Strobl 				return (ENOENT);
1205db9066f7SMarius Strobl 			if (strcmp(p, oidp->oid_name) == 0)
1206db9066f7SMarius Strobl 				break;
1207946bb7a2SPoul-Henning Kamp 		}
1208ce02431fSDoug Rabson 		*oid++ = oidp->oid_number;
1209946bb7a2SPoul-Henning Kamp 		(*len)++;
1210946bb7a2SPoul-Henning Kamp 
1211db9066f7SMarius Strobl 		if (name == NULL || *name == '\0') {
1212ce02431fSDoug Rabson 			if (oidpp)
1213ce02431fSDoug Rabson 				*oidpp = oidp;
1214946bb7a2SPoul-Henning Kamp 			return (0);
1215946bb7a2SPoul-Henning Kamp 		}
1216946bb7a2SPoul-Henning Kamp 
1217ce02431fSDoug Rabson 		if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
1218946bb7a2SPoul-Henning Kamp 			break;
1219946bb7a2SPoul-Henning Kamp 
1220ce02431fSDoug Rabson 		if (oidp->oid_handler)
1221946bb7a2SPoul-Henning Kamp 			break;
1222946bb7a2SPoul-Henning Kamp 
12235127ecb8SMatthew D Fleming 		lsp = SYSCTL_CHILDREN(oidp);
1224946bb7a2SPoul-Henning Kamp 	}
122546003fb3SPawel Jakub Dawidek 	return (ENOENT);
1226946bb7a2SPoul-Henning Kamp }
1227946bb7a2SPoul-Henning Kamp 
1228946bb7a2SPoul-Henning Kamp static int
122982d9ae4eSPoul-Henning Kamp sysctl_sysctl_name2oid(SYSCTL_HANDLER_ARGS)
1230946bb7a2SPoul-Henning Kamp {
1231946bb7a2SPoul-Henning Kamp 	char *p;
1232dd6312a7SMatthew D Fleming 	int error, oid[CTL_MAXNAME], len = 0;
1233b85f65afSPedro F. Giffuni 	struct sysctl_oid *op = NULL;
12347665e341SMateusz Guzik 	struct rm_priotracker tracker;
12358b9817a4SMateusz Guzik 	char buf[32];
1236946bb7a2SPoul-Henning Kamp 
1237946bb7a2SPoul-Henning Kamp 	if (!req->newlen)
123846003fb3SPawel Jakub Dawidek 		return (ENOENT);
12396a5d592aSPoul-Henning Kamp 	if (req->newlen >= MAXPATHLEN)	/* XXX arbitrary, undocumented */
12406a5d592aSPoul-Henning Kamp 		return (ENAMETOOLONG);
1241946bb7a2SPoul-Henning Kamp 
12428b9817a4SMateusz Guzik 	p = buf;
12438b9817a4SMateusz Guzik 	if (req->newlen >= sizeof(buf))
1244a163d034SWarner Losh 		p = malloc(req->newlen+1, M_SYSCTL, M_WAITOK);
1245946bb7a2SPoul-Henning Kamp 
1246946bb7a2SPoul-Henning Kamp 	error = SYSCTL_IN(req, p, req->newlen);
1247946bb7a2SPoul-Henning Kamp 	if (error) {
12488b9817a4SMateusz Guzik 		if (p != buf)
1249946bb7a2SPoul-Henning Kamp 			free(p, M_SYSCTL);
1250946bb7a2SPoul-Henning Kamp 		return (error);
1251946bb7a2SPoul-Henning Kamp 	}
1252946bb7a2SPoul-Henning Kamp 
1253946bb7a2SPoul-Henning Kamp 	p [req->newlen] = '\0';
1254946bb7a2SPoul-Henning Kamp 
12557665e341SMateusz Guzik 	SYSCTL_RLOCK(&tracker);
1256946bb7a2SPoul-Henning Kamp 	error = name2oid(p, oid, &len, &op);
12577665e341SMateusz Guzik 	SYSCTL_RUNLOCK(&tracker);
1258946bb7a2SPoul-Henning Kamp 
12598b9817a4SMateusz Guzik 	if (p != buf)
1260946bb7a2SPoul-Henning Kamp 		free(p, M_SYSCTL);
1261946bb7a2SPoul-Henning Kamp 
1262946bb7a2SPoul-Henning Kamp 	if (error)
1263946bb7a2SPoul-Henning Kamp 		return (error);
1264946bb7a2SPoul-Henning Kamp 
1265946bb7a2SPoul-Henning Kamp 	error = SYSCTL_OUT(req, oid, len * sizeof *oid);
1266946bb7a2SPoul-Henning Kamp 	return (error);
1267946bb7a2SPoul-Henning Kamp }
1268946bb7a2SPoul-Henning Kamp 
1269ff66f6a4SRobert Watson /*
1270ff66f6a4SRobert Watson  * XXXRW/JA: Shouldn't return name2oid data for nodes that we don't permit in
1271ff66f6a4SRobert Watson  * capability mode.
1272ff66f6a4SRobert Watson  */
1273382e01c8SKonstantin Belousov SYSCTL_PROC(_sysctl, CTL_SYSCTL_NAME2OID, name2oid, CTLTYPE_INT | CTLFLAG_RW |
1274382e01c8SKonstantin Belousov     CTLFLAG_ANYBODY | CTLFLAG_MPSAFE | CTLFLAG_CAPRW, 0, 0,
1275382e01c8SKonstantin Belousov     sysctl_sysctl_name2oid, "I", "");
1276946bb7a2SPoul-Henning Kamp 
1277946bb7a2SPoul-Henning Kamp static int
127882d9ae4eSPoul-Henning Kamp sysctl_sysctl_oidfmt(SYSCTL_HANDLER_ARGS)
1279946bb7a2SPoul-Henning Kamp {
1280ce02431fSDoug Rabson 	struct sysctl_oid *oid;
12817665e341SMateusz Guzik 	struct rm_priotracker tracker;
1282226420a4SBrian Feldman 	int error;
1283946bb7a2SPoul-Henning Kamp 
128443cefe8bSRyan Libby 	error = sysctl_wire_old_buffer(req, 0);
128543cefe8bSRyan Libby 	if (error)
128643cefe8bSRyan Libby 		return (error);
128743cefe8bSRyan Libby 
12887665e341SMateusz Guzik 	SYSCTL_RLOCK(&tracker);
1289226420a4SBrian Feldman 	error = sysctl_find_oid(arg1, arg2, &oid, NULL, req);
1290226420a4SBrian Feldman 	if (error)
1291ccecef29SMatthew D Fleming 		goto out;
1292946bb7a2SPoul-Henning Kamp 
1293ccecef29SMatthew D Fleming 	if (oid->oid_fmt == NULL) {
1294ccecef29SMatthew D Fleming 		error = ENOENT;
1295ccecef29SMatthew D Fleming 		goto out;
1296ccecef29SMatthew D Fleming 	}
1297226420a4SBrian Feldman 	error = SYSCTL_OUT(req, &oid->oid_kind, sizeof(oid->oid_kind));
1298226420a4SBrian Feldman 	if (error)
1299ccecef29SMatthew D Fleming 		goto out;
1300226420a4SBrian Feldman 	error = SYSCTL_OUT(req, oid->oid_fmt, strlen(oid->oid_fmt) + 1);
1301ccecef29SMatthew D Fleming  out:
13027665e341SMateusz Guzik 	SYSCTL_RUNLOCK(&tracker);
130365d0bc13SPoul-Henning Kamp 	return (error);
1304946bb7a2SPoul-Henning Kamp }
1305946bb7a2SPoul-Henning Kamp 
1306382e01c8SKonstantin Belousov static SYSCTL_NODE(_sysctl, CTL_SYSCTL_OIDFMT, oidfmt, CTLFLAG_RD |
1307382e01c8SKonstantin Belousov     CTLFLAG_MPSAFE | CTLFLAG_CAPRD, sysctl_sysctl_oidfmt, "");
1308946bb7a2SPoul-Henning Kamp 
13096105f815SLuigi Rizzo static int
13106105f815SLuigi Rizzo sysctl_sysctl_oiddescr(SYSCTL_HANDLER_ARGS)
13116105f815SLuigi Rizzo {
13126105f815SLuigi Rizzo 	struct sysctl_oid *oid;
13137665e341SMateusz Guzik 	struct rm_priotracker tracker;
13146105f815SLuigi Rizzo 	int error;
13156105f815SLuigi Rizzo 
131643cefe8bSRyan Libby 	error = sysctl_wire_old_buffer(req, 0);
131743cefe8bSRyan Libby 	if (error)
131843cefe8bSRyan Libby 		return (error);
131943cefe8bSRyan Libby 
13207665e341SMateusz Guzik 	SYSCTL_RLOCK(&tracker);
13216105f815SLuigi Rizzo 	error = sysctl_find_oid(arg1, arg2, &oid, NULL, req);
13226105f815SLuigi Rizzo 	if (error)
1323ccecef29SMatthew D Fleming 		goto out;
13246105f815SLuigi Rizzo 
1325ccecef29SMatthew D Fleming 	if (oid->oid_descr == NULL) {
1326ccecef29SMatthew D Fleming 		error = ENOENT;
1327ccecef29SMatthew D Fleming 		goto out;
1328ccecef29SMatthew D Fleming 	}
13295937226dSPoul-Henning Kamp 	error = SYSCTL_OUT(req, oid->oid_descr, strlen(oid->oid_descr) + 1);
1330ccecef29SMatthew D Fleming  out:
13317665e341SMateusz Guzik 	SYSCTL_RUNLOCK(&tracker);
13326105f815SLuigi Rizzo 	return (error);
13336105f815SLuigi Rizzo }
13346105f815SLuigi Rizzo 
1335382e01c8SKonstantin Belousov static SYSCTL_NODE(_sysctl, CTL_SYSCTL_OIDDESCR, oiddescr, CTLFLAG_RD |
1336382e01c8SKonstantin Belousov     CTLFLAG_MPSAFE|CTLFLAG_CAPRD, sysctl_sysctl_oiddescr, "");
13376105f815SLuigi Rizzo 
13381e1f3941SEd Schouten static int
13391e1f3941SEd Schouten sysctl_sysctl_oidlabel(SYSCTL_HANDLER_ARGS)
13401e1f3941SEd Schouten {
13411e1f3941SEd Schouten 	struct sysctl_oid *oid;
13421e1f3941SEd Schouten 	struct rm_priotracker tracker;
13431e1f3941SEd Schouten 	int error;
13441e1f3941SEd Schouten 
134543cefe8bSRyan Libby 	error = sysctl_wire_old_buffer(req, 0);
134643cefe8bSRyan Libby 	if (error)
134743cefe8bSRyan Libby 		return (error);
134843cefe8bSRyan Libby 
13491e1f3941SEd Schouten 	SYSCTL_RLOCK(&tracker);
13501e1f3941SEd Schouten 	error = sysctl_find_oid(arg1, arg2, &oid, NULL, req);
13511e1f3941SEd Schouten 	if (error)
13521e1f3941SEd Schouten 		goto out;
13531e1f3941SEd Schouten 
13541e1f3941SEd Schouten 	if (oid->oid_label == NULL) {
13551e1f3941SEd Schouten 		error = ENOENT;
13561e1f3941SEd Schouten 		goto out;
13571e1f3941SEd Schouten 	}
13581e1f3941SEd Schouten 	error = SYSCTL_OUT(req, oid->oid_label, strlen(oid->oid_label) + 1);
13591e1f3941SEd Schouten  out:
13601e1f3941SEd Schouten 	SYSCTL_RUNLOCK(&tracker);
13611e1f3941SEd Schouten 	return (error);
13621e1f3941SEd Schouten }
13631e1f3941SEd Schouten 
1364382e01c8SKonstantin Belousov static SYSCTL_NODE(_sysctl, CTL_SYSCTL_OIDLABEL, oidlabel, CTLFLAG_RD |
1365382e01c8SKonstantin Belousov     CTLFLAG_MPSAFE | CTLFLAG_CAPRD, sysctl_sysctl_oidlabel, "");
13661e1f3941SEd Schouten 
1367946bb7a2SPoul-Henning Kamp /*
1368946bb7a2SPoul-Henning Kamp  * Default "handler" functions.
1369946bb7a2SPoul-Henning Kamp  */
13702e210993SPoul-Henning Kamp 
1371ae0eb976SPoul-Henning Kamp /*
137284e717c4SHans Petter Selasky  * Handle a bool.
137384e717c4SHans Petter Selasky  * Two cases:
137484e717c4SHans Petter Selasky  *     a variable:  point arg1 at it.
137584e717c4SHans Petter Selasky  *     a constant:  pass it in arg2.
137684e717c4SHans Petter Selasky  */
137784e717c4SHans Petter Selasky 
137884e717c4SHans Petter Selasky int
137984e717c4SHans Petter Selasky sysctl_handle_bool(SYSCTL_HANDLER_ARGS)
138084e717c4SHans Petter Selasky {
138184e717c4SHans Petter Selasky 	uint8_t temp;
138284e717c4SHans Petter Selasky 	int error;
138384e717c4SHans Petter Selasky 
138484e717c4SHans Petter Selasky 	/*
138584e717c4SHans Petter Selasky 	 * Attempt to get a coherent snapshot by making a copy of the data.
138684e717c4SHans Petter Selasky 	 */
138784e717c4SHans Petter Selasky 	if (arg1)
138884e717c4SHans Petter Selasky 		temp = *(bool *)arg1 ? 1 : 0;
138984e717c4SHans Petter Selasky 	else
139084e717c4SHans Petter Selasky 		temp = arg2 ? 1 : 0;
139184e717c4SHans Petter Selasky 
139284e717c4SHans Petter Selasky 	error = SYSCTL_OUT(req, &temp, sizeof(temp));
139384e717c4SHans Petter Selasky 	if (error || !req->newptr)
139484e717c4SHans Petter Selasky 		return (error);
139584e717c4SHans Petter Selasky 
139684e717c4SHans Petter Selasky 	if (!arg1)
139784e717c4SHans Petter Selasky 		error = EPERM;
139884e717c4SHans Petter Selasky 	else {
139984e717c4SHans Petter Selasky 		error = SYSCTL_IN(req, &temp, sizeof(temp));
140084e717c4SHans Petter Selasky 		if (!error)
140184e717c4SHans Petter Selasky 			*(bool *)arg1 = temp ? 1 : 0;
140284e717c4SHans Petter Selasky 	}
140384e717c4SHans Petter Selasky 	return (error);
140484e717c4SHans Petter Selasky }
140584e717c4SHans Petter Selasky 
140684e717c4SHans Petter Selasky /*
1407c3220d0bSConrad Meyer  * Handle an int8_t, signed or unsigned.
1408c3220d0bSConrad Meyer  * Two cases:
1409c3220d0bSConrad Meyer  *     a variable:  point arg1 at it.
1410c3220d0bSConrad Meyer  *     a constant:  pass it in arg2.
1411c3220d0bSConrad Meyer  */
1412c3220d0bSConrad Meyer 
1413c3220d0bSConrad Meyer int
1414c3220d0bSConrad Meyer sysctl_handle_8(SYSCTL_HANDLER_ARGS)
1415c3220d0bSConrad Meyer {
1416c3220d0bSConrad Meyer 	int8_t tmpout;
1417c3220d0bSConrad Meyer 	int error = 0;
1418c3220d0bSConrad Meyer 
1419c3220d0bSConrad Meyer 	/*
1420c3220d0bSConrad Meyer 	 * Attempt to get a coherent snapshot by making a copy of the data.
1421c3220d0bSConrad Meyer 	 */
1422c3220d0bSConrad Meyer 	if (arg1)
1423c3220d0bSConrad Meyer 		tmpout = *(int8_t *)arg1;
1424c3220d0bSConrad Meyer 	else
1425c3220d0bSConrad Meyer 		tmpout = arg2;
1426c3220d0bSConrad Meyer 	error = SYSCTL_OUT(req, &tmpout, sizeof(tmpout));
1427c3220d0bSConrad Meyer 
1428c3220d0bSConrad Meyer 	if (error || !req->newptr)
1429c3220d0bSConrad Meyer 		return (error);
1430c3220d0bSConrad Meyer 
1431c3220d0bSConrad Meyer 	if (!arg1)
1432c3220d0bSConrad Meyer 		error = EPERM;
1433c3220d0bSConrad Meyer 	else
1434c3220d0bSConrad Meyer 		error = SYSCTL_IN(req, arg1, sizeof(tmpout));
1435c3220d0bSConrad Meyer 	return (error);
1436c3220d0bSConrad Meyer }
1437c3220d0bSConrad Meyer 
1438c3220d0bSConrad Meyer /*
1439c3220d0bSConrad Meyer  * Handle an int16_t, signed or unsigned.
1440c3220d0bSConrad Meyer  * Two cases:
1441c3220d0bSConrad Meyer  *     a variable:  point arg1 at it.
1442c3220d0bSConrad Meyer  *     a constant:  pass it in arg2.
1443c3220d0bSConrad Meyer  */
1444c3220d0bSConrad Meyer 
1445c3220d0bSConrad Meyer int
1446c3220d0bSConrad Meyer sysctl_handle_16(SYSCTL_HANDLER_ARGS)
1447c3220d0bSConrad Meyer {
1448c3220d0bSConrad Meyer 	int16_t tmpout;
1449c3220d0bSConrad Meyer 	int error = 0;
1450c3220d0bSConrad Meyer 
1451c3220d0bSConrad Meyer 	/*
1452c3220d0bSConrad Meyer 	 * Attempt to get a coherent snapshot by making a copy of the data.
1453c3220d0bSConrad Meyer 	 */
1454c3220d0bSConrad Meyer 	if (arg1)
1455c3220d0bSConrad Meyer 		tmpout = *(int16_t *)arg1;
1456c3220d0bSConrad Meyer 	else
1457c3220d0bSConrad Meyer 		tmpout = arg2;
1458c3220d0bSConrad Meyer 	error = SYSCTL_OUT(req, &tmpout, sizeof(tmpout));
1459c3220d0bSConrad Meyer 
1460c3220d0bSConrad Meyer 	if (error || !req->newptr)
1461c3220d0bSConrad Meyer 		return (error);
1462c3220d0bSConrad Meyer 
1463c3220d0bSConrad Meyer 	if (!arg1)
1464c3220d0bSConrad Meyer 		error = EPERM;
1465c3220d0bSConrad Meyer 	else
1466c3220d0bSConrad Meyer 		error = SYSCTL_IN(req, arg1, sizeof(tmpout));
1467c3220d0bSConrad Meyer 	return (error);
1468c3220d0bSConrad Meyer }
1469c3220d0bSConrad Meyer 
1470c3220d0bSConrad Meyer /*
1471be87839eSConrad Meyer  * Handle an int32_t, signed or unsigned.
1472be87839eSConrad Meyer  * Two cases:
1473be87839eSConrad Meyer  *     a variable:  point arg1 at it.
1474be87839eSConrad Meyer  *     a constant:  pass it in arg2.
1475be87839eSConrad Meyer  */
1476be87839eSConrad Meyer 
1477be87839eSConrad Meyer int
1478be87839eSConrad Meyer sysctl_handle_32(SYSCTL_HANDLER_ARGS)
1479be87839eSConrad Meyer {
1480be87839eSConrad Meyer 	int32_t tmpout;
1481be87839eSConrad Meyer 	int error = 0;
1482be87839eSConrad Meyer 
1483be87839eSConrad Meyer 	/*
1484be87839eSConrad Meyer 	 * Attempt to get a coherent snapshot by making a copy of the data.
1485be87839eSConrad Meyer 	 */
1486be87839eSConrad Meyer 	if (arg1)
1487be87839eSConrad Meyer 		tmpout = *(int32_t *)arg1;
1488be87839eSConrad Meyer 	else
1489be87839eSConrad Meyer 		tmpout = arg2;
1490be87839eSConrad Meyer 	error = SYSCTL_OUT(req, &tmpout, sizeof(tmpout));
1491be87839eSConrad Meyer 
1492be87839eSConrad Meyer 	if (error || !req->newptr)
1493be87839eSConrad Meyer 		return (error);
1494be87839eSConrad Meyer 
1495be87839eSConrad Meyer 	if (!arg1)
1496be87839eSConrad Meyer 		error = EPERM;
1497be87839eSConrad Meyer 	else
1498be87839eSConrad Meyer 		error = SYSCTL_IN(req, arg1, sizeof(tmpout));
1499be87839eSConrad Meyer 	return (error);
1500be87839eSConrad Meyer }
1501be87839eSConrad Meyer 
1502be87839eSConrad Meyer /*
1503486bddb0SDoug Rabson  * Handle an int, signed or unsigned.
1504ae0eb976SPoul-Henning Kamp  * Two cases:
1505ae0eb976SPoul-Henning Kamp  *     a variable:  point arg1 at it.
1506ae0eb976SPoul-Henning Kamp  *     a constant:  pass it in arg2.
1507ae0eb976SPoul-Henning Kamp  */
1508ae0eb976SPoul-Henning Kamp 
15093a34a5c3SPoul-Henning Kamp int
151082d9ae4eSPoul-Henning Kamp sysctl_handle_int(SYSCTL_HANDLER_ARGS)
1511b396cd83SPoul-Henning Kamp {
15129e74cba3SDon Lewis 	int tmpout, error = 0;
1513b396cd83SPoul-Henning Kamp 
15149e74cba3SDon Lewis 	/*
15159e74cba3SDon Lewis 	 * Attempt to get a coherent snapshot by making a copy of the data.
15169e74cba3SDon Lewis 	 */
1517ae0eb976SPoul-Henning Kamp 	if (arg1)
15189e74cba3SDon Lewis 		tmpout = *(int *)arg1;
15191fbf1f71SBruce Evans 	else
15209e74cba3SDon Lewis 		tmpout = arg2;
15219e74cba3SDon Lewis 	error = SYSCTL_OUT(req, &tmpout, sizeof(int));
1522b396cd83SPoul-Henning Kamp 
1523ae0eb976SPoul-Henning Kamp 	if (error || !req->newptr)
1524ae0eb976SPoul-Henning Kamp 		return (error);
1525b396cd83SPoul-Henning Kamp 
1526ae0eb976SPoul-Henning Kamp 	if (!arg1)
1527ae0eb976SPoul-Henning Kamp 		error = EPERM;
1528ae0eb976SPoul-Henning Kamp 	else
1529ae0eb976SPoul-Henning Kamp 		error = SYSCTL_IN(req, arg1, sizeof(int));
1530ae0eb976SPoul-Henning Kamp 	return (error);
1531b396cd83SPoul-Henning Kamp }
1532b396cd83SPoul-Henning Kamp 
1533a4684d74SAndre Oppermann /*
1534a4684d74SAndre Oppermann  * Based on on sysctl_handle_int() convert milliseconds into ticks.
1535eddfbb76SRobert Watson  * Note: this is used by TCP.
1536a4684d74SAndre Oppermann  */
1537a4684d74SAndre Oppermann 
1538a4684d74SAndre Oppermann int
1539a4684d74SAndre Oppermann sysctl_msec_to_ticks(SYSCTL_HANDLER_ARGS)
1540a4684d74SAndre Oppermann {
1541a4684d74SAndre Oppermann 	int error, s, tt;
1542a4684d74SAndre Oppermann 
1543f6dfe47aSMarko Zec 	tt = *(int *)arg1;
1544a4684d74SAndre Oppermann 	s = (int)((int64_t)tt * 1000 / hz);
1545a4684d74SAndre Oppermann 
1546a4684d74SAndre Oppermann 	error = sysctl_handle_int(oidp, &s, 0, req);
1547a4684d74SAndre Oppermann 	if (error || !req->newptr)
1548a4684d74SAndre Oppermann 		return (error);
1549a4684d74SAndre Oppermann 
1550a4684d74SAndre Oppermann 	tt = (int)((int64_t)s * hz / 1000);
1551a4684d74SAndre Oppermann 	if (tt < 1)
1552a4684d74SAndre Oppermann 		return (EINVAL);
1553a4684d74SAndre Oppermann 
1554f6dfe47aSMarko Zec 	*(int *)arg1 = tt;
1555a4684d74SAndre Oppermann 	return (0);
1556a4684d74SAndre Oppermann }
1557a4684d74SAndre Oppermann 
1558ae0eb976SPoul-Henning Kamp /*
155918716f9fSMarius Strobl  * Handle a long, signed or unsigned.
156018716f9fSMarius Strobl  * Two cases:
156118716f9fSMarius Strobl  *     a variable:  point arg1 at it.
156218716f9fSMarius Strobl  *     a constant:  pass it in arg2.
1563069e9bc1SDoug Rabson  */
1564069e9bc1SDoug Rabson 
1565069e9bc1SDoug Rabson int
156682d9ae4eSPoul-Henning Kamp sysctl_handle_long(SYSCTL_HANDLER_ARGS)
1567069e9bc1SDoug Rabson {
1568069e9bc1SDoug Rabson 	int error = 0;
1569a7bc3102SPeter Wemm 	long tmplong;
1570a7bc3102SPeter Wemm #ifdef SCTL_MASK32
1571a7bc3102SPeter Wemm 	int tmpint;
1572a7bc3102SPeter Wemm #endif
1573069e9bc1SDoug Rabson 
15749e74cba3SDon Lewis 	/*
15759e74cba3SDon Lewis 	 * Attempt to get a coherent snapshot by making a copy of the data.
15769e74cba3SDon Lewis 	 */
1577bdc5f017SMarius Strobl 	if (arg1)
1578a7bc3102SPeter Wemm 		tmplong = *(long *)arg1;
1579bdc5f017SMarius Strobl 	else
1580bdc5f017SMarius Strobl 		tmplong = arg2;
1581a7bc3102SPeter Wemm #ifdef SCTL_MASK32
1582a7bc3102SPeter Wemm 	if (req->flags & SCTL_MASK32) {
1583a7bc3102SPeter Wemm 		tmpint = tmplong;
1584a7bc3102SPeter Wemm 		error = SYSCTL_OUT(req, &tmpint, sizeof(int));
1585a7bc3102SPeter Wemm 	} else
1586a7bc3102SPeter Wemm #endif
1587a7bc3102SPeter Wemm 		error = SYSCTL_OUT(req, &tmplong, sizeof(long));
1588069e9bc1SDoug Rabson 
1589069e9bc1SDoug Rabson 	if (error || !req->newptr)
1590069e9bc1SDoug Rabson 		return (error);
1591069e9bc1SDoug Rabson 
1592bdc5f017SMarius Strobl 	if (!arg1)
1593bdc5f017SMarius Strobl 		error = EPERM;
1594a7bc3102SPeter Wemm #ifdef SCTL_MASK32
1595bdc5f017SMarius Strobl 	else if (req->flags & SCTL_MASK32) {
1596a7bc3102SPeter Wemm 		error = SYSCTL_IN(req, &tmpint, sizeof(int));
1597a7bc3102SPeter Wemm 		*(long *)arg1 = (long)tmpint;
1598bdc5f017SMarius Strobl 	}
1599a7bc3102SPeter Wemm #endif
1600bdc5f017SMarius Strobl 	else
1601069e9bc1SDoug Rabson 		error = SYSCTL_IN(req, arg1, sizeof(long));
1602069e9bc1SDoug Rabson 	return (error);
1603069e9bc1SDoug Rabson }
1604069e9bc1SDoug Rabson 
1605069e9bc1SDoug Rabson /*
160618716f9fSMarius Strobl  * Handle a 64 bit int, signed or unsigned.
160718716f9fSMarius Strobl  * Two cases:
160818716f9fSMarius Strobl  *     a variable:  point arg1 at it.
160918716f9fSMarius Strobl  *     a constant:  pass it in arg2.
1610df82ff50SDavid Malone  */
1611df82ff50SDavid Malone int
1612cbc134adSMatthew D Fleming sysctl_handle_64(SYSCTL_HANDLER_ARGS)
1613df82ff50SDavid Malone {
1614df82ff50SDavid Malone 	int error = 0;
1615df82ff50SDavid Malone 	uint64_t tmpout;
1616df82ff50SDavid Malone 
1617df82ff50SDavid Malone 	/*
1618df82ff50SDavid Malone 	 * Attempt to get a coherent snapshot by making a copy of the data.
1619df82ff50SDavid Malone 	 */
1620bdc5f017SMarius Strobl 	if (arg1)
1621df82ff50SDavid Malone 		tmpout = *(uint64_t *)arg1;
1622bdc5f017SMarius Strobl 	else
1623bdc5f017SMarius Strobl 		tmpout = arg2;
1624df82ff50SDavid Malone 	error = SYSCTL_OUT(req, &tmpout, sizeof(uint64_t));
1625df82ff50SDavid Malone 
1626df82ff50SDavid Malone 	if (error || !req->newptr)
1627df82ff50SDavid Malone 		return (error);
1628df82ff50SDavid Malone 
1629bdc5f017SMarius Strobl 	if (!arg1)
1630bdc5f017SMarius Strobl 		error = EPERM;
1631bdc5f017SMarius Strobl 	else
1632df82ff50SDavid Malone 		error = SYSCTL_IN(req, arg1, sizeof(uint64_t));
1633df82ff50SDavid Malone 	return (error);
1634df82ff50SDavid Malone }
1635df82ff50SDavid Malone 
1636df82ff50SDavid Malone /*
1637ae0eb976SPoul-Henning Kamp  * Handle our generic '\0' terminated 'C' string.
1638ae0eb976SPoul-Henning Kamp  * Two cases:
1639ae0eb976SPoul-Henning Kamp  * 	a variable string:  point arg1 at it, arg2 is max length.
1640ae0eb976SPoul-Henning Kamp  * 	a constant string:  point arg1 at it, arg2 is zero.
1641ae0eb976SPoul-Henning Kamp  */
1642ae0eb976SPoul-Henning Kamp 
16433a34a5c3SPoul-Henning Kamp int
164482d9ae4eSPoul-Henning Kamp sysctl_handle_string(SYSCTL_HANDLER_ARGS)
1645b396cd83SPoul-Henning Kamp {
1646*210176adSPawel Biernacki 	char *tmparg;
164737a107a4SGlen Barber 	size_t outlen;
164830d58d6bSMateusz Guzik 	int error = 0, ro_string = 0;
1649e80fb434SRobert Drehmel 
16506a3287f8SHans Petter Selasky 	/*
1651*210176adSPawel Biernacki 	 * If the sysctl isn't writable, microoptimise and treat it as a
1652*210176adSPawel Biernacki 	 * const string.
16536a3287f8SHans Petter Selasky 	 * A zero-length buffer indicates a fixed size read-only
1654088c17b4SConrad Meyer 	 * string.  In ddb, don't worry about trying to make a malloced
1655088c17b4SConrad Meyer 	 * snapshot.
16566a3287f8SHans Petter Selasky 	 */
1657*210176adSPawel Biernacki 	if (!(oidp->oid_kind & CTLFLAG_WR) || arg2 == 0 || kdb_active) {
16586a3287f8SHans Petter Selasky 		arg2 = strlen((char *)arg1) + 1;
165930d58d6bSMateusz Guzik 		ro_string = 1;
166030d58d6bSMateusz Guzik 	}
16613da1cf1eSHans Petter Selasky 
1662af3b2549SHans Petter Selasky 	if (req->oldptr != NULL) {
166330d58d6bSMateusz Guzik 		if (ro_string) {
166430d58d6bSMateusz Guzik 			tmparg = arg1;
1665*210176adSPawel Biernacki 			outlen = strlen(tmparg) + 1;
166630d58d6bSMateusz Guzik 		} else {
1667af3b2549SHans Petter Selasky 			tmparg = malloc(arg2, M_SYSCTLTMP, M_WAITOK);
1668*210176adSPawel Biernacki 			sx_slock(&sysctlstringlock);
1669af3b2549SHans Petter Selasky 			memcpy(tmparg, arg1, arg2);
1670*210176adSPawel Biernacki 			sx_sunlock(&sysctlstringlock);
1671*210176adSPawel Biernacki 			outlen = strlen(tmparg) + 1;
167230d58d6bSMateusz Guzik 		}
1673af3b2549SHans Petter Selasky 
167437a107a4SGlen Barber 		error = SYSCTL_OUT(req, tmparg, outlen);
167537a107a4SGlen Barber 
167630d58d6bSMateusz Guzik 		if (!ro_string)
1677af3b2549SHans Petter Selasky 			free(tmparg, M_SYSCTLTMP);
1678af3b2549SHans Petter Selasky 	} else {
1679*210176adSPawel Biernacki 		if (!ro_string)
1680*210176adSPawel Biernacki 			sx_slock(&sysctlstringlock);
1681*210176adSPawel Biernacki 		outlen = strlen((char *)arg1) + 1;
1682*210176adSPawel Biernacki 		if (!ro_string)
1683*210176adSPawel Biernacki 			sx_sunlock(&sysctlstringlock);
1684af3b2549SHans Petter Selasky 		error = SYSCTL_OUT(req, NULL, outlen);
1685af3b2549SHans Petter Selasky 	}
16866a5d592aSPoul-Henning Kamp 	if (error || !req->newptr)
1687ae0eb976SPoul-Henning Kamp 		return (error);
1688ae0eb976SPoul-Henning Kamp 
1689*210176adSPawel Biernacki 	if (req->newlen - req->newidx >= arg2 ||
1690*210176adSPawel Biernacki 	    req->newlen - req->newidx <= 0) {
16916a5d592aSPoul-Henning Kamp 		error = EINVAL;
1692ae0eb976SPoul-Henning Kamp 	} else {
1693*210176adSPawel Biernacki 		arg2 = req->newlen - req->newidx;
1694*210176adSPawel Biernacki 		tmparg = malloc(arg2, M_SYSCTLTMP, M_WAITOK);
1695*210176adSPawel Biernacki 
1696*210176adSPawel Biernacki 		error = copyin((const char *)req->newptr + req->newidx,
1697*210176adSPawel Biernacki 		    tmparg, arg2);
1698*210176adSPawel Biernacki 		if (error) {
1699*210176adSPawel Biernacki 			free(tmparg, M_SYSCTLTMP);
1700*210176adSPawel Biernacki 			return (error);
1701*210176adSPawel Biernacki 		}
1702*210176adSPawel Biernacki 
1703*210176adSPawel Biernacki 		sx_xlock(&sysctlstringlock);
1704*210176adSPawel Biernacki 		memcpy(arg1, tmparg, arg2);
1705ae0eb976SPoul-Henning Kamp 		((char *)arg1)[arg2] = '\0';
1706*210176adSPawel Biernacki 		sx_xunlock(&sysctlstringlock);
1707*210176adSPawel Biernacki 		free(tmparg, M_SYSCTLTMP);
1708*210176adSPawel Biernacki 		req->newidx += arg2;
1709b396cd83SPoul-Henning Kamp 	}
17102e210993SPoul-Henning Kamp 	return (error);
1711b396cd83SPoul-Henning Kamp }
1712b396cd83SPoul-Henning Kamp 
1713ae0eb976SPoul-Henning Kamp /*
1714ae0eb976SPoul-Henning Kamp  * Handle any kind of opaque data.
1715ae0eb976SPoul-Henning Kamp  * arg1 points to it, arg2 is the size.
1716ae0eb976SPoul-Henning Kamp  */
1717ae0eb976SPoul-Henning Kamp 
17183a34a5c3SPoul-Henning Kamp int
171982d9ae4eSPoul-Henning Kamp sysctl_handle_opaque(SYSCTL_HANDLER_ARGS)
1720b396cd83SPoul-Henning Kamp {
1721dcf59a59SBruce M Simpson 	int error, tries;
1722dcf59a59SBruce M Simpson 	u_int generation;
1723f0597024SBruce M Simpson 	struct sysctl_req req2;
1724b396cd83SPoul-Henning Kamp 
17259e74cba3SDon Lewis 	/*
1726dcf59a59SBruce M Simpson 	 * Attempt to get a coherent snapshot, by using the thread
1727dcf59a59SBruce M Simpson 	 * pre-emption counter updated from within mi_switch() to
1728dcf59a59SBruce M Simpson 	 * determine if we were pre-empted during a bcopy() or
1729dcf59a59SBruce M Simpson 	 * copyout(). Make 3 attempts at doing this before giving up.
1730dcf59a59SBruce M Simpson 	 * If we encounter an error, stop immediately.
17319e74cba3SDon Lewis 	 */
1732dcf59a59SBruce M Simpson 	tries = 0;
1733f0597024SBruce M Simpson 	req2 = *req;
1734f0597024SBruce M Simpson retry:
1735dcf59a59SBruce M Simpson 	generation = curthread->td_generation;
1736ae0eb976SPoul-Henning Kamp 	error = SYSCTL_OUT(req, arg1, arg2);
1737dcf59a59SBruce M Simpson 	if (error)
1738ae0eb976SPoul-Henning Kamp 		return (error);
1739dcf59a59SBruce M Simpson 	tries++;
1740f0597024SBruce M Simpson 	if (generation != curthread->td_generation && tries < 3) {
1741f0597024SBruce M Simpson 		*req = req2;
1742f0597024SBruce M Simpson 		goto retry;
1743f0597024SBruce M Simpson 	}
1744ae0eb976SPoul-Henning Kamp 
1745ae0eb976SPoul-Henning Kamp 	error = SYSCTL_IN(req, arg1, arg2);
1746ae0eb976SPoul-Henning Kamp 
1747ae0eb976SPoul-Henning Kamp 	return (error);
1748b396cd83SPoul-Henning Kamp }
1749ae0eb976SPoul-Henning Kamp 
1750deae269aSPoul-Henning Kamp /*
1751003ffd57SWarner Losh  * Based on on sysctl_handle_int() convert microseconds to a sbintime.
1752003ffd57SWarner Losh  */
1753003ffd57SWarner Losh int
1754003ffd57SWarner Losh sysctl_usec_to_sbintime(SYSCTL_HANDLER_ARGS)
1755003ffd57SWarner Losh {
1756003ffd57SWarner Losh 	int error;
1757003ffd57SWarner Losh 	int64_t tt;
1758003ffd57SWarner Losh 	sbintime_t sb;
1759003ffd57SWarner Losh 
1760003ffd57SWarner Losh 	tt = *(int64_t *)arg1;
176136173f69SWarner Losh 	sb = sbttous(tt);
1762003ffd57SWarner Losh 
1763003ffd57SWarner Losh 	error = sysctl_handle_64(oidp, &sb, 0, req);
1764003ffd57SWarner Losh 	if (error || !req->newptr)
1765003ffd57SWarner Losh 		return (error);
1766003ffd57SWarner Losh 
176736173f69SWarner Losh 	tt = ustosbt(sb);
1768003ffd57SWarner Losh 	*(int64_t *)arg1 = tt;
1769003ffd57SWarner Losh 
1770003ffd57SWarner Losh 	return (0);
1771003ffd57SWarner Losh }
1772003ffd57SWarner Losh 
1773003ffd57SWarner Losh /*
1774003ffd57SWarner Losh  * Based on on sysctl_handle_int() convert milliseconds to a sbintime.
1775003ffd57SWarner Losh  */
1776003ffd57SWarner Losh int
1777003ffd57SWarner Losh sysctl_msec_to_sbintime(SYSCTL_HANDLER_ARGS)
1778003ffd57SWarner Losh {
1779003ffd57SWarner Losh 	int error;
1780003ffd57SWarner Losh 	int64_t tt;
1781003ffd57SWarner Losh 	sbintime_t sb;
1782003ffd57SWarner Losh 
1783003ffd57SWarner Losh 	tt = *(int64_t *)arg1;
178436173f69SWarner Losh 	sb = sbttoms(tt);
1785003ffd57SWarner Losh 
1786003ffd57SWarner Losh 	error = sysctl_handle_64(oidp, &sb, 0, req);
1787003ffd57SWarner Losh 	if (error || !req->newptr)
1788003ffd57SWarner Losh 		return (error);
1789003ffd57SWarner Losh 
179036173f69SWarner Losh 	tt = mstosbt(sb);
1791003ffd57SWarner Losh 	*(int64_t *)arg1 = tt;
1792003ffd57SWarner Losh 
1793003ffd57SWarner Losh 	return (0);
1794003ffd57SWarner Losh }
1795003ffd57SWarner Losh 
17960f702183SJohn Baldwin /*
17970f702183SJohn Baldwin  * Convert seconds to a struct timeval.  Intended for use with
17980f702183SJohn Baldwin  * intervals and thus does not permit negative seconds.
17990f702183SJohn Baldwin  */
18000f702183SJohn Baldwin int
18010f702183SJohn Baldwin sysctl_sec_to_timeval(SYSCTL_HANDLER_ARGS)
18020f702183SJohn Baldwin {
18030f702183SJohn Baldwin 	struct timeval *tv;
18040f702183SJohn Baldwin 	int error, secs;
18050f702183SJohn Baldwin 
18060f702183SJohn Baldwin 	tv = arg1;
18070f702183SJohn Baldwin 	secs = tv->tv_sec;
18080f702183SJohn Baldwin 
18090f702183SJohn Baldwin 	error = sysctl_handle_int(oidp, &secs, 0, req);
18100f702183SJohn Baldwin 	if (error || req->newptr == NULL)
18110f702183SJohn Baldwin 		return (error);
18120f702183SJohn Baldwin 
18130f702183SJohn Baldwin 	if (secs < 0)
18140f702183SJohn Baldwin 		return (EINVAL);
18150f702183SJohn Baldwin 	tv->tv_sec = secs;
18160f702183SJohn Baldwin 
18170f702183SJohn Baldwin 	return (0);
18180f702183SJohn Baldwin }
1819003ffd57SWarner Losh 
1820003ffd57SWarner Losh /*
1821deae269aSPoul-Henning Kamp  * Transfer functions to/from kernel space.
1822deae269aSPoul-Henning Kamp  * XXX: rather untested at this point
1823deae269aSPoul-Henning Kamp  */
1824deae269aSPoul-Henning Kamp static int
1825069e9bc1SDoug Rabson sysctl_old_kernel(struct sysctl_req *req, const void *p, size_t l)
1826ae0eb976SPoul-Henning Kamp {
1827069e9bc1SDoug Rabson 	size_t i = 0;
1828deae269aSPoul-Henning Kamp 
1829deae269aSPoul-Henning Kamp 	if (req->oldptr) {
1830069e9bc1SDoug Rabson 		i = l;
18313a515572SThomas Moestl 		if (req->oldlen <= req->oldidx)
18323a515572SThomas Moestl 			i = 0;
18333a515572SThomas Moestl 		else
1834069e9bc1SDoug Rabson 			if (i > req->oldlen - req->oldidx)
1835069e9bc1SDoug Rabson 				i = req->oldlen - req->oldidx;
1836deae269aSPoul-Henning Kamp 		if (i > 0)
183709a8dfa2SBruce Evans 			bcopy(p, (char *)req->oldptr + req->oldidx, i);
1838ae0eb976SPoul-Henning Kamp 	}
18396b72d8dbSKonstantin Belousov 	req->oldidx += l;
18401c346c70SNate Williams 	if (req->oldptr && i != l)
1841ae0eb976SPoul-Henning Kamp 		return (ENOMEM);
18422e210993SPoul-Henning Kamp 	return (0);
1843ae0eb976SPoul-Henning Kamp }
1844ae0eb976SPoul-Henning Kamp 
1845deae269aSPoul-Henning Kamp static int
1846069e9bc1SDoug Rabson sysctl_new_kernel(struct sysctl_req *req, void *p, size_t l)
1847ae0eb976SPoul-Henning Kamp {
1848deae269aSPoul-Henning Kamp 	if (!req->newptr)
184946003fb3SPawel Jakub Dawidek 		return (0);
1850deae269aSPoul-Henning Kamp 	if (req->newlen - req->newidx < l)
1851ae0eb976SPoul-Henning Kamp 		return (EINVAL);
185210f7b12cSBrooks Davis 	bcopy((const char *)req->newptr + req->newidx, p, l);
1853ae0eb976SPoul-Henning Kamp 	req->newidx += l;
1854ae0eb976SPoul-Henning Kamp 	return (0);
1855ae0eb976SPoul-Henning Kamp }
1856ae0eb976SPoul-Henning Kamp 
18571c346c70SNate Williams int
1858b40ce416SJulian Elischer kernel_sysctl(struct thread *td, int *name, u_int namelen, void *old,
1859a7bc3102SPeter Wemm     size_t *oldlenp, void *new, size_t newlen, size_t *retval, int flags)
18601c346c70SNate Williams {
18611c346c70SNate Williams 	int error = 0;
18621c346c70SNate Williams 	struct sysctl_req req;
18631c346c70SNate Williams 
18641c346c70SNate Williams 	bzero(&req, sizeof req);
18651c346c70SNate Williams 
1866ce178806SRobert Watson 	req.td = td;
1867a7bc3102SPeter Wemm 	req.flags = flags;
18681c346c70SNate Williams 
18691c346c70SNate Williams 	if (oldlenp) {
18701c346c70SNate Williams 		req.oldlen = *oldlenp;
18711c346c70SNate Williams 	}
1872a961520cSDon Lewis 	req.validlen = req.oldlen;
18731c346c70SNate Williams 
18741c346c70SNate Williams 	if (old) {
18751c346c70SNate Williams 		req.oldptr= old;
18761c346c70SNate Williams 	}
18771c346c70SNate Williams 
1878b8edb44cSDima Dorfman 	if (new != NULL) {
18791c346c70SNate Williams 		req.newlen = newlen;
18801c346c70SNate Williams 		req.newptr = new;
18811c346c70SNate Williams 	}
18821c346c70SNate Williams 
18831c346c70SNate Williams 	req.oldfunc = sysctl_old_kernel;
18841c346c70SNate Williams 	req.newfunc = sysctl_new_kernel;
188573d6f851SMatthew D Fleming 	req.lock = REQ_UNWIRED;
18861c346c70SNate Williams 
18871c346c70SNate Williams 	error = sysctl_root(0, name, namelen, &req);
1888f0597024SBruce M Simpson 
1889a961520cSDon Lewis 	if (req.lock == REQ_WIRED && req.validlen > 0)
1890a961520cSDon Lewis 		vsunlock(req.oldptr, req.validlen);
18911c346c70SNate Williams 
18921c346c70SNate Williams 	if (error && error != ENOMEM)
18931c346c70SNate Williams 		return (error);
18941c346c70SNate Williams 
18951c346c70SNate Williams 	if (retval) {
1896a961520cSDon Lewis 		if (req.oldptr && req.oldidx > req.validlen)
1897a961520cSDon Lewis 			*retval = req.validlen;
18981c346c70SNate Williams 		else
18991c346c70SNate Williams 			*retval = req.oldidx;
19001c346c70SNate Williams 	}
19011c346c70SNate Williams 	return (error);
19021c346c70SNate Williams }
19031c346c70SNate Williams 
19041890520aSJonathan Lemon int
1905b40ce416SJulian Elischer kernel_sysctlbyname(struct thread *td, char *name, void *old, size_t *oldlenp,
1906a7bc3102SPeter Wemm     void *new, size_t newlen, size_t *retval, int flags)
19071890520aSJonathan Lemon {
19081890520aSJonathan Lemon         int oid[CTL_MAXNAME];
19092f7f966cSMatt Jacob         size_t oidlen, plen;
19102f7f966cSMatt Jacob 	int error;
19111890520aSJonathan Lemon 
1912382e01c8SKonstantin Belousov 	oid[0] = CTL_SYSCTL;
1913382e01c8SKonstantin Belousov 	oid[1] = CTL_SYSCTL_NAME2OID;
19141890520aSJonathan Lemon 	oidlen = sizeof(oid);
19151890520aSJonathan Lemon 
1916b40ce416SJulian Elischer 	error = kernel_sysctl(td, oid, 2, oid, &oidlen,
1917a7bc3102SPeter Wemm 	    (void *)name, strlen(name), &plen, flags);
19181890520aSJonathan Lemon 	if (error)
19191890520aSJonathan Lemon 		return (error);
19201890520aSJonathan Lemon 
1921b40ce416SJulian Elischer 	error = kernel_sysctl(td, oid, plen / sizeof(int), old, oldlenp,
1922a7bc3102SPeter Wemm 	    new, newlen, retval, flags);
19231890520aSJonathan Lemon 	return (error);
19241890520aSJonathan Lemon }
19251890520aSJonathan Lemon 
1926deae269aSPoul-Henning Kamp /*
1927deae269aSPoul-Henning Kamp  * Transfer function to/from user space.
1928deae269aSPoul-Henning Kamp  */
1929deae269aSPoul-Henning Kamp static int
1930069e9bc1SDoug Rabson sysctl_old_user(struct sysctl_req *req, const void *p, size_t l)
1931ae0eb976SPoul-Henning Kamp {
193247934cefSDon Lewis 	size_t i, len, origidx;
19335730afc9SAlan Cox 	int error;
1934ae0eb976SPoul-Henning Kamp 
193547934cefSDon Lewis 	origidx = req->oldidx;
193647934cefSDon Lewis 	req->oldidx += l;
19376b72d8dbSKonstantin Belousov 	if (req->oldptr == NULL)
193847934cefSDon Lewis 		return (0);
1939417ab24fSChristian S.J. Peron 	/*
1940417ab24fSChristian S.J. Peron 	 * If we have not wired the user supplied buffer and we are currently
1941417ab24fSChristian S.J. Peron 	 * holding locks, drop a witness warning, as it's possible that
1942417ab24fSChristian S.J. Peron 	 * write operations to the user page can sleep.
1943417ab24fSChristian S.J. Peron 	 */
1944417ab24fSChristian S.J. Peron 	if (req->lock != REQ_WIRED)
194526306795SJohn Baldwin 		WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
194626306795SJohn Baldwin 		    "sysctl_old_user()");
1947069e9bc1SDoug Rabson 	i = l;
1948a961520cSDon Lewis 	len = req->validlen;
194947934cefSDon Lewis 	if (len <= origidx)
19503a515572SThomas Moestl 		i = 0;
195147934cefSDon Lewis 	else {
195247934cefSDon Lewis 		if (i > len - origidx)
195347934cefSDon Lewis 			i = len - origidx;
19545730afc9SAlan Cox 		if (req->lock == REQ_WIRED) {
19555730afc9SAlan Cox 			error = copyout_nofault(p, (char *)req->oldptr +
19565730afc9SAlan Cox 			    origidx, i);
19575730afc9SAlan Cox 		} else
195847934cefSDon Lewis 			error = copyout(p, (char *)req->oldptr + origidx, i);
19595730afc9SAlan Cox 		if (error != 0)
1960ae0eb976SPoul-Henning Kamp 			return (error);
19615730afc9SAlan Cox 	}
196247934cefSDon Lewis 	if (i < l)
1963ae0eb976SPoul-Henning Kamp 		return (ENOMEM);
1964deae269aSPoul-Henning Kamp 	return (0);
1965ae0eb976SPoul-Henning Kamp }
1966ae0eb976SPoul-Henning Kamp 
1967deae269aSPoul-Henning Kamp static int
1968069e9bc1SDoug Rabson sysctl_new_user(struct sysctl_req *req, void *p, size_t l)
1969ae0eb976SPoul-Henning Kamp {
197016cd04a3SPoul-Henning Kamp 	int error;
1971deae269aSPoul-Henning Kamp 
1972deae269aSPoul-Henning Kamp 	if (!req->newptr)
197346003fb3SPawel Jakub Dawidek 		return (0);
1974deae269aSPoul-Henning Kamp 	if (req->newlen - req->newidx < l)
1975ae0eb976SPoul-Henning Kamp 		return (EINVAL);
1976d8339a26SChristian S.J. Peron 	WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
1977d8339a26SChristian S.J. Peron 	    "sysctl_new_user()");
197810f7b12cSBrooks Davis 	error = copyin((const char *)req->newptr + req->newidx, p, l);
1979ae0eb976SPoul-Henning Kamp 	req->newidx += l;
1980ae0eb976SPoul-Henning Kamp 	return (error);
1981b396cd83SPoul-Henning Kamp }
1982b396cd83SPoul-Henning Kamp 
19830600730dSDon Lewis /*
19840600730dSDon Lewis  * Wire the user space destination buffer.  If set to a value greater than
19850600730dSDon Lewis  * zero, the len parameter limits the maximum amount of wired memory.
19860600730dSDon Lewis  */
198747934cefSDon Lewis int
19880600730dSDon Lewis sysctl_wire_old_buffer(struct sysctl_req *req, size_t len)
19890600730dSDon Lewis {
199047934cefSDon Lewis 	int ret;
1991433e2f47SDag-Erling Smørgrav 	size_t wiredlen;
199247934cefSDon Lewis 
199347934cefSDon Lewis 	wiredlen = (len > 0 && len < req->oldlen) ? len : req->oldlen;
199447934cefSDon Lewis 	ret = 0;
199573d6f851SMatthew D Fleming 	if (req->lock != REQ_WIRED && req->oldptr &&
19965be99846SBruce M Simpson 	    req->oldfunc == sysctl_old_user) {
19978ac3e8e9SDon Lewis 		if (wiredlen != 0) {
1998ce8660e3SDon Lewis 			ret = vslock(req->oldptr, wiredlen);
1999b4adfcf2SBrian Feldman 			if (ret != 0) {
2000b4adfcf2SBrian Feldman 				if (ret != ENOMEM)
20018ac3e8e9SDon Lewis 					return (ret);
2002b4adfcf2SBrian Feldman 				wiredlen = 0;
2003b4adfcf2SBrian Feldman 			}
20048ac3e8e9SDon Lewis 		}
20055be99846SBruce M Simpson 		req->lock = REQ_WIRED;
2006a961520cSDon Lewis 		req->validlen = wiredlen;
20070600730dSDon Lewis 	}
20088ac3e8e9SDon Lewis 	return (0);
200947934cefSDon Lewis }
20100600730dSDon Lewis 
20112e210993SPoul-Henning Kamp int
2012226420a4SBrian Feldman sysctl_find_oid(int *name, u_int namelen, struct sysctl_oid **noid,
2013226420a4SBrian Feldman     int *nindx, struct sysctl_req *req)
20142e210993SPoul-Henning Kamp {
2015d0bb6f25SMatthew D Fleming 	struct sysctl_oid_list *lsp;
2016ce02431fSDoug Rabson 	struct sysctl_oid *oid;
2017226420a4SBrian Feldman 	int indx;
20182e210993SPoul-Henning Kamp 
2019efe0abddSMateusz Guzik 	SYSCTL_ASSERT_LOCKED();
2020d0bb6f25SMatthew D Fleming 	lsp = &sysctl__children;
20212e210993SPoul-Henning Kamp 	indx = 0;
2022d0bb6f25SMatthew D Fleming 	while (indx < CTL_MAXNAME) {
2023d0bb6f25SMatthew D Fleming 		SLIST_FOREACH(oid, lsp, oid_link) {
2024d0bb6f25SMatthew D Fleming 			if (oid->oid_number == name[indx])
2025d0bb6f25SMatthew D Fleming 				break;
2026d0bb6f25SMatthew D Fleming 		}
2027d0bb6f25SMatthew D Fleming 		if (oid == NULL)
2028d0bb6f25SMatthew D Fleming 			return (ENOENT);
2029d0bb6f25SMatthew D Fleming 
20302e210993SPoul-Henning Kamp 		indx++;
2031ce02431fSDoug Rabson 		if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
2032d0bb6f25SMatthew D Fleming 			if (oid->oid_handler != NULL || indx == namelen) {
2033226420a4SBrian Feldman 				*noid = oid;
2034226420a4SBrian Feldman 				if (nindx != NULL)
2035226420a4SBrian Feldman 					*nindx = indx;
2036ccecef29SMatthew D Fleming 				KASSERT((oid->oid_kind & CTLFLAG_DYING) == 0,
2037ccecef29SMatthew D Fleming 				    ("%s found DYING node %p", __func__, oid));
2038226420a4SBrian Feldman 				return (0);
2039226420a4SBrian Feldman 			}
2040d0bb6f25SMatthew D Fleming 			lsp = SYSCTL_CHILDREN(oid);
2041226420a4SBrian Feldman 		} else if (indx == namelen) {
2042693593b6SAndriy Gapon 			if ((oid->oid_kind & CTLFLAG_DORMANT) != 0)
2043693593b6SAndriy Gapon 				return (ENOENT);
2044226420a4SBrian Feldman 			*noid = oid;
2045226420a4SBrian Feldman 			if (nindx != NULL)
2046226420a4SBrian Feldman 				*nindx = indx;
2047ccecef29SMatthew D Fleming 			KASSERT((oid->oid_kind & CTLFLAG_DYING) == 0,
2048ccecef29SMatthew D Fleming 			    ("%s found DYING node %p", __func__, oid));
2049226420a4SBrian Feldman 			return (0);
20502e210993SPoul-Henning Kamp 		} else {
2051226420a4SBrian Feldman 			return (ENOTDIR);
20522e210993SPoul-Henning Kamp 		}
20532e210993SPoul-Henning Kamp 	}
2054226420a4SBrian Feldman 	return (ENOENT);
2055226420a4SBrian Feldman }
2056226420a4SBrian Feldman 
2057226420a4SBrian Feldman /*
2058226420a4SBrian Feldman  * Traverse our tree, and find the right node, execute whatever it points
2059226420a4SBrian Feldman  * to, and return the resulting error code.
2060226420a4SBrian Feldman  */
2061226420a4SBrian Feldman 
206237c84183SPoul-Henning Kamp static int
206382d9ae4eSPoul-Henning Kamp sysctl_root(SYSCTL_HANDLER_ARGS)
2064226420a4SBrian Feldman {
2065226420a4SBrian Feldman 	struct sysctl_oid *oid;
20667665e341SMateusz Guzik 	struct rm_priotracker tracker;
2067fe41ca53SMatthew Dillon 	int error, indx, lvl;
2068226420a4SBrian Feldman 
20697665e341SMateusz Guzik 	SYSCTL_RLOCK(&tracker);
2070ddf9d243SEd Schouten 
2071226420a4SBrian Feldman 	error = sysctl_find_oid(arg1, arg2, &oid, &indx, req);
2072226420a4SBrian Feldman 	if (error)
20737665e341SMateusz Guzik 		goto out;
2074226420a4SBrian Feldman 
2075226420a4SBrian Feldman 	if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
2076226420a4SBrian Feldman 		/*
2077226420a4SBrian Feldman 		 * You can't call a sysctl when it's a node, but has
2078226420a4SBrian Feldman 		 * no handler.  Inform the user that it's a node.
2079226420a4SBrian Feldman 		 * The indx may or may not be the same as namelen.
2080226420a4SBrian Feldman 		 */
20817665e341SMateusz Guzik 		if (oid->oid_handler == NULL) {
20827665e341SMateusz Guzik 			error = EISDIR;
20837665e341SMateusz Guzik 			goto out;
20847665e341SMateusz Guzik 		}
2085226420a4SBrian Feldman 	}
2086226420a4SBrian Feldman 
2087c2f413afSRobert Watson 	/* Is this sysctl writable? */
20887665e341SMateusz Guzik 	if (req->newptr && !(oid->oid_kind & CTLFLAG_WR)) {
20897665e341SMateusz Guzik 		error = EPERM;
20907665e341SMateusz Guzik 		goto out;
20917665e341SMateusz Guzik 	}
20922e210993SPoul-Henning Kamp 
20937906271fSRobert Watson 	KASSERT(req->td != NULL, ("sysctl_root(): req->td == NULL"));
20947906271fSRobert Watson 
2095ff66f6a4SRobert Watson #ifdef CAPABILITY_MODE
2096ff66f6a4SRobert Watson 	/*
2097ff66f6a4SRobert Watson 	 * If the process is in capability mode, then don't permit reading or
2098ff66f6a4SRobert Watson 	 * writing unless specifically granted for the node.
2099ff66f6a4SRobert Watson 	 */
2100ff66f6a4SRobert Watson 	if (IN_CAPABILITY_MODE(req->td)) {
21017665e341SMateusz Guzik 		if ((req->oldptr && !(oid->oid_kind & CTLFLAG_CAPRD)) ||
21027665e341SMateusz Guzik 		    (req->newptr && !(oid->oid_kind & CTLFLAG_CAPWR))) {
21037665e341SMateusz Guzik 			error = EPERM;
21047665e341SMateusz Guzik 			goto out;
21057665e341SMateusz Guzik 		}
2106ff66f6a4SRobert Watson 	}
2107ff66f6a4SRobert Watson #endif
2108ff66f6a4SRobert Watson 
2109c2f413afSRobert Watson 	/* Is this sysctl sensitive to securelevels? */
2110c2f413afSRobert Watson 	if (req->newptr && (oid->oid_kind & CTLFLAG_SECURE)) {
2111fe41ca53SMatthew Dillon 		lvl = (oid->oid_kind & CTLMASK_SECURE) >> CTLSHIFT_SECURE;
2112fe41ca53SMatthew Dillon 		error = securelevel_gt(req->td->td_ucred, lvl);
2113c2f413afSRobert Watson 		if (error)
21147665e341SMateusz Guzik 			goto out;
2115c2f413afSRobert Watson 	}
2116c2f413afSRobert Watson 
2117c2f413afSRobert Watson 	/* Is this sysctl writable by only privileged users? */
2118c2f413afSRobert Watson 	if (req->newptr && !(oid->oid_kind & CTLFLAG_ANYBODY)) {
2119eb79e1c7SBjoern A. Zeeb 		int priv;
2120eb79e1c7SBjoern A. Zeeb 
2121c2f413afSRobert Watson 		if (oid->oid_kind & CTLFLAG_PRISON)
2122eb79e1c7SBjoern A. Zeeb 			priv = PRIV_SYSCTL_WRITEJAIL;
2123eb79e1c7SBjoern A. Zeeb #ifdef VIMAGE
2124eb79e1c7SBjoern A. Zeeb 		else if ((oid->oid_kind & CTLFLAG_VNET) &&
2125eb79e1c7SBjoern A. Zeeb 		     prison_owns_vnet(req->td->td_ucred))
2126eb79e1c7SBjoern A. Zeeb 			priv = PRIV_SYSCTL_WRITEJAIL;
2127eb79e1c7SBjoern A. Zeeb #endif
2128c2f413afSRobert Watson 		else
2129eb79e1c7SBjoern A. Zeeb 			priv = PRIV_SYSCTL_WRITE;
2130eb79e1c7SBjoern A. Zeeb 		error = priv_check(req->td, priv);
2131c2f413afSRobert Watson 		if (error)
21327665e341SMateusz Guzik 			goto out;
2133c2f413afSRobert Watson 	}
21343ac9f819SPoul-Henning Kamp 
21357665e341SMateusz Guzik 	if (!oid->oid_handler) {
21367665e341SMateusz Guzik 		error = EINVAL;
21377665e341SMateusz Guzik 		goto out;
21387665e341SMateusz Guzik 	}
21392e210993SPoul-Henning Kamp 
214063dba32bSPawel Jakub Dawidek 	if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
214100fbcda8SAlexander Kabaev 		arg1 = (int *)arg1 + indx;
214263dba32bSPawel Jakub Dawidek 		arg2 -= indx;
214363dba32bSPawel Jakub Dawidek 	} else {
214463dba32bSPawel Jakub Dawidek 		arg1 = oid->oid_arg1;
214563dba32bSPawel Jakub Dawidek 		arg2 = oid->oid_arg2;
214663dba32bSPawel Jakub Dawidek 	}
214763dba32bSPawel Jakub Dawidek #ifdef MAC
214830d239bcSRobert Watson 	error = mac_system_check_sysctl(req->td->td_ucred, oid, arg1, arg2,
2149ae0eb976SPoul-Henning Kamp 	    req);
215063dba32bSPawel Jakub Dawidek 	if (error != 0)
21517665e341SMateusz Guzik 		goto out;
215263dba32bSPawel Jakub Dawidek #endif
2153b5c32cf4SGleb Smirnoff #ifdef VIMAGE
2154b5c32cf4SGleb Smirnoff 	if ((oid->oid_kind & CTLFLAG_VNET) && arg1 != NULL)
2155b5c32cf4SGleb Smirnoff 		arg1 = (void *)(curvnet->vnet_data_base + (uintptr_t)arg1);
2156b5c32cf4SGleb Smirnoff #endif
21577665e341SMateusz Guzik 	error = sysctl_root_handler_locked(oid, arg1, arg2, req, &tracker);
215863dba32bSPawel Jakub Dawidek 
21597665e341SMateusz Guzik out:
21607665e341SMateusz Guzik 	SYSCTL_RUNLOCK(&tracker);
2161226420a4SBrian Feldman 	return (error);
21622e210993SPoul-Henning Kamp }
21632e210993SPoul-Henning Kamp 
2164d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_
2165b8da2396SPoul-Henning Kamp struct sysctl_args {
2166b8da2396SPoul-Henning Kamp 	int	*name;
2167b8da2396SPoul-Henning Kamp 	u_int	namelen;
2168b8da2396SPoul-Henning Kamp 	void	*old;
2169b8da2396SPoul-Henning Kamp 	size_t	*oldlenp;
2170b8da2396SPoul-Henning Kamp 	void	*new;
2171b8da2396SPoul-Henning Kamp 	size_t	newlen;
2172b8da2396SPoul-Henning Kamp };
2173d2d3e875SBruce Evans #endif
2174df8bae1dSRodney W. Grimes int
21758451d0ddSKip Macy sys___sysctl(struct thread *td, struct sysctl_args *uap)
2176df8bae1dSRodney W. Grimes {
2177875b66a0SJohn Baldwin 	int error, i, name[CTL_MAXNAME];
2178069e9bc1SDoug Rabson 	size_t j;
2179b396cd83SPoul-Henning Kamp 
2180df8bae1dSRodney W. Grimes 	if (uap->namelen > CTL_MAXNAME || uap->namelen < 2)
2181df8bae1dSRodney W. Grimes 		return (EINVAL);
2182b396cd83SPoul-Henning Kamp 
2183797f2d22SPoul-Henning Kamp  	error = copyin(uap->name, &name, uap->namelen * sizeof(int));
2184797f2d22SPoul-Henning Kamp  	if (error)
2185df8bae1dSRodney W. Grimes 		return (error);
2186df8bae1dSRodney W. Grimes 
2187b40ce416SJulian Elischer 	error = userland_sysctl(td, name, uap->namelen,
2188b8da2396SPoul-Henning Kamp 		uap->old, uap->oldlenp, 0,
2189a7bc3102SPeter Wemm 		uap->new, uap->newlen, &j, 0);
2190deae269aSPoul-Henning Kamp 	if (error && error != ENOMEM)
2191ddf9d243SEd Schouten 		return (error);
21924cfe4790SEd Schouten 	if (uap->oldlenp) {
2193875b66a0SJohn Baldwin 		i = copyout(&j, uap->oldlenp, sizeof(j));
21944cfe4790SEd Schouten 		if (i)
21954cfe4790SEd Schouten 			return (i);
21964cfe4790SEd Schouten 	}
2197deae269aSPoul-Henning Kamp 	return (error);
2198b8da2396SPoul-Henning Kamp }
2199b8da2396SPoul-Henning Kamp 
2200d05b53e0SMateusz Guzik int
2201d05b53e0SMateusz Guzik kern___sysctlbyname(struct thread *td, const char *oname, size_t namelen,
2202d05b53e0SMateusz Guzik     void *old, size_t *oldlenp, void *new, size_t newlen, size_t *retval,
2203d05b53e0SMateusz Guzik     int flags, bool inkernel)
2204d05b53e0SMateusz Guzik {
2205d05b53e0SMateusz Guzik 	int oid[CTL_MAXNAME];
2206d05b53e0SMateusz Guzik 	char namebuf[16];
2207d05b53e0SMateusz Guzik 	char *name;
2208d05b53e0SMateusz Guzik 	size_t oidlen;
2209d05b53e0SMateusz Guzik 	int error;
2210d05b53e0SMateusz Guzik 
2211d05b53e0SMateusz Guzik 	if (namelen > MAXPATHLEN || namelen == 0)
2212d05b53e0SMateusz Guzik 		return (EINVAL);
2213d05b53e0SMateusz Guzik 	name = namebuf;
2214d05b53e0SMateusz Guzik 	if (namelen > sizeof(namebuf))
2215d05b53e0SMateusz Guzik 		name = malloc(namelen, M_SYSCTL, M_WAITOK);
2216d05b53e0SMateusz Guzik 	error = copyin(oname, name, namelen);
2217d05b53e0SMateusz Guzik 	if (error != 0)
2218d05b53e0SMateusz Guzik 		goto out;
2219d05b53e0SMateusz Guzik 
2220382e01c8SKonstantin Belousov 	oid[0] = CTL_SYSCTL;
2221382e01c8SKonstantin Belousov 	oid[1] = CTL_SYSCTL_NAME2OID;
2222d05b53e0SMateusz Guzik 	oidlen = sizeof(oid);
2223d05b53e0SMateusz Guzik 	error = kernel_sysctl(td, oid, 2, oid, &oidlen, (void *)name, namelen,
2224d05b53e0SMateusz Guzik 	    retval, flags);
2225d05b53e0SMateusz Guzik 	if (error != 0)
2226d05b53e0SMateusz Guzik 		goto out;
2227d05b53e0SMateusz Guzik 	error = userland_sysctl(td, oid, *retval / sizeof(int), old, oldlenp,
2228d05b53e0SMateusz Guzik 	    inkernel, new, newlen, retval, flags);
2229d05b53e0SMateusz Guzik 
2230d05b53e0SMateusz Guzik out:
2231d05b53e0SMateusz Guzik 	if (namelen > sizeof(namebuf))
2232d05b53e0SMateusz Guzik 		free(name, M_SYSCTL);
2233d05b53e0SMateusz Guzik 	return (error);
2234d05b53e0SMateusz Guzik }
2235d05b53e0SMateusz Guzik 
2236d05b53e0SMateusz Guzik #ifndef	_SYS_SYSPROTO_H_
2237d05b53e0SMateusz Guzik struct __sysctlbyname_args {
2238d05b53e0SMateusz Guzik 	const char	*name;
2239d05b53e0SMateusz Guzik 	size_t	namelen;
2240d05b53e0SMateusz Guzik 	void	*old;
2241d05b53e0SMateusz Guzik 	size_t	*oldlenp;
2242d05b53e0SMateusz Guzik 	void	*new;
2243d05b53e0SMateusz Guzik 	size_t	newlen;
2244d05b53e0SMateusz Guzik };
2245d05b53e0SMateusz Guzik #endif
2246d05b53e0SMateusz Guzik int
2247d05b53e0SMateusz Guzik sys___sysctlbyname(struct thread *td, struct __sysctlbyname_args *uap)
2248d05b53e0SMateusz Guzik {
2249d05b53e0SMateusz Guzik 	size_t rv;
2250d05b53e0SMateusz Guzik 	int error;
2251d05b53e0SMateusz Guzik 
2252d05b53e0SMateusz Guzik 	error = kern___sysctlbyname(td, uap->name, uap->namelen, uap->old,
2253d05b53e0SMateusz Guzik 	    uap->oldlenp, uap->new, uap->newlen, &rv, 0, 0);
2254d05b53e0SMateusz Guzik 	if (error != 0)
2255d05b53e0SMateusz Guzik 		return (error);
2256d05b53e0SMateusz Guzik 	if (uap->oldlenp != NULL)
2257d05b53e0SMateusz Guzik 		error = copyout(&rv, uap->oldlenp, sizeof(rv));
2258d05b53e0SMateusz Guzik 
2259d05b53e0SMateusz Guzik 	return (error);
2260d05b53e0SMateusz Guzik }
2261d05b53e0SMateusz Guzik 
2262b8da2396SPoul-Henning Kamp /*
2263b8da2396SPoul-Henning Kamp  * This is used from various compatibility syscalls too.  That's why name
2264b8da2396SPoul-Henning Kamp  * must be in kernel space.
2265b8da2396SPoul-Henning Kamp  */
2266b8da2396SPoul-Henning Kamp int
2267b40ce416SJulian Elischer userland_sysctl(struct thread *td, int *name, u_int namelen, void *old,
226810f7b12cSBrooks Davis     size_t *oldlenp, int inkernel, const void *new, size_t newlen,
226910f7b12cSBrooks Davis     size_t *retval, int flags)
2270b8da2396SPoul-Henning Kamp {
22713e829b18SJohn Baldwin 	int error = 0, memlocked;
2272a961520cSDon Lewis 	struct sysctl_req req;
2273ae0eb976SPoul-Henning Kamp 
2274ae0eb976SPoul-Henning Kamp 	bzero(&req, sizeof req);
2275b8da2396SPoul-Henning Kamp 
2276ce178806SRobert Watson 	req.td = td;
2277a7bc3102SPeter Wemm 	req.flags = flags;
227816cd04a3SPoul-Henning Kamp 
2279b8da2396SPoul-Henning Kamp 	if (oldlenp) {
2280b8da2396SPoul-Henning Kamp 		if (inkernel) {
2281ae0eb976SPoul-Henning Kamp 			req.oldlen = *oldlenp;
2282b8da2396SPoul-Henning Kamp 		} else {
2283deae269aSPoul-Henning Kamp 			error = copyin(oldlenp, &req.oldlen, sizeof(*oldlenp));
2284b8da2396SPoul-Henning Kamp 			if (error)
2285b8da2396SPoul-Henning Kamp 				return (error);
2286b8da2396SPoul-Henning Kamp 		}
2287b8da2396SPoul-Henning Kamp 	}
2288a961520cSDon Lewis 	req.validlen = req.oldlen;
2289ae0eb976SPoul-Henning Kamp 	req.oldptr = old;
22902e210993SPoul-Henning Kamp 
2291b8edb44cSDima Dorfman 	if (new != NULL) {
2292ae0eb976SPoul-Henning Kamp 		req.newlen = newlen;
2293ae0eb976SPoul-Henning Kamp 		req.newptr = new;
2294b396cd83SPoul-Henning Kamp 	}
2295b396cd83SPoul-Henning Kamp 
2296ae0eb976SPoul-Henning Kamp 	req.oldfunc = sysctl_old_user;
2297ae0eb976SPoul-Henning Kamp 	req.newfunc = sysctl_new_user;
229873d6f851SMatthew D Fleming 	req.lock = REQ_UNWIRED;
22994b2af45fSPoul-Henning Kamp 
2300a56be37eSJohn Baldwin #ifdef KTRACE
2301a56be37eSJohn Baldwin 	if (KTRPOINT(curthread, KTR_SYSCTL))
2302a56be37eSJohn Baldwin 		ktrsysctl(name, namelen);
2303a56be37eSJohn Baldwin #endif
23049b8de76bSMateusz Guzik 	memlocked = 0;
23059b8de76bSMateusz Guzik 	if (req.oldptr && req.oldlen > 4 * PAGE_SIZE) {
23063e829b18SJohn Baldwin 		memlocked = 1;
23073e829b18SJohn Baldwin 		sx_xlock(&sysctlmemlock);
23089b8de76bSMateusz Guzik 	}
23099ed47d01SJamie Gritton 	CURVNET_SET(TD_TO_VNET(td));
2310ae0eb976SPoul-Henning Kamp 
2311af80b2c9SKonstantin Belousov 	for (;;) {
2312a961520cSDon Lewis 		req.oldidx = 0;
2313a961520cSDon Lewis 		req.newidx = 0;
2314a961520cSDon Lewis 		error = sysctl_root(0, name, namelen, &req);
2315af80b2c9SKonstantin Belousov 		if (error != EAGAIN)
2316af80b2c9SKonstantin Belousov 			break;
23173d08a76bSMatthew D Fleming 		kern_yield(PRI_USER);
2318af80b2c9SKonstantin Belousov 	}
2319b396cd83SPoul-Henning Kamp 
232097021c24SMarko Zec 	CURVNET_RESTORE();
23214b2af45fSPoul-Henning Kamp 
2322ddf9d243SEd Schouten 	if (req.lock == REQ_WIRED && req.validlen > 0)
2323ddf9d243SEd Schouten 		vsunlock(req.oldptr, req.validlen);
23243e829b18SJohn Baldwin 	if (memlocked)
23253e829b18SJohn Baldwin 		sx_xunlock(&sysctlmemlock);
2326ddf9d243SEd Schouten 
2327deae269aSPoul-Henning Kamp 	if (error && error != ENOMEM)
2328deae269aSPoul-Henning Kamp 		return (error);
2329deae269aSPoul-Henning Kamp 
2330deae269aSPoul-Henning Kamp 	if (retval) {
2331a961520cSDon Lewis 		if (req.oldptr && req.oldidx > req.validlen)
2332a961520cSDon Lewis 			*retval = req.validlen;
2333deae269aSPoul-Henning Kamp 		else
2334deae269aSPoul-Henning Kamp 			*retval = req.oldidx;
2335b8da2396SPoul-Henning Kamp 	}
23362e210993SPoul-Henning Kamp 	return (error);
2337df8bae1dSRodney W. Grimes }
23384e657159SMatthew D Fleming 
23394e657159SMatthew D Fleming /*
234000f0e671SMatthew D Fleming  * Drain into a sysctl struct.  The user buffer should be wired if a page
234100f0e671SMatthew D Fleming  * fault would cause issue.
23424e657159SMatthew D Fleming  */
23434e657159SMatthew D Fleming static int
23444e657159SMatthew D Fleming sbuf_sysctl_drain(void *arg, const char *data, int len)
23454e657159SMatthew D Fleming {
23464e657159SMatthew D Fleming 	struct sysctl_req *req = arg;
23474e657159SMatthew D Fleming 	int error;
23484e657159SMatthew D Fleming 
23494e657159SMatthew D Fleming 	error = SYSCTL_OUT(req, data, len);
23504e657159SMatthew D Fleming 	KASSERT(error >= 0, ("Got unexpected negative value %d", error));
23514e657159SMatthew D Fleming 	return (error == 0 ? len : -error);
23524e657159SMatthew D Fleming }
23534e657159SMatthew D Fleming 
23544e657159SMatthew D Fleming struct sbuf *
23554e657159SMatthew D Fleming sbuf_new_for_sysctl(struct sbuf *s, char *buf, int length,
23564e657159SMatthew D Fleming     struct sysctl_req *req)
23574e657159SMatthew D Fleming {
23584e657159SMatthew D Fleming 
235928349245SIan Lepore 	/* Supply a default buffer size if none given. */
236028349245SIan Lepore 	if (buf == NULL && length == 0)
236128349245SIan Lepore 		length = 64;
23621eafc078SIan Lepore 	s = sbuf_new(s, buf, length, SBUF_FIXEDLEN | SBUF_INCLUDENUL);
23634e657159SMatthew D Fleming 	sbuf_set_drain(s, sbuf_sysctl_drain, req);
23644e657159SMatthew D Fleming 	return (s);
23654e657159SMatthew D Fleming }
2366088c17b4SConrad Meyer 
2367088c17b4SConrad Meyer #ifdef DDB
2368088c17b4SConrad Meyer 
2369088c17b4SConrad Meyer /* The current OID the debugger is working with */
2370088c17b4SConrad Meyer static struct sysctl_oid *g_ddb_oid;
2371088c17b4SConrad Meyer 
2372088c17b4SConrad Meyer /* The current flags specified by the user */
2373088c17b4SConrad Meyer static int g_ddb_sysctl_flags;
2374088c17b4SConrad Meyer 
2375088c17b4SConrad Meyer /* Check to see if the last sysctl printed */
2376088c17b4SConrad Meyer static int g_ddb_sysctl_printed;
2377088c17b4SConrad Meyer 
2378088c17b4SConrad Meyer static const int ctl_sign[CTLTYPE+1] = {
2379088c17b4SConrad Meyer 	[CTLTYPE_INT] = 1,
2380088c17b4SConrad Meyer 	[CTLTYPE_LONG] = 1,
2381088c17b4SConrad Meyer 	[CTLTYPE_S8] = 1,
2382088c17b4SConrad Meyer 	[CTLTYPE_S16] = 1,
2383088c17b4SConrad Meyer 	[CTLTYPE_S32] = 1,
2384088c17b4SConrad Meyer 	[CTLTYPE_S64] = 1,
2385088c17b4SConrad Meyer };
2386088c17b4SConrad Meyer 
2387088c17b4SConrad Meyer static const int ctl_size[CTLTYPE+1] = {
2388088c17b4SConrad Meyer 	[CTLTYPE_INT] = sizeof(int),
2389088c17b4SConrad Meyer 	[CTLTYPE_UINT] = sizeof(u_int),
2390088c17b4SConrad Meyer 	[CTLTYPE_LONG] = sizeof(long),
2391088c17b4SConrad Meyer 	[CTLTYPE_ULONG] = sizeof(u_long),
2392088c17b4SConrad Meyer 	[CTLTYPE_S8] = sizeof(int8_t),
2393088c17b4SConrad Meyer 	[CTLTYPE_S16] = sizeof(int16_t),
2394088c17b4SConrad Meyer 	[CTLTYPE_S32] = sizeof(int32_t),
2395088c17b4SConrad Meyer 	[CTLTYPE_S64] = sizeof(int64_t),
2396088c17b4SConrad Meyer 	[CTLTYPE_U8] = sizeof(uint8_t),
2397088c17b4SConrad Meyer 	[CTLTYPE_U16] = sizeof(uint16_t),
2398088c17b4SConrad Meyer 	[CTLTYPE_U32] = sizeof(uint32_t),
2399088c17b4SConrad Meyer 	[CTLTYPE_U64] = sizeof(uint64_t),
2400088c17b4SConrad Meyer };
2401088c17b4SConrad Meyer 
2402088c17b4SConrad Meyer #define DB_SYSCTL_NAME_ONLY	0x001	/* Compare with -N */
2403088c17b4SConrad Meyer #define DB_SYSCTL_VALUE_ONLY	0x002	/* Compare with -n */
2404088c17b4SConrad Meyer #define DB_SYSCTL_OPAQUE	0x004	/* Compare with -o */
2405088c17b4SConrad Meyer #define DB_SYSCTL_HEX		0x008	/* Compare with -x */
2406088c17b4SConrad Meyer 
2407088c17b4SConrad Meyer #define DB_SYSCTL_SAFE_ONLY	0x100	/* Only simple types */
2408088c17b4SConrad Meyer 
2409088c17b4SConrad Meyer static const char db_sysctl_modifs[] = {
2410088c17b4SConrad Meyer 	'N', 'n', 'o', 'x',
2411088c17b4SConrad Meyer };
2412088c17b4SConrad Meyer 
2413088c17b4SConrad Meyer static const int db_sysctl_modif_values[] = {
2414088c17b4SConrad Meyer 	DB_SYSCTL_NAME_ONLY, DB_SYSCTL_VALUE_ONLY,
2415088c17b4SConrad Meyer 	DB_SYSCTL_OPAQUE, DB_SYSCTL_HEX,
2416088c17b4SConrad Meyer };
2417088c17b4SConrad Meyer 
2418088c17b4SConrad Meyer /* Handlers considered safe to print while recursing */
2419088c17b4SConrad Meyer static int (* const db_safe_handlers[])(SYSCTL_HANDLER_ARGS) = {
2420088c17b4SConrad Meyer 	sysctl_handle_bool,
2421088c17b4SConrad Meyer 	sysctl_handle_8,
2422088c17b4SConrad Meyer 	sysctl_handle_16,
2423088c17b4SConrad Meyer 	sysctl_handle_32,
2424088c17b4SConrad Meyer 	sysctl_handle_64,
2425088c17b4SConrad Meyer 	sysctl_handle_int,
2426088c17b4SConrad Meyer 	sysctl_handle_long,
2427088c17b4SConrad Meyer 	sysctl_handle_string,
2428088c17b4SConrad Meyer 	sysctl_handle_opaque,
2429088c17b4SConrad Meyer };
2430088c17b4SConrad Meyer 
2431088c17b4SConrad Meyer /*
2432088c17b4SConrad Meyer  * Use in place of sysctl_old_kernel to print sysctl values.
2433088c17b4SConrad Meyer  *
2434088c17b4SConrad Meyer  * Compare to the output handling in show_var from sbin/sysctl/sysctl.c
2435088c17b4SConrad Meyer  */
2436088c17b4SConrad Meyer static int
2437088c17b4SConrad Meyer sysctl_old_ddb(struct sysctl_req *req, const void *ptr, size_t len)
2438088c17b4SConrad Meyer {
2439088c17b4SConrad Meyer 	const u_char *val, *p;
2440088c17b4SConrad Meyer 	const char *sep1;
2441088c17b4SConrad Meyer 	size_t intlen, slen;
2442088c17b4SConrad Meyer 	uintmax_t umv;
2443088c17b4SConrad Meyer 	intmax_t mv;
2444088c17b4SConrad Meyer 	int sign, ctltype, hexlen, xflag, error;
2445088c17b4SConrad Meyer 
2446088c17b4SConrad Meyer 	/* Suppress false-positive GCC uninitialized variable warnings */
2447088c17b4SConrad Meyer 	mv = 0;
2448088c17b4SConrad Meyer 	umv = 0;
2449088c17b4SConrad Meyer 
2450088c17b4SConrad Meyer 	slen = len;
2451088c17b4SConrad Meyer 	val = p = ptr;
2452088c17b4SConrad Meyer 
2453088c17b4SConrad Meyer 	if (ptr == NULL) {
2454088c17b4SConrad Meyer 		error = 0;
2455088c17b4SConrad Meyer 		goto out;
2456088c17b4SConrad Meyer 	}
2457088c17b4SConrad Meyer 
2458088c17b4SConrad Meyer 	/* We are going to print */
2459088c17b4SConrad Meyer 	g_ddb_sysctl_printed = 1;
2460088c17b4SConrad Meyer 
2461088c17b4SConrad Meyer 	xflag = g_ddb_sysctl_flags & DB_SYSCTL_HEX;
2462088c17b4SConrad Meyer 
2463088c17b4SConrad Meyer 	ctltype = (g_ddb_oid->oid_kind & CTLTYPE);
2464088c17b4SConrad Meyer 	sign = ctl_sign[ctltype];
2465088c17b4SConrad Meyer 	intlen = ctl_size[ctltype];
2466088c17b4SConrad Meyer 
2467088c17b4SConrad Meyer 	switch (ctltype) {
2468088c17b4SConrad Meyer 	case CTLTYPE_NODE:
2469088c17b4SConrad Meyer 	case CTLTYPE_STRING:
2470088c17b4SConrad Meyer 		db_printf("%.*s", (int) len, (const char *) p);
2471088c17b4SConrad Meyer 		error = 0;
2472088c17b4SConrad Meyer 		goto out;
2473088c17b4SConrad Meyer 
2474088c17b4SConrad Meyer 	case CTLTYPE_INT:
2475088c17b4SConrad Meyer 	case CTLTYPE_UINT:
2476088c17b4SConrad Meyer 	case CTLTYPE_LONG:
2477088c17b4SConrad Meyer 	case CTLTYPE_ULONG:
2478088c17b4SConrad Meyer 	case CTLTYPE_S8:
2479088c17b4SConrad Meyer 	case CTLTYPE_S16:
2480088c17b4SConrad Meyer 	case CTLTYPE_S32:
2481088c17b4SConrad Meyer 	case CTLTYPE_S64:
2482088c17b4SConrad Meyer 	case CTLTYPE_U8:
2483088c17b4SConrad Meyer 	case CTLTYPE_U16:
2484088c17b4SConrad Meyer 	case CTLTYPE_U32:
2485088c17b4SConrad Meyer 	case CTLTYPE_U64:
2486088c17b4SConrad Meyer 		hexlen = 2 + (intlen * CHAR_BIT + 3) / 4;
2487088c17b4SConrad Meyer 		sep1 = "";
2488088c17b4SConrad Meyer 		while (len >= intlen) {
2489088c17b4SConrad Meyer 			switch (ctltype) {
2490088c17b4SConrad Meyer 			case CTLTYPE_INT:
2491088c17b4SConrad Meyer 			case CTLTYPE_UINT:
2492088c17b4SConrad Meyer 				umv = *(const u_int *)p;
2493088c17b4SConrad Meyer 				mv = *(const int *)p;
2494088c17b4SConrad Meyer 				break;
2495088c17b4SConrad Meyer 			case CTLTYPE_LONG:
2496088c17b4SConrad Meyer 			case CTLTYPE_ULONG:
2497088c17b4SConrad Meyer 				umv = *(const u_long *)p;
2498088c17b4SConrad Meyer 				mv = *(const long *)p;
2499088c17b4SConrad Meyer 				break;
2500088c17b4SConrad Meyer 			case CTLTYPE_S8:
2501088c17b4SConrad Meyer 			case CTLTYPE_U8:
2502088c17b4SConrad Meyer 				umv = *(const uint8_t *)p;
2503088c17b4SConrad Meyer 				mv = *(const int8_t *)p;
2504088c17b4SConrad Meyer 				break;
2505088c17b4SConrad Meyer 			case CTLTYPE_S16:
2506088c17b4SConrad Meyer 			case CTLTYPE_U16:
2507088c17b4SConrad Meyer 				umv = *(const uint16_t *)p;
2508088c17b4SConrad Meyer 				mv = *(const int16_t *)p;
2509088c17b4SConrad Meyer 				break;
2510088c17b4SConrad Meyer 			case CTLTYPE_S32:
2511088c17b4SConrad Meyer 			case CTLTYPE_U32:
2512088c17b4SConrad Meyer 				umv = *(const uint32_t *)p;
2513088c17b4SConrad Meyer 				mv = *(const int32_t *)p;
2514088c17b4SConrad Meyer 				break;
2515088c17b4SConrad Meyer 			case CTLTYPE_S64:
2516088c17b4SConrad Meyer 			case CTLTYPE_U64:
2517088c17b4SConrad Meyer 				umv = *(const uint64_t *)p;
2518088c17b4SConrad Meyer 				mv = *(const int64_t *)p;
2519088c17b4SConrad Meyer 				break;
2520088c17b4SConrad Meyer 			}
2521088c17b4SConrad Meyer 
2522088c17b4SConrad Meyer 			db_printf("%s", sep1);
2523088c17b4SConrad Meyer 			if (xflag)
2524088c17b4SConrad Meyer 				db_printf("%#0*jx", hexlen, umv);
2525088c17b4SConrad Meyer 			else if (!sign)
2526088c17b4SConrad Meyer 				db_printf("%ju", umv);
2527088c17b4SConrad Meyer 			else if (g_ddb_oid->oid_fmt[1] == 'K') {
2528088c17b4SConrad Meyer 				/* Kelvins are currently unsupported. */
2529088c17b4SConrad Meyer 				error = EOPNOTSUPP;
2530088c17b4SConrad Meyer 				goto out;
2531088c17b4SConrad Meyer 			} else
2532088c17b4SConrad Meyer 				db_printf("%jd", mv);
2533088c17b4SConrad Meyer 
2534088c17b4SConrad Meyer 			sep1 = " ";
2535088c17b4SConrad Meyer 			len -= intlen;
2536088c17b4SConrad Meyer 			p += intlen;
2537088c17b4SConrad Meyer 		}
2538088c17b4SConrad Meyer 		error = 0;
2539088c17b4SConrad Meyer 		goto out;
2540088c17b4SConrad Meyer 
2541088c17b4SConrad Meyer 	case CTLTYPE_OPAQUE:
2542088c17b4SConrad Meyer 		/* TODO: Support struct functions. */
2543088c17b4SConrad Meyer 
2544088c17b4SConrad Meyer 		/* FALLTHROUGH */
2545088c17b4SConrad Meyer 	default:
2546088c17b4SConrad Meyer 		db_printf("Format:%s Length:%zu Dump:0x",
2547088c17b4SConrad Meyer 		    g_ddb_oid->oid_fmt, len);
2548088c17b4SConrad Meyer 		while (len-- && (xflag || p < val + 16))
2549088c17b4SConrad Meyer 			db_printf("%02x", *p++);
2550088c17b4SConrad Meyer 		if (!xflag && len > 16)
2551088c17b4SConrad Meyer 			db_printf("...");
2552088c17b4SConrad Meyer 		error = 0;
2553088c17b4SConrad Meyer 		goto out;
2554088c17b4SConrad Meyer 	}
2555088c17b4SConrad Meyer 
2556088c17b4SConrad Meyer out:
2557088c17b4SConrad Meyer 	req->oldidx += slen;
2558088c17b4SConrad Meyer 	return (error);
2559088c17b4SConrad Meyer }
2560088c17b4SConrad Meyer 
2561088c17b4SConrad Meyer /*
2562088c17b4SConrad Meyer  * Avoid setting new sysctl values from the debugger
2563088c17b4SConrad Meyer  */
2564088c17b4SConrad Meyer static int
2565088c17b4SConrad Meyer sysctl_new_ddb(struct sysctl_req *req, void *p, size_t l)
2566088c17b4SConrad Meyer {
2567088c17b4SConrad Meyer 
2568088c17b4SConrad Meyer 	if (!req->newptr)
2569088c17b4SConrad Meyer 		return (0);
2570088c17b4SConrad Meyer 
2571088c17b4SConrad Meyer 	/* Changing sysctls from the debugger is currently unsupported */
2572088c17b4SConrad Meyer 	return (EPERM);
2573088c17b4SConrad Meyer }
2574088c17b4SConrad Meyer 
2575088c17b4SConrad Meyer /*
2576088c17b4SConrad Meyer  * Run a sysctl handler with the DDB oldfunc and newfunc attached.
2577088c17b4SConrad Meyer  * Instead of copying any output to a buffer we'll dump it right to
2578088c17b4SConrad Meyer  * the console.
2579088c17b4SConrad Meyer  */
2580088c17b4SConrad Meyer static int
2581088c17b4SConrad Meyer db_sysctl(struct sysctl_oid *oidp, int *name, u_int namelen,
2582088c17b4SConrad Meyer     void *old, size_t *oldlenp, size_t *retval, int flags)
2583088c17b4SConrad Meyer {
2584088c17b4SConrad Meyer 	struct sysctl_req req;
2585088c17b4SConrad Meyer 	int error;
2586088c17b4SConrad Meyer 
2587088c17b4SConrad Meyer 	/* Setup the request */
2588088c17b4SConrad Meyer 	bzero(&req, sizeof req);
2589088c17b4SConrad Meyer 	req.td = kdb_thread;
2590088c17b4SConrad Meyer 	req.oldfunc = sysctl_old_ddb;
2591088c17b4SConrad Meyer 	req.newfunc = sysctl_new_ddb;
2592088c17b4SConrad Meyer 	req.lock = REQ_UNWIRED;
2593088c17b4SConrad Meyer 	if (oldlenp) {
2594088c17b4SConrad Meyer 		req.oldlen = *oldlenp;
2595088c17b4SConrad Meyer 	}
2596088c17b4SConrad Meyer 	req.validlen = req.oldlen;
2597088c17b4SConrad Meyer 	if (old) {
2598088c17b4SConrad Meyer 		req.oldptr = old;
2599088c17b4SConrad Meyer 	}
2600088c17b4SConrad Meyer 
2601088c17b4SConrad Meyer 	/* Setup our globals for sysctl_old_ddb */
2602088c17b4SConrad Meyer 	g_ddb_oid = oidp;
2603088c17b4SConrad Meyer 	g_ddb_sysctl_flags = flags;
2604088c17b4SConrad Meyer 	g_ddb_sysctl_printed = 0;
2605088c17b4SConrad Meyer 
2606088c17b4SConrad Meyer 	error = sysctl_root(0, name, namelen, &req);
2607088c17b4SConrad Meyer 
2608088c17b4SConrad Meyer 	/* Reset globals */
2609088c17b4SConrad Meyer 	g_ddb_oid = NULL;
2610088c17b4SConrad Meyer 	g_ddb_sysctl_flags = 0;
2611088c17b4SConrad Meyer 
2612088c17b4SConrad Meyer 	if (retval) {
2613088c17b4SConrad Meyer 		if (req.oldptr && req.oldidx > req.validlen)
2614088c17b4SConrad Meyer 			*retval = req.validlen;
2615088c17b4SConrad Meyer 		else
2616088c17b4SConrad Meyer 			*retval = req.oldidx;
2617088c17b4SConrad Meyer 	}
2618088c17b4SConrad Meyer 	return (error);
2619088c17b4SConrad Meyer }
2620088c17b4SConrad Meyer 
2621088c17b4SConrad Meyer /*
2622088c17b4SConrad Meyer  * Show a sysctl's name
2623088c17b4SConrad Meyer  */
2624088c17b4SConrad Meyer static void
2625088c17b4SConrad Meyer db_show_oid_name(int *oid, size_t nlen)
2626088c17b4SConrad Meyer {
2627088c17b4SConrad Meyer 	struct sysctl_oid *oidp;
2628088c17b4SConrad Meyer 	int qoid[CTL_MAXNAME+2];
2629088c17b4SConrad Meyer 	int error;
2630088c17b4SConrad Meyer 
2631088c17b4SConrad Meyer 	qoid[0] = 0;
2632088c17b4SConrad Meyer 	memcpy(qoid + 2, oid, nlen * sizeof(int));
2633088c17b4SConrad Meyer 	qoid[1] = 1;
2634088c17b4SConrad Meyer 
2635088c17b4SConrad Meyer 	error = sysctl_find_oid(qoid, nlen + 2, &oidp, NULL, NULL);
2636088c17b4SConrad Meyer 	if (error)
2637088c17b4SConrad Meyer 		db_error("sysctl name oid");
2638088c17b4SConrad Meyer 
2639088c17b4SConrad Meyer 	error = db_sysctl(oidp, qoid, nlen + 2, NULL, NULL, NULL, 0);
2640088c17b4SConrad Meyer 	if (error)
2641088c17b4SConrad Meyer 		db_error("sysctl name");
2642088c17b4SConrad Meyer }
2643088c17b4SConrad Meyer 
2644088c17b4SConrad Meyer /*
2645088c17b4SConrad Meyer  * Check to see if an OID is safe to print from ddb.
2646088c17b4SConrad Meyer  */
2647088c17b4SConrad Meyer static bool
2648088c17b4SConrad Meyer db_oid_safe(const struct sysctl_oid *oidp)
2649088c17b4SConrad Meyer {
2650088c17b4SConrad Meyer 	for (unsigned int i = 0; i < nitems(db_safe_handlers); ++i) {
2651088c17b4SConrad Meyer 		if (oidp->oid_handler == db_safe_handlers[i])
2652088c17b4SConrad Meyer 			return (true);
2653088c17b4SConrad Meyer 	}
2654088c17b4SConrad Meyer 
2655088c17b4SConrad Meyer 	return (false);
2656088c17b4SConrad Meyer }
2657088c17b4SConrad Meyer 
2658088c17b4SConrad Meyer /*
2659088c17b4SConrad Meyer  * Show a sysctl at a specific OID
2660088c17b4SConrad Meyer  * Compare to the input handling in show_var from sbin/sysctl/sysctl.c
2661088c17b4SConrad Meyer  */
2662088c17b4SConrad Meyer static int
2663088c17b4SConrad Meyer db_show_oid(struct sysctl_oid *oidp, int *oid, size_t nlen, int flags)
2664088c17b4SConrad Meyer {
2665088c17b4SConrad Meyer 	int error, xflag, oflag, Nflag, nflag;
2666088c17b4SConrad Meyer 	size_t len;
2667088c17b4SConrad Meyer 
2668088c17b4SConrad Meyer 	xflag = flags & DB_SYSCTL_HEX;
2669088c17b4SConrad Meyer 	oflag = flags & DB_SYSCTL_OPAQUE;
2670088c17b4SConrad Meyer 	nflag = flags & DB_SYSCTL_VALUE_ONLY;
2671088c17b4SConrad Meyer 	Nflag = flags & DB_SYSCTL_NAME_ONLY;
2672088c17b4SConrad Meyer 
2673088c17b4SConrad Meyer 	if ((oidp->oid_kind & CTLTYPE) == CTLTYPE_OPAQUE &&
2674088c17b4SConrad Meyer 	    (!xflag && !oflag))
2675088c17b4SConrad Meyer 		return (0);
2676088c17b4SConrad Meyer 
2677088c17b4SConrad Meyer 	if (Nflag) {
2678088c17b4SConrad Meyer 		db_show_oid_name(oid, nlen);
2679088c17b4SConrad Meyer 		error = 0;
2680088c17b4SConrad Meyer 		goto out;
2681088c17b4SConrad Meyer 	}
2682088c17b4SConrad Meyer 
2683088c17b4SConrad Meyer 	if (!nflag) {
2684088c17b4SConrad Meyer 		db_show_oid_name(oid, nlen);
2685088c17b4SConrad Meyer 		db_printf(": ");
2686088c17b4SConrad Meyer 	}
2687088c17b4SConrad Meyer 
2688088c17b4SConrad Meyer 	if ((flags & DB_SYSCTL_SAFE_ONLY) && !db_oid_safe(oidp)) {
2689088c17b4SConrad Meyer 		db_printf("Skipping, unsafe to print while recursing.");
2690088c17b4SConrad Meyer 		error = 0;
2691088c17b4SConrad Meyer 		goto out;
2692088c17b4SConrad Meyer 	}
2693088c17b4SConrad Meyer 
2694088c17b4SConrad Meyer 	/* Try once, and ask about the size */
2695088c17b4SConrad Meyer 	len = 0;
2696088c17b4SConrad Meyer 	error = db_sysctl(oidp, oid, nlen,
2697088c17b4SConrad Meyer 	    NULL, NULL, &len, flags);
2698088c17b4SConrad Meyer 	if (error)
2699088c17b4SConrad Meyer 		goto out;
2700088c17b4SConrad Meyer 
2701088c17b4SConrad Meyer 	if (!g_ddb_sysctl_printed)
2702088c17b4SConrad Meyer 		/* Lie about the size */
2703088c17b4SConrad Meyer 		error = db_sysctl(oidp, oid, nlen,
2704088c17b4SConrad Meyer 		    (void *) 1, &len, NULL, flags);
2705088c17b4SConrad Meyer 
2706088c17b4SConrad Meyer out:
2707088c17b4SConrad Meyer 	db_printf("\n");
2708088c17b4SConrad Meyer 	return (error);
2709088c17b4SConrad Meyer }
2710088c17b4SConrad Meyer 
2711088c17b4SConrad Meyer /*
2712088c17b4SConrad Meyer  * Show all sysctls under a specific OID
2713088c17b4SConrad Meyer  * Compare to sysctl_all from sbin/sysctl/sysctl.c
2714088c17b4SConrad Meyer  */
2715088c17b4SConrad Meyer static int
2716088c17b4SConrad Meyer db_show_sysctl_all(int *oid, size_t len, int flags)
2717088c17b4SConrad Meyer {
2718088c17b4SConrad Meyer 	struct sysctl_oid *oidp;
2719088c17b4SConrad Meyer 	int name1[CTL_MAXNAME + 2], name2[CTL_MAXNAME + 2];
2720088c17b4SConrad Meyer 	size_t l1, l2;
2721088c17b4SConrad Meyer 
2722382e01c8SKonstantin Belousov 	name1[0] = CTL_SYSCTL;
2723382e01c8SKonstantin Belousov 	name1[1] = CTL_SYSCTL_NEXT;
2724088c17b4SConrad Meyer 	l1 = 2;
2725088c17b4SConrad Meyer 	if (len) {
2726088c17b4SConrad Meyer 		memcpy(name1+2, oid, len * sizeof(int));
2727088c17b4SConrad Meyer 		l1 +=len;
2728088c17b4SConrad Meyer 	} else {
2729088c17b4SConrad Meyer 		name1[2] = 1;
2730088c17b4SConrad Meyer 		l1++;
2731088c17b4SConrad Meyer 	}
2732088c17b4SConrad Meyer 	for (;;) {
2733088c17b4SConrad Meyer 		int i, error;
2734088c17b4SConrad Meyer 
2735088c17b4SConrad Meyer 		l2 = sizeof(name2);
2736088c17b4SConrad Meyer 		error = kernel_sysctl(kdb_thread, name1, l1,
2737088c17b4SConrad Meyer 		    name2, &l2, NULL, 0, &l2, 0);
2738088c17b4SConrad Meyer 		if (error != 0) {
2739088c17b4SConrad Meyer 			if (error == ENOENT)
2740088c17b4SConrad Meyer 				return (0);
2741088c17b4SConrad Meyer 			else
2742088c17b4SConrad Meyer 				db_error("sysctl(getnext)");
2743088c17b4SConrad Meyer 		}
2744088c17b4SConrad Meyer 
2745088c17b4SConrad Meyer 		l2 /= sizeof(int);
2746088c17b4SConrad Meyer 
2747088c17b4SConrad Meyer 		if (l2 < (unsigned int)len)
2748088c17b4SConrad Meyer 			return (0);
2749088c17b4SConrad Meyer 
2750088c17b4SConrad Meyer 		for (i = 0; i < len; i++)
2751088c17b4SConrad Meyer 			if (name2[i] != oid[i])
2752088c17b4SConrad Meyer 				return (0);
2753088c17b4SConrad Meyer 
2754088c17b4SConrad Meyer 		/* Find the OID in question */
2755088c17b4SConrad Meyer 		error = sysctl_find_oid(name2, l2, &oidp, NULL, NULL);
2756088c17b4SConrad Meyer 		if (error)
2757088c17b4SConrad Meyer 			return (error);
2758088c17b4SConrad Meyer 
2759088c17b4SConrad Meyer 		i = db_show_oid(oidp, name2, l2, flags | DB_SYSCTL_SAFE_ONLY);
2760088c17b4SConrad Meyer 
2761088c17b4SConrad Meyer 		if (db_pager_quit)
2762088c17b4SConrad Meyer 			return (0);
2763088c17b4SConrad Meyer 
2764088c17b4SConrad Meyer 		memcpy(name1+2, name2, l2 * sizeof(int));
2765088c17b4SConrad Meyer 		l1 = 2 + l2;
2766088c17b4SConrad Meyer 	}
2767088c17b4SConrad Meyer }
2768088c17b4SConrad Meyer 
2769088c17b4SConrad Meyer /*
2770088c17b4SConrad Meyer  * Show a sysctl by its user facing string
2771088c17b4SConrad Meyer  */
2772088c17b4SConrad Meyer static int
2773088c17b4SConrad Meyer db_sysctlbyname(char *name, int flags)
2774088c17b4SConrad Meyer {
2775088c17b4SConrad Meyer 	struct sysctl_oid *oidp;
2776088c17b4SConrad Meyer 	int oid[CTL_MAXNAME];
2777088c17b4SConrad Meyer 	int error, nlen;
2778088c17b4SConrad Meyer 
2779088c17b4SConrad Meyer 	error = name2oid(name, oid, &nlen, &oidp);
2780088c17b4SConrad Meyer 	if (error) {
2781088c17b4SConrad Meyer 		return (error);
2782088c17b4SConrad Meyer 	}
2783088c17b4SConrad Meyer 
2784088c17b4SConrad Meyer 	if ((oidp->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
2785088c17b4SConrad Meyer 		db_show_sysctl_all(oid, nlen, flags);
2786088c17b4SConrad Meyer 	} else {
2787088c17b4SConrad Meyer 		error = db_show_oid(oidp, oid, nlen, flags);
2788088c17b4SConrad Meyer 	}
2789088c17b4SConrad Meyer 
2790088c17b4SConrad Meyer 	return (error);
2791088c17b4SConrad Meyer }
2792088c17b4SConrad Meyer 
2793088c17b4SConrad Meyer static void
2794088c17b4SConrad Meyer db_sysctl_cmd_usage(void)
2795088c17b4SConrad Meyer {
2796088c17b4SConrad Meyer 	db_printf(
2797088c17b4SConrad Meyer 	    " sysctl [/Nnox] <sysctl>					    \n"
2798088c17b4SConrad Meyer 	    "								    \n"
2799088c17b4SConrad Meyer 	    " <sysctl> The name of the sysctl to show.			    \n"
2800088c17b4SConrad Meyer 	    "								    \n"
2801088c17b4SConrad Meyer 	    " Show a sysctl by hooking into SYSCTL_IN and SYSCTL_OUT.	    \n"
2802088c17b4SConrad Meyer 	    " This will work for most sysctls, but should not be used	    \n"
2803088c17b4SConrad Meyer 	    " with sysctls that are known to malloc.			    \n"
2804088c17b4SConrad Meyer 	    "								    \n"
2805088c17b4SConrad Meyer 	    " While recursing any \"unsafe\" sysctls will be skipped.	    \n"
2806088c17b4SConrad Meyer 	    " Call sysctl directly on the sysctl to try printing the	    \n"
2807088c17b4SConrad Meyer 	    " skipped sysctl. This is unsafe and may make the ddb	    \n"
2808088c17b4SConrad Meyer 	    " session unusable.						    \n"
2809088c17b4SConrad Meyer 	    "								    \n"
2810088c17b4SConrad Meyer 	    " Arguments:						    \n"
2811088c17b4SConrad Meyer 	    "	/N	Display only the name of the sysctl.		    \n"
2812088c17b4SConrad Meyer 	    "	/n	Display only the value of the sysctl.		    \n"
2813088c17b4SConrad Meyer 	    "	/o	Display opaque values.				    \n"
2814088c17b4SConrad Meyer 	    "	/x	Display the sysctl in hex.			    \n"
2815088c17b4SConrad Meyer 	    "								    \n"
2816088c17b4SConrad Meyer 	    "For example:						    \n"
2817088c17b4SConrad Meyer 	    "sysctl vm.v_free_min					    \n"
2818088c17b4SConrad Meyer 	    "vn.v_free_min: 12669					    \n"
2819088c17b4SConrad Meyer 	    );
2820088c17b4SConrad Meyer }
2821088c17b4SConrad Meyer 
2822088c17b4SConrad Meyer /*
2823088c17b4SConrad Meyer  * Show a specific sysctl similar to sysctl (8).
2824088c17b4SConrad Meyer  */
2825088c17b4SConrad Meyer DB_FUNC(sysctl, db_sysctl_cmd, db_cmd_table, CS_OWN, NULL)
2826088c17b4SConrad Meyer {
2827088c17b4SConrad Meyer 	char name[TOK_STRING_SIZE];
2828088c17b4SConrad Meyer 	int error, i, t, flags;
2829088c17b4SConrad Meyer 
2830088c17b4SConrad Meyer 	/* Parse the modifiers */
2831088c17b4SConrad Meyer 	t = db_read_token();
2832088c17b4SConrad Meyer 	if (t == tSLASH || t == tMINUS) {
2833088c17b4SConrad Meyer 		t = db_read_token();
2834088c17b4SConrad Meyer 		if (t != tIDENT) {
2835088c17b4SConrad Meyer 			db_printf("Bad modifier\n");
2836088c17b4SConrad Meyer 			error = EINVAL;
2837088c17b4SConrad Meyer 			goto out;
2838088c17b4SConrad Meyer 		}
2839088c17b4SConrad Meyer 		db_strcpy(modif, db_tok_string);
2840088c17b4SConrad Meyer 	}
2841088c17b4SConrad Meyer 	else {
2842088c17b4SConrad Meyer 		db_unread_token(t);
2843088c17b4SConrad Meyer 		modif[0] = '\0';
2844088c17b4SConrad Meyer 	}
2845088c17b4SConrad Meyer 
2846088c17b4SConrad Meyer 	flags = 0;
2847088c17b4SConrad Meyer 	for (i = 0; i < nitems(db_sysctl_modifs); i++) {
2848088c17b4SConrad Meyer 		if (strchr(modif, db_sysctl_modifs[i])) {
2849088c17b4SConrad Meyer 			flags |= db_sysctl_modif_values[i];
2850088c17b4SConrad Meyer 		}
2851088c17b4SConrad Meyer 	}
2852088c17b4SConrad Meyer 
2853088c17b4SConrad Meyer 	/* Parse the sysctl names */
2854088c17b4SConrad Meyer 	t = db_read_token();
2855088c17b4SConrad Meyer 	if (t != tIDENT) {
2856088c17b4SConrad Meyer 		db_printf("Need sysctl name\n");
2857088c17b4SConrad Meyer 		error = EINVAL;
2858088c17b4SConrad Meyer 		goto out;
2859088c17b4SConrad Meyer 	}
2860088c17b4SConrad Meyer 
2861088c17b4SConrad Meyer 	/* Copy the name into a temporary buffer */
2862088c17b4SConrad Meyer 	db_strcpy(name, db_tok_string);
2863088c17b4SConrad Meyer 
2864088c17b4SConrad Meyer 	/* Ensure there is no trailing cruft */
2865088c17b4SConrad Meyer 	t = db_read_token();
2866088c17b4SConrad Meyer 	if (t != tEOL) {
2867088c17b4SConrad Meyer 		db_printf("Unexpected sysctl argument\n");
2868088c17b4SConrad Meyer 		error = EINVAL;
2869088c17b4SConrad Meyer 		goto out;
2870088c17b4SConrad Meyer 	}
2871088c17b4SConrad Meyer 
2872088c17b4SConrad Meyer 	error = db_sysctlbyname(name, flags);
2873088c17b4SConrad Meyer 	if (error == ENOENT) {
2874088c17b4SConrad Meyer 		db_printf("unknown oid: '%s'\n", db_tok_string);
2875088c17b4SConrad Meyer 		goto out;
2876088c17b4SConrad Meyer 	} else if (error) {
2877088c17b4SConrad Meyer 		db_printf("%s: error: %d\n", db_tok_string, error);
2878088c17b4SConrad Meyer 		goto out;
2879088c17b4SConrad Meyer 	}
2880088c17b4SConrad Meyer 
2881088c17b4SConrad Meyer out:
2882088c17b4SConrad Meyer 	/* Ensure we eat all of our text */
2883088c17b4SConrad Meyer 	db_flush_lex();
2884088c17b4SConrad Meyer 
2885088c17b4SConrad Meyer 	if (error == EINVAL) {
2886088c17b4SConrad Meyer 		db_sysctl_cmd_usage();
2887088c17b4SConrad Meyer 	}
2888088c17b4SConrad Meyer }
2889088c17b4SConrad Meyer 
2890088c17b4SConrad Meyer #endif /* DDB */
2891