xref: /freebsd/sys/kern/kern_sysctl.c (revision 84267cacf449706d08b5cfd16c97e9abe15115d5)
1df8bae1dSRodney W. Grimes /*-
2df8bae1dSRodney W. Grimes  * Copyright (c) 1982, 1986, 1989, 1993
3df8bae1dSRodney W. Grimes  *	The Regents of the University of California.  All rights reserved.
4df8bae1dSRodney W. Grimes  *
5df8bae1dSRodney W. Grimes  * This code is derived from software contributed to Berkeley by
6df8bae1dSRodney W. Grimes  * Mike Karels at Berkeley Software Design, Inc.
7df8bae1dSRodney W. Grimes  *
8946bb7a2SPoul-Henning Kamp  * Quite extensively rewritten by Poul-Henning Kamp of the FreeBSD
9946bb7a2SPoul-Henning Kamp  * project, to make these variables more userfriendly.
10946bb7a2SPoul-Henning Kamp  *
11df8bae1dSRodney W. Grimes  * Redistribution and use in source and binary forms, with or without
12df8bae1dSRodney W. Grimes  * modification, are permitted provided that the following conditions
13df8bae1dSRodney W. Grimes  * are met:
14df8bae1dSRodney W. Grimes  * 1. Redistributions of source code must retain the above copyright
15df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer.
16df8bae1dSRodney W. Grimes  * 2. Redistributions in binary form must reproduce the above copyright
17df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer in the
18df8bae1dSRodney W. Grimes  *    documentation and/or other materials provided with the distribution.
19df8bae1dSRodney W. Grimes  * 4. Neither the name of the University nor the names of its contributors
20df8bae1dSRodney W. Grimes  *    may be used to endorse or promote products derived from this software
21df8bae1dSRodney W. Grimes  *    without specific prior written permission.
22df8bae1dSRodney W. Grimes  *
23df8bae1dSRodney W. Grimes  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24df8bae1dSRodney W. Grimes  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25df8bae1dSRodney W. Grimes  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26df8bae1dSRodney W. Grimes  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27df8bae1dSRodney W. Grimes  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28df8bae1dSRodney W. Grimes  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29df8bae1dSRodney W. Grimes  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30df8bae1dSRodney W. Grimes  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31df8bae1dSRodney W. Grimes  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32df8bae1dSRodney W. Grimes  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33df8bae1dSRodney W. Grimes  * SUCH DAMAGE.
34df8bae1dSRodney W. Grimes  *
35df8bae1dSRodney W. Grimes  *	@(#)kern_sysctl.c	8.4 (Berkeley) 4/14/94
36df8bae1dSRodney W. Grimes  */
37df8bae1dSRodney W. Grimes 
38677b542eSDavid E. O'Brien #include <sys/cdefs.h>
39677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$");
40677b542eSDavid E. O'Brien 
41ff66f6a4SRobert Watson #include "opt_capsicum.h"
425591b823SEivind Eklund #include "opt_compat.h"
43a56be37eSJohn Baldwin #include "opt_ktrace.h"
445591b823SEivind Eklund 
45df8bae1dSRodney W. Grimes #include <sys/param.h>
46ccecef29SMatthew D Fleming #include <sys/fail.h>
47e96c1fdcSPeter Wemm #include <sys/systm.h>
484a144410SRobert Watson #include <sys/capsicum.h>
49df8bae1dSRodney W. Grimes #include <sys/kernel.h>
50df8bae1dSRodney W. Grimes #include <sys/sysctl.h>
51946bb7a2SPoul-Henning Kamp #include <sys/malloc.h>
52acd3428bSRobert Watson #include <sys/priv.h>
53efeaf95aSDavid Greenman #include <sys/proc.h>
54ebd8672cSBjoern A. Zeeb #include <sys/jail.h>
55fb99ab88SMatthew Dillon #include <sys/lock.h>
56fb99ab88SMatthew Dillon #include <sys/mutex.h>
574e657159SMatthew D Fleming #include <sys/sbuf.h>
5829a2c0cdSAlfred Perlstein #include <sys/sx.h>
5945ec3b38SPoul-Henning Kamp #include <sys/sysproto.h>
60af80b2c9SKonstantin Belousov #include <sys/uio.h>
61a56be37eSJohn Baldwin #ifdef KTRACE
62a56be37eSJohn Baldwin #include <sys/ktrace.h>
63a56be37eSJohn Baldwin #endif
64aed55708SRobert Watson 
65eddfbb76SRobert Watson #include <net/vnet.h>
66eddfbb76SRobert Watson 
67aed55708SRobert Watson #include <security/mac/mac_framework.h>
68aed55708SRobert Watson 
694cb03b1bSBruce Evans #include <vm/vm.h>
70efeaf95aSDavid Greenman #include <vm/vm_extern.h>
714cb03b1bSBruce Evans 
72a1c995b6SPoul-Henning Kamp static MALLOC_DEFINE(M_SYSCTL, "sysctl", "sysctl internal magic");
73bd3cdc31SAndrzej Bialecki static MALLOC_DEFINE(M_SYSCTLOID, "sysctloid", "sysctl dynamic oids");
749e74cba3SDon Lewis static MALLOC_DEFINE(M_SYSCTLTMP, "sysctltmp", "sysctl temp output buffer");
7555166637SPoul-Henning Kamp 
764b2af45fSPoul-Henning Kamp /*
77875b66a0SJohn Baldwin  * The sysctllock protects the MIB tree.  It also protects sysctl
78875b66a0SJohn Baldwin  * contexts used with dynamic sysctls.  The sysctl_register_oid() and
79875b66a0SJohn Baldwin  * sysctl_unregister_oid() routines require the sysctllock to already
80f84f8f94SMateusz Guzik  * be held, so the sysctl_xlock() and sysctl_xunlock() routines are
81875b66a0SJohn Baldwin  * provided for the few places in the kernel which need to use that
82875b66a0SJohn Baldwin  * API rather than using the dynamic API.  Use of the dynamic API is
83875b66a0SJohn Baldwin  * strongly encouraged for most code.
84875b66a0SJohn Baldwin  *
853e829b18SJohn Baldwin  * The sysctlmemlock is used to limit the amount of user memory wired for
863e829b18SJohn Baldwin  * sysctl requests.  This is implemented by serializing any userland
873e829b18SJohn Baldwin  * sysctl requests larger than a single page via an exclusive lock.
884b2af45fSPoul-Henning Kamp  */
893bd1da29SRobert Watson static struct sx sysctllock;
903e829b18SJohn Baldwin static struct sx sysctlmemlock;
9129a2c0cdSAlfred Perlstein 
92875b66a0SJohn Baldwin #define	SYSCTL_XLOCK()		sx_xlock(&sysctllock)
93875b66a0SJohn Baldwin #define	SYSCTL_XUNLOCK()	sx_xunlock(&sysctllock)
94efe0abddSMateusz Guzik #define	SYSCTL_SLOCK()		sx_slock(&sysctllock)
95efe0abddSMateusz Guzik #define	SYSCTL_SUNLOCK()	sx_sunlock(&sysctllock)
96efe0abddSMateusz Guzik #define	SYSCTL_XLOCKED()	sx_xlocked(&sysctllock)
97efe0abddSMateusz Guzik #define	SYSCTL_ASSERT_LOCKED()	sx_assert(&sysctllock, SA_LOCKED)
98875b66a0SJohn Baldwin #define	SYSCTL_ASSERT_XLOCKED()	sx_assert(&sysctllock, SA_XLOCKED)
99f84f8f94SMateusz Guzik #define	SYSCTL_ASSERT_SLOCKED()	sx_assert(&sysctllock, SA_SLOCKED)
10074019059SJohn Baldwin #define	SYSCTL_INIT()		sx_init(&sysctllock, "sysctl lock")
101ccecef29SMatthew D Fleming #define	SYSCTL_SLEEP(ch, wmesg, timo)					\
102ccecef29SMatthew D Fleming 				sx_sleep(ch, &sysctllock, 0, wmesg, timo)
1034b2af45fSPoul-Henning Kamp 
10482d9ae4eSPoul-Henning Kamp static int sysctl_root(SYSCTL_HANDLER_ARGS);
1054b2af45fSPoul-Henning Kamp 
106af3b2549SHans Petter Selasky /* Root list */
107af3b2549SHans Petter Selasky struct sysctl_oid_list sysctl__children = SLIST_HEAD_INITIALIZER(&sysctl__children);
108787d58f2SPoul-Henning Kamp 
109875b66a0SJohn Baldwin static int	sysctl_remove_oid_locked(struct sysctl_oid *oidp, int del,
110875b66a0SJohn Baldwin 		    int recurse);
111af3b2549SHans Petter Selasky static int	sysctl_old_kernel(struct sysctl_req *, const void *, size_t);
112af3b2549SHans Petter Selasky static int	sysctl_new_kernel(struct sysctl_req *, void *, size_t);
113875b66a0SJohn Baldwin 
114efe0abddSMateusz Guzik static void
115efe0abddSMateusz Guzik sysctl_lock(bool xlock)
116efe0abddSMateusz Guzik {
117efe0abddSMateusz Guzik 
118efe0abddSMateusz Guzik 	if (xlock)
119efe0abddSMateusz Guzik 		SYSCTL_XLOCK();
120efe0abddSMateusz Guzik 	else
121efe0abddSMateusz Guzik 		SYSCTL_SLOCK();
122efe0abddSMateusz Guzik }
123efe0abddSMateusz Guzik 
124efe0abddSMateusz Guzik static bool
125efe0abddSMateusz Guzik sysctl_unlock(void)
126efe0abddSMateusz Guzik {
127efe0abddSMateusz Guzik 	bool xlocked;
128efe0abddSMateusz Guzik 
129efe0abddSMateusz Guzik 	xlocked = SYSCTL_XLOCKED();
130efe0abddSMateusz Guzik 	if (xlocked)
131efe0abddSMateusz Guzik 		SYSCTL_XUNLOCK();
132efe0abddSMateusz Guzik 	else
133efe0abddSMateusz Guzik 		SYSCTL_SUNLOCK();
134efe0abddSMateusz Guzik 	return (xlocked);
135efe0abddSMateusz Guzik }
136efe0abddSMateusz Guzik 
137bd3cdc31SAndrzej Bialecki static struct sysctl_oid *
138bd3cdc31SAndrzej Bialecki sysctl_find_oidname(const char *name, struct sysctl_oid_list *list)
139bd3cdc31SAndrzej Bialecki {
140bd3cdc31SAndrzej Bialecki 	struct sysctl_oid *oidp;
141bd3cdc31SAndrzej Bialecki 
142efe0abddSMateusz Guzik 	SYSCTL_ASSERT_LOCKED();
143bd3cdc31SAndrzej Bialecki 	SLIST_FOREACH(oidp, list, oid_link) {
144bd3cdc31SAndrzej Bialecki 		if (strcmp(oidp->oid_name, name) == 0) {
145bd3cdc31SAndrzej Bialecki 			return (oidp);
146bd3cdc31SAndrzej Bialecki 		}
147bd3cdc31SAndrzej Bialecki 	}
148bd3cdc31SAndrzej Bialecki 	return (NULL);
149bd3cdc31SAndrzej Bialecki }
150bd3cdc31SAndrzej Bialecki 
151946bb7a2SPoul-Henning Kamp /*
152946bb7a2SPoul-Henning Kamp  * Initialization of the MIB tree.
153946bb7a2SPoul-Henning Kamp  *
154ce02431fSDoug Rabson  * Order by number in each list.
155946bb7a2SPoul-Henning Kamp  */
156875b66a0SJohn Baldwin void
157580a0117SMateusz Guzik sysctl_xlock(void)
158875b66a0SJohn Baldwin {
159875b66a0SJohn Baldwin 
160875b66a0SJohn Baldwin 	SYSCTL_XLOCK();
161875b66a0SJohn Baldwin }
162875b66a0SJohn Baldwin 
163875b66a0SJohn Baldwin void
164580a0117SMateusz Guzik sysctl_xunlock(void)
165875b66a0SJohn Baldwin {
166875b66a0SJohn Baldwin 
167875b66a0SJohn Baldwin 	SYSCTL_XUNLOCK();
168875b66a0SJohn Baldwin }
1694b2af45fSPoul-Henning Kamp 
170af3b2549SHans Petter Selasky static int
171af3b2549SHans Petter Selasky sysctl_root_handler_locked(struct sysctl_oid *oid, void *arg1, intptr_t arg2,
172af3b2549SHans Petter Selasky     struct sysctl_req *req)
173af3b2549SHans Petter Selasky {
174af3b2549SHans Petter Selasky 	int error;
175efe0abddSMateusz Guzik 	bool xlocked;
176af3b2549SHans Petter Selasky 
177*84267cacSMateusz Guzik 	if (oid->oid_kind & CTLFLAG_DYN)
178efe0abddSMateusz Guzik 		atomic_add_int(&oid->oid_running, 1);
179efe0abddSMateusz Guzik 	xlocked = sysctl_unlock();
180af3b2549SHans Petter Selasky 
181af3b2549SHans Petter Selasky 	if (!(oid->oid_kind & CTLFLAG_MPSAFE))
182af3b2549SHans Petter Selasky 		mtx_lock(&Giant);
183af3b2549SHans Petter Selasky 	error = oid->oid_handler(oid, arg1, arg2, req);
184af3b2549SHans Petter Selasky 	if (!(oid->oid_kind & CTLFLAG_MPSAFE))
185af3b2549SHans Petter Selasky 		mtx_unlock(&Giant);
186af3b2549SHans Petter Selasky 
187efe0abddSMateusz Guzik 	sysctl_lock(xlocked);
188*84267cacSMateusz Guzik 	if (oid->oid_kind & CTLFLAG_DYN) {
189efe0abddSMateusz Guzik 		if (atomic_fetchadd_int(&oid->oid_running, -1) == 1 &&
190efe0abddSMateusz Guzik 		    (oid->oid_kind & CTLFLAG_DYING) != 0)
191af3b2549SHans Petter Selasky 			wakeup(&oid->oid_running);
192*84267cacSMateusz Guzik 	}
193af3b2549SHans Petter Selasky 
194af3b2549SHans Petter Selasky 	return (error);
195af3b2549SHans Petter Selasky }
196af3b2549SHans Petter Selasky 
197af3b2549SHans Petter Selasky static void
198af3b2549SHans Petter Selasky sysctl_load_tunable_by_oid_locked(struct sysctl_oid *oidp)
199af3b2549SHans Petter Selasky {
200af3b2549SHans Petter Selasky 	struct sysctl_req req;
201af3b2549SHans Petter Selasky 	struct sysctl_oid *curr;
202604bf9d3SHans Petter Selasky 	char *penv = NULL;
203af3b2549SHans Petter Selasky 	char path[64];
204af3b2549SHans Petter Selasky 	ssize_t rem = sizeof(path);
205af3b2549SHans Petter Selasky 	ssize_t len;
206af3b2549SHans Petter Selasky 	int val_int;
207af3b2549SHans Petter Selasky 	long val_long;
208af3b2549SHans Petter Selasky 	int64_t val_64;
209604bf9d3SHans Petter Selasky 	quad_t val_quad;
210af3b2549SHans Petter Selasky 	int error;
211af3b2549SHans Petter Selasky 
212af3b2549SHans Petter Selasky 	path[--rem] = 0;
213af3b2549SHans Petter Selasky 
214af3b2549SHans Petter Selasky 	for (curr = oidp; curr != NULL; curr = SYSCTL_PARENT(curr)) {
215af3b2549SHans Petter Selasky 		len = strlen(curr->oid_name);
216af3b2549SHans Petter Selasky 		rem -= len;
217af3b2549SHans Petter Selasky 		if (curr != oidp)
218af3b2549SHans Petter Selasky 			rem -= 1;
219af3b2549SHans Petter Selasky 		if (rem < 0) {
220af3b2549SHans Petter Selasky 			printf("OID path exceeds %d bytes\n", (int)sizeof(path));
221af3b2549SHans Petter Selasky 			return;
222af3b2549SHans Petter Selasky 		}
223af3b2549SHans Petter Selasky 		memcpy(path + rem, curr->oid_name, len);
224af3b2549SHans Petter Selasky 		if (curr != oidp)
225af3b2549SHans Petter Selasky 			path[rem + len] = '.';
226af3b2549SHans Petter Selasky 	}
227af3b2549SHans Petter Selasky 
228af3b2549SHans Petter Selasky 	memset(&req, 0, sizeof(req));
229af3b2549SHans Petter Selasky 
230af3b2549SHans Petter Selasky 	req.td = curthread;
231af3b2549SHans Petter Selasky 	req.oldfunc = sysctl_old_kernel;
232af3b2549SHans Petter Selasky 	req.newfunc = sysctl_new_kernel;
233af3b2549SHans Petter Selasky 	req.lock = REQ_UNWIRED;
234af3b2549SHans Petter Selasky 
235af3b2549SHans Petter Selasky 	switch (oidp->oid_kind & CTLTYPE) {
236af3b2549SHans Petter Selasky 	case CTLTYPE_INT:
237604bf9d3SHans Petter Selasky 		if (getenv_int(path + rem, &val_int) == 0)
238604bf9d3SHans Petter Selasky 			return;
239af3b2549SHans Petter Selasky 		req.newlen = sizeof(val_int);
240af3b2549SHans Petter Selasky 		req.newptr = &val_int;
241af3b2549SHans Petter Selasky 		break;
242af3b2549SHans Petter Selasky 	case CTLTYPE_UINT:
243604bf9d3SHans Petter Selasky 		if (getenv_uint(path + rem, (unsigned int *)&val_int) == 0)
244604bf9d3SHans Petter Selasky 			return;
245af3b2549SHans Petter Selasky 		req.newlen = sizeof(val_int);
246af3b2549SHans Petter Selasky 		req.newptr = &val_int;
247af3b2549SHans Petter Selasky 		break;
248af3b2549SHans Petter Selasky 	case CTLTYPE_LONG:
249604bf9d3SHans Petter Selasky 		if (getenv_long(path + rem, &val_long) == 0)
250604bf9d3SHans Petter Selasky 			return;
251af3b2549SHans Petter Selasky 		req.newlen = sizeof(val_long);
252af3b2549SHans Petter Selasky 		req.newptr = &val_long;
253af3b2549SHans Petter Selasky 		break;
254af3b2549SHans Petter Selasky 	case CTLTYPE_ULONG:
255604bf9d3SHans Petter Selasky 		if (getenv_ulong(path + rem, (unsigned long *)&val_long) == 0)
256604bf9d3SHans Petter Selasky 			return;
257af3b2549SHans Petter Selasky 		req.newlen = sizeof(val_long);
258af3b2549SHans Petter Selasky 		req.newptr = &val_long;
259af3b2549SHans Petter Selasky 		break;
260af3b2549SHans Petter Selasky 	case CTLTYPE_S64:
261604bf9d3SHans Petter Selasky 		if (getenv_quad(path + rem, &val_quad) == 0)
262604bf9d3SHans Petter Selasky 			return;
263604bf9d3SHans Petter Selasky 		val_64 = val_quad;
264af3b2549SHans Petter Selasky 		req.newlen = sizeof(val_64);
265af3b2549SHans Petter Selasky 		req.newptr = &val_64;
266af3b2549SHans Petter Selasky 		break;
267af3b2549SHans Petter Selasky 	case CTLTYPE_U64:
268604bf9d3SHans Petter Selasky 		/* XXX there is no getenv_uquad() */
269604bf9d3SHans Petter Selasky 		if (getenv_quad(path + rem, &val_quad) == 0)
270604bf9d3SHans Petter Selasky 			return;
271604bf9d3SHans Petter Selasky 		val_64 = val_quad;
272af3b2549SHans Petter Selasky 		req.newlen = sizeof(val_64);
273af3b2549SHans Petter Selasky 		req.newptr = &val_64;
274af3b2549SHans Petter Selasky 		break;
275af3b2549SHans Petter Selasky 	case CTLTYPE_STRING:
2762be111bfSDavide Italiano 		penv = kern_getenv(path + rem);
277604bf9d3SHans Petter Selasky 		if (penv == NULL)
278604bf9d3SHans Petter Selasky 			return;
279af3b2549SHans Petter Selasky 		req.newlen = strlen(penv);
280af3b2549SHans Petter Selasky 		req.newptr = penv;
281af3b2549SHans Petter Selasky 		break;
282af3b2549SHans Petter Selasky 	default:
283af3b2549SHans Petter Selasky 		return;
284af3b2549SHans Petter Selasky 	}
285af3b2549SHans Petter Selasky 	error = sysctl_root_handler_locked(oidp, oidp->oid_arg1,
286af3b2549SHans Petter Selasky 	    oidp->oid_arg2, &req);
287b0d69dfaSDag-Erling Smørgrav 	if (error != 0)
288b0d69dfaSDag-Erling Smørgrav 		printf("Setting sysctl %s failed: %d\n", path, error);
289b0d69dfaSDag-Erling Smørgrav 	if (penv != NULL)
290af3b2549SHans Petter Selasky 		freeenv(penv);
291af3b2549SHans Petter Selasky }
292af3b2549SHans Petter Selasky 
293107e7dc5SPeter Pentchev void
294107e7dc5SPeter Pentchev sysctl_register_oid(struct sysctl_oid *oidp)
295787d58f2SPoul-Henning Kamp {
296ce02431fSDoug Rabson 	struct sysctl_oid_list *parent = oidp->oid_parent;
297ce02431fSDoug Rabson 	struct sysctl_oid *p;
298ce02431fSDoug Rabson 	struct sysctl_oid *q;
2993c8e79ddSBruce Evans 
300ce02431fSDoug Rabson 	/*
301bd3cdc31SAndrzej Bialecki 	 * First check if another oid with the same name already
302bd3cdc31SAndrzej Bialecki 	 * exists in the parent's list.
303bd3cdc31SAndrzej Bialecki 	 */
304875b66a0SJohn Baldwin 	SYSCTL_ASSERT_XLOCKED();
305bd3cdc31SAndrzej Bialecki 	p = sysctl_find_oidname(oidp->oid_name, parent);
306bd3cdc31SAndrzej Bialecki 	if (p != NULL) {
307bd3cdc31SAndrzej Bialecki 		if ((p->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
308bd3cdc31SAndrzej Bialecki 			p->oid_refcnt++;
309bd3cdc31SAndrzej Bialecki 			return;
310bd3cdc31SAndrzej Bialecki 		} else {
311bd3cdc31SAndrzej Bialecki 			printf("can't re-use a leaf (%s)!\n", p->oid_name);
312bd3cdc31SAndrzej Bialecki 			return;
313bd3cdc31SAndrzej Bialecki 		}
314bd3cdc31SAndrzej Bialecki 	}
315bd3cdc31SAndrzej Bialecki 	/*
316ce02431fSDoug Rabson 	 * If this oid has a number OID_AUTO, give it a number which
3177ca4d05fSPeter Pentchev 	 * is greater than any current oid.
3187ca4d05fSPeter Pentchev 	 * NOTE: DO NOT change the starting value here, change it in
3197ca4d05fSPeter Pentchev 	 * <sys/sysctl.h>, and make sure it is at least 256 to
3207ca4d05fSPeter Pentchev 	 * accomodate e.g. net.inet.raw as a static sysctl node.
321ce02431fSDoug Rabson 	 */
322ce02431fSDoug Rabson 	if (oidp->oid_number == OID_AUTO) {
3237ca4d05fSPeter Pentchev 		static int newoid = CTL_AUTO_START;
3245ed57d32SKirk McKusick 
3255ed57d32SKirk McKusick 		oidp->oid_number = newoid++;
3265ed57d32SKirk McKusick 		if (newoid == 0x7fffffff)
3275ed57d32SKirk McKusick 			panic("out of oids");
328787d58f2SPoul-Henning Kamp 	}
32988fbb423SPeter Pentchev #if 0
33088fbb423SPeter Pentchev 	else if (oidp->oid_number >= CTL_AUTO_START) {
33188fbb423SPeter Pentchev 		/* do not panic; this happens when unregistering sysctl sets */
33288fbb423SPeter Pentchev 		printf("static sysctl oid too high: %d", oidp->oid_number);
33388fbb423SPeter Pentchev 	}
33488fbb423SPeter Pentchev #endif
335787d58f2SPoul-Henning Kamp 
336ce02431fSDoug Rabson 	/*
337ce02431fSDoug Rabson 	 * Insert the oid into the parent's list in order.
338ce02431fSDoug Rabson 	 */
339ce02431fSDoug Rabson 	q = NULL;
340ce02431fSDoug Rabson 	SLIST_FOREACH(p, parent, oid_link) {
341ce02431fSDoug Rabson 		if (oidp->oid_number < p->oid_number)
342ce02431fSDoug Rabson 			break;
343ce02431fSDoug Rabson 		q = p;
344ce02431fSDoug Rabson 	}
345ce02431fSDoug Rabson 	if (q)
346ce02431fSDoug Rabson 		SLIST_INSERT_AFTER(q, oidp, oid_link);
347ce02431fSDoug Rabson 	else
348ce02431fSDoug Rabson 		SLIST_INSERT_HEAD(parent, oidp, oid_link);
349af3b2549SHans Petter Selasky 
350af3b2549SHans Petter Selasky 	if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE &&
351af3b2549SHans Petter Selasky #ifdef VIMAGE
352af3b2549SHans Petter Selasky 	    (oidp->oid_kind & CTLFLAG_VNET) == 0 &&
353af3b2549SHans Petter Selasky #endif
354af3b2549SHans Petter Selasky 	    (oidp->oid_kind & CTLFLAG_TUN) != 0 &&
355af3b2549SHans Petter Selasky 	    (oidp->oid_kind & CTLFLAG_NOFETCH) == 0) {
356af3b2549SHans Petter Selasky 		sysctl_load_tunable_by_oid_locked(oidp);
357af3b2549SHans Petter Selasky 	}
358ce02431fSDoug Rabson }
359ce02431fSDoug Rabson 
360107e7dc5SPeter Pentchev void
361107e7dc5SPeter Pentchev sysctl_unregister_oid(struct sysctl_oid *oidp)
362787d58f2SPoul-Henning Kamp {
363193f2edbSMaxime Henrion 	struct sysctl_oid *p;
364193f2edbSMaxime Henrion 	int error;
365193f2edbSMaxime Henrion 
366875b66a0SJohn Baldwin 	SYSCTL_ASSERT_XLOCKED();
367193f2edbSMaxime Henrion 	error = ENOENT;
368193f2edbSMaxime Henrion 	if (oidp->oid_number == OID_AUTO) {
369193f2edbSMaxime Henrion 		error = EINVAL;
370193f2edbSMaxime Henrion 	} else {
371193f2edbSMaxime Henrion 		SLIST_FOREACH(p, oidp->oid_parent, oid_link) {
372193f2edbSMaxime Henrion 			if (p == oidp) {
373193f2edbSMaxime Henrion 				SLIST_REMOVE(oidp->oid_parent, oidp,
374193f2edbSMaxime Henrion 				    sysctl_oid, oid_link);
375193f2edbSMaxime Henrion 				error = 0;
376193f2edbSMaxime Henrion 				break;
377193f2edbSMaxime Henrion 			}
378193f2edbSMaxime Henrion 		}
379193f2edbSMaxime Henrion 	}
380193f2edbSMaxime Henrion 
381193f2edbSMaxime Henrion 	/*
382193f2edbSMaxime Henrion 	 * This can happen when a module fails to register and is
383193f2edbSMaxime Henrion 	 * being unloaded afterwards.  It should not be a panic()
384193f2edbSMaxime Henrion 	 * for normal use.
385193f2edbSMaxime Henrion 	 */
386193f2edbSMaxime Henrion 	if (error)
387193f2edbSMaxime Henrion 		printf("%s: failed to unregister sysctl\n", __func__);
38861220614SPoul-Henning Kamp }
389946bb7a2SPoul-Henning Kamp 
390bd3cdc31SAndrzej Bialecki /* Initialize a new context to keep track of dynamically added sysctls. */
391bd3cdc31SAndrzej Bialecki int
392bd3cdc31SAndrzej Bialecki sysctl_ctx_init(struct sysctl_ctx_list *c)
393bd3cdc31SAndrzej Bialecki {
394bd3cdc31SAndrzej Bialecki 
395bd3cdc31SAndrzej Bialecki 	if (c == NULL) {
396bd3cdc31SAndrzej Bialecki 		return (EINVAL);
397bd3cdc31SAndrzej Bialecki 	}
398875b66a0SJohn Baldwin 
399875b66a0SJohn Baldwin 	/*
400875b66a0SJohn Baldwin 	 * No locking here, the caller is responsible for not adding
401875b66a0SJohn Baldwin 	 * new nodes to a context until after this function has
402875b66a0SJohn Baldwin 	 * returned.
403875b66a0SJohn Baldwin 	 */
404bd3cdc31SAndrzej Bialecki 	TAILQ_INIT(c);
405bd3cdc31SAndrzej Bialecki 	return (0);
406bd3cdc31SAndrzej Bialecki }
407bd3cdc31SAndrzej Bialecki 
408bd3cdc31SAndrzej Bialecki /* Free the context, and destroy all dynamic oids registered in this context */
409bd3cdc31SAndrzej Bialecki int
410bd3cdc31SAndrzej Bialecki sysctl_ctx_free(struct sysctl_ctx_list *clist)
411bd3cdc31SAndrzej Bialecki {
412bd3cdc31SAndrzej Bialecki 	struct sysctl_ctx_entry *e, *e1;
413bd3cdc31SAndrzej Bialecki 	int error;
414bd3cdc31SAndrzej Bialecki 
415bd3cdc31SAndrzej Bialecki 	error = 0;
416bd3cdc31SAndrzej Bialecki 	/*
417bd3cdc31SAndrzej Bialecki 	 * First perform a "dry run" to check if it's ok to remove oids.
418bd3cdc31SAndrzej Bialecki 	 * XXX FIXME
419bd3cdc31SAndrzej Bialecki 	 * XXX This algorithm is a hack. But I don't know any
420bd3cdc31SAndrzej Bialecki 	 * XXX better solution for now...
421bd3cdc31SAndrzej Bialecki 	 */
422875b66a0SJohn Baldwin 	SYSCTL_XLOCK();
423bd3cdc31SAndrzej Bialecki 	TAILQ_FOREACH(e, clist, link) {
424875b66a0SJohn Baldwin 		error = sysctl_remove_oid_locked(e->entry, 0, 0);
425bd3cdc31SAndrzej Bialecki 		if (error)
426bd3cdc31SAndrzej Bialecki 			break;
427bd3cdc31SAndrzej Bialecki 	}
428bd3cdc31SAndrzej Bialecki 	/*
429bd3cdc31SAndrzej Bialecki 	 * Restore deregistered entries, either from the end,
430bd3cdc31SAndrzej Bialecki 	 * or from the place where error occured.
431bd3cdc31SAndrzej Bialecki 	 * e contains the entry that was not unregistered
432bd3cdc31SAndrzej Bialecki 	 */
433bd3cdc31SAndrzej Bialecki 	if (error)
434bd3cdc31SAndrzej Bialecki 		e1 = TAILQ_PREV(e, sysctl_ctx_list, link);
435bd3cdc31SAndrzej Bialecki 	else
436bd3cdc31SAndrzej Bialecki 		e1 = TAILQ_LAST(clist, sysctl_ctx_list);
437bd3cdc31SAndrzej Bialecki 	while (e1 != NULL) {
438bd3cdc31SAndrzej Bialecki 		sysctl_register_oid(e1->entry);
439bd3cdc31SAndrzej Bialecki 		e1 = TAILQ_PREV(e1, sysctl_ctx_list, link);
440bd3cdc31SAndrzej Bialecki 	}
441875b66a0SJohn Baldwin 	if (error) {
442875b66a0SJohn Baldwin 		SYSCTL_XUNLOCK();
443bd3cdc31SAndrzej Bialecki 		return(EBUSY);
444875b66a0SJohn Baldwin 	}
445bd3cdc31SAndrzej Bialecki 	/* Now really delete the entries */
446bd3cdc31SAndrzej Bialecki 	e = TAILQ_FIRST(clist);
447bd3cdc31SAndrzej Bialecki 	while (e != NULL) {
448bd3cdc31SAndrzej Bialecki 		e1 = TAILQ_NEXT(e, link);
449875b66a0SJohn Baldwin 		error = sysctl_remove_oid_locked(e->entry, 1, 0);
450bd3cdc31SAndrzej Bialecki 		if (error)
451bd3cdc31SAndrzej Bialecki 			panic("sysctl_remove_oid: corrupt tree, entry: %s",
452bd3cdc31SAndrzej Bialecki 			    e->entry->oid_name);
453bd3cdc31SAndrzej Bialecki 		free(e, M_SYSCTLOID);
454bd3cdc31SAndrzej Bialecki 		e = e1;
455bd3cdc31SAndrzej Bialecki 	}
456875b66a0SJohn Baldwin 	SYSCTL_XUNLOCK();
457bd3cdc31SAndrzej Bialecki 	return (error);
458bd3cdc31SAndrzej Bialecki }
459bd3cdc31SAndrzej Bialecki 
460bd3cdc31SAndrzej Bialecki /* Add an entry to the context */
461bd3cdc31SAndrzej Bialecki struct sysctl_ctx_entry *
462bd3cdc31SAndrzej Bialecki sysctl_ctx_entry_add(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp)
463bd3cdc31SAndrzej Bialecki {
464bd3cdc31SAndrzej Bialecki 	struct sysctl_ctx_entry *e;
465bd3cdc31SAndrzej Bialecki 
466875b66a0SJohn Baldwin 	SYSCTL_ASSERT_XLOCKED();
467bd3cdc31SAndrzej Bialecki 	if (clist == NULL || oidp == NULL)
468bd3cdc31SAndrzej Bialecki 		return(NULL);
469a163d034SWarner Losh 	e = malloc(sizeof(struct sysctl_ctx_entry), M_SYSCTLOID, M_WAITOK);
470bd3cdc31SAndrzej Bialecki 	e->entry = oidp;
471bd3cdc31SAndrzej Bialecki 	TAILQ_INSERT_HEAD(clist, e, link);
472bd3cdc31SAndrzej Bialecki 	return (e);
473bd3cdc31SAndrzej Bialecki }
474bd3cdc31SAndrzej Bialecki 
475bd3cdc31SAndrzej Bialecki /* Find an entry in the context */
476bd3cdc31SAndrzej Bialecki struct sysctl_ctx_entry *
477bd3cdc31SAndrzej Bialecki sysctl_ctx_entry_find(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp)
478bd3cdc31SAndrzej Bialecki {
479bd3cdc31SAndrzej Bialecki 	struct sysctl_ctx_entry *e;
480bd3cdc31SAndrzej Bialecki 
481ccecef29SMatthew D Fleming 	SYSCTL_ASSERT_XLOCKED();
482bd3cdc31SAndrzej Bialecki 	if (clist == NULL || oidp == NULL)
483bd3cdc31SAndrzej Bialecki 		return(NULL);
484fc2ffbe6SPoul-Henning Kamp 	TAILQ_FOREACH(e, clist, link) {
485bd3cdc31SAndrzej Bialecki 		if(e->entry == oidp)
486bd3cdc31SAndrzej Bialecki 			return(e);
487bd3cdc31SAndrzej Bialecki 	}
488bd3cdc31SAndrzej Bialecki 	return (e);
489bd3cdc31SAndrzej Bialecki }
490bd3cdc31SAndrzej Bialecki 
491bd3cdc31SAndrzej Bialecki /*
492bd3cdc31SAndrzej Bialecki  * Delete an entry from the context.
493bd3cdc31SAndrzej Bialecki  * NOTE: this function doesn't free oidp! You have to remove it
494bd3cdc31SAndrzej Bialecki  * with sysctl_remove_oid().
495bd3cdc31SAndrzej Bialecki  */
496bd3cdc31SAndrzej Bialecki int
497bd3cdc31SAndrzej Bialecki sysctl_ctx_entry_del(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp)
498bd3cdc31SAndrzej Bialecki {
499bd3cdc31SAndrzej Bialecki 	struct sysctl_ctx_entry *e;
500bd3cdc31SAndrzej Bialecki 
501bd3cdc31SAndrzej Bialecki 	if (clist == NULL || oidp == NULL)
502bd3cdc31SAndrzej Bialecki 		return (EINVAL);
503875b66a0SJohn Baldwin 	SYSCTL_XLOCK();
504bd3cdc31SAndrzej Bialecki 	e = sysctl_ctx_entry_find(clist, oidp);
505bd3cdc31SAndrzej Bialecki 	if (e != NULL) {
506bd3cdc31SAndrzej Bialecki 		TAILQ_REMOVE(clist, e, link);
507875b66a0SJohn Baldwin 		SYSCTL_XUNLOCK();
508bd3cdc31SAndrzej Bialecki 		free(e, M_SYSCTLOID);
509bd3cdc31SAndrzej Bialecki 		return (0);
510875b66a0SJohn Baldwin 	} else {
511875b66a0SJohn Baldwin 		SYSCTL_XUNLOCK();
512bd3cdc31SAndrzej Bialecki 		return (ENOENT);
513bd3cdc31SAndrzej Bialecki 	}
514875b66a0SJohn Baldwin }
515bd3cdc31SAndrzej Bialecki 
516bd3cdc31SAndrzej Bialecki /*
517bd3cdc31SAndrzej Bialecki  * Remove dynamically created sysctl trees.
518bd3cdc31SAndrzej Bialecki  * oidp - top of the tree to be removed
519bd3cdc31SAndrzej Bialecki  * del - if 0 - just deregister, otherwise free up entries as well
520bd3cdc31SAndrzej Bialecki  * recurse - if != 0 traverse the subtree to be deleted
521bd3cdc31SAndrzej Bialecki  */
522bd3cdc31SAndrzej Bialecki int
523bd3cdc31SAndrzej Bialecki sysctl_remove_oid(struct sysctl_oid *oidp, int del, int recurse)
524bd3cdc31SAndrzej Bialecki {
525875b66a0SJohn Baldwin 	int error;
526875b66a0SJohn Baldwin 
527875b66a0SJohn Baldwin 	SYSCTL_XLOCK();
528875b66a0SJohn Baldwin 	error = sysctl_remove_oid_locked(oidp, del, recurse);
529875b66a0SJohn Baldwin 	SYSCTL_XUNLOCK();
530875b66a0SJohn Baldwin 	return (error);
531875b66a0SJohn Baldwin }
532875b66a0SJohn Baldwin 
533e4cd31ddSJeff Roberson int
534e4cd31ddSJeff Roberson sysctl_remove_name(struct sysctl_oid *parent, const char *name,
535e4cd31ddSJeff Roberson     int del, int recurse)
536e4cd31ddSJeff Roberson {
537e4cd31ddSJeff Roberson 	struct sysctl_oid *p, *tmp;
538e4cd31ddSJeff Roberson 	int error;
539e4cd31ddSJeff Roberson 
540e4cd31ddSJeff Roberson 	error = ENOENT;
541e4cd31ddSJeff Roberson 	SYSCTL_XLOCK();
542e4cd31ddSJeff Roberson 	SLIST_FOREACH_SAFE(p, SYSCTL_CHILDREN(parent), oid_link, tmp) {
543e4cd31ddSJeff Roberson 		if (strcmp(p->oid_name, name) == 0) {
544e4cd31ddSJeff Roberson 			error = sysctl_remove_oid_locked(p, del, recurse);
545e4cd31ddSJeff Roberson 			break;
546e4cd31ddSJeff Roberson 		}
547e4cd31ddSJeff Roberson 	}
548e4cd31ddSJeff Roberson 	SYSCTL_XUNLOCK();
549e4cd31ddSJeff Roberson 
550e4cd31ddSJeff Roberson 	return (error);
551e4cd31ddSJeff Roberson }
552e4cd31ddSJeff Roberson 
553e4cd31ddSJeff Roberson 
554875b66a0SJohn Baldwin static int
555875b66a0SJohn Baldwin sysctl_remove_oid_locked(struct sysctl_oid *oidp, int del, int recurse)
556875b66a0SJohn Baldwin {
557e4cd31ddSJeff Roberson 	struct sysctl_oid *p, *tmp;
558bd3cdc31SAndrzej Bialecki 	int error;
559bd3cdc31SAndrzej Bialecki 
560875b66a0SJohn Baldwin 	SYSCTL_ASSERT_XLOCKED();
561bd3cdc31SAndrzej Bialecki 	if (oidp == NULL)
562bd3cdc31SAndrzej Bialecki 		return(EINVAL);
563bd3cdc31SAndrzej Bialecki 	if ((oidp->oid_kind & CTLFLAG_DYN) == 0) {
564bd3cdc31SAndrzej Bialecki 		printf("can't remove non-dynamic nodes!\n");
565bd3cdc31SAndrzej Bialecki 		return (EINVAL);
566bd3cdc31SAndrzej Bialecki 	}
567bd3cdc31SAndrzej Bialecki 	/*
568bd3cdc31SAndrzej Bialecki 	 * WARNING: normal method to do this should be through
569bd3cdc31SAndrzej Bialecki 	 * sysctl_ctx_free(). Use recursing as the last resort
570bd3cdc31SAndrzej Bialecki 	 * method to purge your sysctl tree of leftovers...
571bd3cdc31SAndrzej Bialecki 	 * However, if some other code still references these nodes,
572bd3cdc31SAndrzej Bialecki 	 * it will panic.
573bd3cdc31SAndrzej Bialecki 	 */
574bd3cdc31SAndrzej Bialecki 	if ((oidp->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
575bd3cdc31SAndrzej Bialecki 		if (oidp->oid_refcnt == 1) {
576e4cd31ddSJeff Roberson 			SLIST_FOREACH_SAFE(p,
577e4cd31ddSJeff Roberson 			    SYSCTL_CHILDREN(oidp), oid_link, tmp) {
578f510415dSScott Long 				if (!recurse) {
579f510415dSScott Long 					printf("Warning: failed attempt to "
580f510415dSScott Long 					    "remove oid %s with child %s\n",
581f510415dSScott Long 					    oidp->oid_name, p->oid_name);
582bd3cdc31SAndrzej Bialecki 					return (ENOTEMPTY);
583f510415dSScott Long 				}
584875b66a0SJohn Baldwin 				error = sysctl_remove_oid_locked(p, del,
585875b66a0SJohn Baldwin 				    recurse);
586bd3cdc31SAndrzej Bialecki 				if (error)
587bd3cdc31SAndrzej Bialecki 					return (error);
588bd3cdc31SAndrzej Bialecki 			}
589bd3cdc31SAndrzej Bialecki 		}
590bd3cdc31SAndrzej Bialecki 	}
591bd3cdc31SAndrzej Bialecki 	if (oidp->oid_refcnt > 1 ) {
592bd3cdc31SAndrzej Bialecki 		oidp->oid_refcnt--;
593bd3cdc31SAndrzej Bialecki 	} else {
594bd3cdc31SAndrzej Bialecki 		if (oidp->oid_refcnt == 0) {
595bd3cdc31SAndrzej Bialecki 			printf("Warning: bad oid_refcnt=%u (%s)!\n",
596bd3cdc31SAndrzej Bialecki 				oidp->oid_refcnt, oidp->oid_name);
597bd3cdc31SAndrzej Bialecki 			return (EINVAL);
598bd3cdc31SAndrzej Bialecki 		}
599bd3cdc31SAndrzej Bialecki 		sysctl_unregister_oid(oidp);
600bd3cdc31SAndrzej Bialecki 		if (del) {
601ccecef29SMatthew D Fleming 			/*
602ccecef29SMatthew D Fleming 			 * Wait for all threads running the handler to drain.
603ccecef29SMatthew D Fleming 			 * This preserves the previous behavior when the
604ccecef29SMatthew D Fleming 			 * sysctl lock was held across a handler invocation,
605ccecef29SMatthew D Fleming 			 * and is necessary for module unload correctness.
606ccecef29SMatthew D Fleming 			 */
607ccecef29SMatthew D Fleming 			while (oidp->oid_running > 0) {
608ccecef29SMatthew D Fleming 				oidp->oid_kind |= CTLFLAG_DYING;
609ccecef29SMatthew D Fleming 				SYSCTL_SLEEP(&oidp->oid_running, "oidrm", 0);
610ccecef29SMatthew D Fleming 			}
6115937226dSPoul-Henning Kamp 			if (oidp->oid_descr)
612db9066f7SMarius Strobl 				free(__DECONST(char *, oidp->oid_descr),
61393e8459aSPeter Wemm 				    M_SYSCTLOID);
614db9066f7SMarius Strobl 			free(__DECONST(char *, oidp->oid_name), M_SYSCTLOID);
615bd3cdc31SAndrzej Bialecki 			free(oidp, M_SYSCTLOID);
616bd3cdc31SAndrzej Bialecki 		}
617bd3cdc31SAndrzej Bialecki 	}
618bd3cdc31SAndrzej Bialecki 	return (0);
619bd3cdc31SAndrzej Bialecki }
620bd3cdc31SAndrzej Bialecki /*
621bd3cdc31SAndrzej Bialecki  * Create new sysctls at run time.
622bd3cdc31SAndrzej Bialecki  * clist may point to a valid context initialized with sysctl_ctx_init().
623bd3cdc31SAndrzej Bialecki  */
624bd3cdc31SAndrzej Bialecki struct sysctl_oid *
625bd3cdc31SAndrzej Bialecki sysctl_add_oid(struct sysctl_ctx_list *clist, struct sysctl_oid_list *parent,
626e4cd31ddSJeff Roberson 	int number, const char *name, int kind, void *arg1, intptr_t arg2,
627c5f9b6d0SJohn Baldwin 	int (*handler)(SYSCTL_HANDLER_ARGS), const char *fmt, const char *descr)
628bd3cdc31SAndrzej Bialecki {
629bd3cdc31SAndrzej Bialecki 	struct sysctl_oid *oidp;
630bd3cdc31SAndrzej Bialecki 
631bd3cdc31SAndrzej Bialecki 	/* You have to hook up somewhere.. */
632bd3cdc31SAndrzej Bialecki 	if (parent == NULL)
633bd3cdc31SAndrzej Bialecki 		return(NULL);
634bd3cdc31SAndrzej Bialecki 	/* Check if the node already exists, otherwise create it */
635875b66a0SJohn Baldwin 	SYSCTL_XLOCK();
636bd3cdc31SAndrzej Bialecki 	oidp = sysctl_find_oidname(name, parent);
637bd3cdc31SAndrzej Bialecki 	if (oidp != NULL) {
638bd3cdc31SAndrzej Bialecki 		if ((oidp->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
639bd3cdc31SAndrzej Bialecki 			oidp->oid_refcnt++;
640bd3cdc31SAndrzej Bialecki 			/* Update the context */
641bd3cdc31SAndrzej Bialecki 			if (clist != NULL)
642bd3cdc31SAndrzej Bialecki 				sysctl_ctx_entry_add(clist, oidp);
643875b66a0SJohn Baldwin 			SYSCTL_XUNLOCK();
644bd3cdc31SAndrzej Bialecki 			return (oidp);
645bd3cdc31SAndrzej Bialecki 		} else {
646875b66a0SJohn Baldwin 			SYSCTL_XUNLOCK();
647bd3cdc31SAndrzej Bialecki 			printf("can't re-use a leaf (%s)!\n", name);
648bd3cdc31SAndrzej Bialecki 			return (NULL);
649bd3cdc31SAndrzej Bialecki 		}
650bd3cdc31SAndrzej Bialecki 	}
651a163d034SWarner Losh 	oidp = malloc(sizeof(struct sysctl_oid), M_SYSCTLOID, M_WAITOK|M_ZERO);
652bd3cdc31SAndrzej Bialecki 	oidp->oid_parent = parent;
653af3b2549SHans Petter Selasky 	SLIST_INIT(&oidp->oid_children);
654bd3cdc31SAndrzej Bialecki 	oidp->oid_number = number;
655bd3cdc31SAndrzej Bialecki 	oidp->oid_refcnt = 1;
656db9066f7SMarius Strobl 	oidp->oid_name = strdup(name, M_SYSCTLOID);
657bd3cdc31SAndrzej Bialecki 	oidp->oid_handler = handler;
658bd3cdc31SAndrzej Bialecki 	oidp->oid_kind = CTLFLAG_DYN | kind;
659bd3cdc31SAndrzej Bialecki 	oidp->oid_arg1 = arg1;
660bd3cdc31SAndrzej Bialecki 	oidp->oid_arg2 = arg2;
661bd3cdc31SAndrzej Bialecki 	oidp->oid_fmt = fmt;
662af3b2549SHans Petter Selasky 	if (descr != NULL)
663db9066f7SMarius Strobl 		oidp->oid_descr = strdup(descr, M_SYSCTLOID);
664bd3cdc31SAndrzej Bialecki 	/* Update the context, if used */
665bd3cdc31SAndrzej Bialecki 	if (clist != NULL)
666bd3cdc31SAndrzej Bialecki 		sysctl_ctx_entry_add(clist, oidp);
667bd3cdc31SAndrzej Bialecki 	/* Register this oid */
668bd3cdc31SAndrzej Bialecki 	sysctl_register_oid(oidp);
669875b66a0SJohn Baldwin 	SYSCTL_XUNLOCK();
670bd3cdc31SAndrzej Bialecki 	return (oidp);
671bd3cdc31SAndrzej Bialecki }
672bd3cdc31SAndrzej Bialecki 
673ce02431fSDoug Rabson /*
674cd17ceaaSPeter Wemm  * Rename an existing oid.
675cd17ceaaSPeter Wemm  */
676cd17ceaaSPeter Wemm void
677cd17ceaaSPeter Wemm sysctl_rename_oid(struct sysctl_oid *oidp, const char *name)
678cd17ceaaSPeter Wemm {
679cd17ceaaSPeter Wemm 	char *newname;
680db9066f7SMarius Strobl 	char *oldname;
681cd17ceaaSPeter Wemm 
682db9066f7SMarius Strobl 	newname = strdup(name, M_SYSCTLOID);
683875b66a0SJohn Baldwin 	SYSCTL_XLOCK();
684db9066f7SMarius Strobl 	oldname = __DECONST(char *, oidp->oid_name);
685cd17ceaaSPeter Wemm 	oidp->oid_name = newname;
686875b66a0SJohn Baldwin 	SYSCTL_XUNLOCK();
687cd17ceaaSPeter Wemm 	free(oldname, M_SYSCTLOID);
688cd17ceaaSPeter Wemm }
689cd17ceaaSPeter Wemm 
690cd17ceaaSPeter Wemm /*
69121885af5SDag-Erling Smørgrav  * Reparent an existing oid.
69221885af5SDag-Erling Smørgrav  */
69321885af5SDag-Erling Smørgrav int
69421885af5SDag-Erling Smørgrav sysctl_move_oid(struct sysctl_oid *oid, struct sysctl_oid_list *parent)
69521885af5SDag-Erling Smørgrav {
69621885af5SDag-Erling Smørgrav 	struct sysctl_oid *oidp;
69721885af5SDag-Erling Smørgrav 
698875b66a0SJohn Baldwin 	SYSCTL_XLOCK();
699875b66a0SJohn Baldwin 	if (oid->oid_parent == parent) {
700875b66a0SJohn Baldwin 		SYSCTL_XUNLOCK();
70121885af5SDag-Erling Smørgrav 		return (0);
702875b66a0SJohn Baldwin 	}
70321885af5SDag-Erling Smørgrav 	oidp = sysctl_find_oidname(oid->oid_name, parent);
704875b66a0SJohn Baldwin 	if (oidp != NULL) {
705875b66a0SJohn Baldwin 		SYSCTL_XUNLOCK();
70621885af5SDag-Erling Smørgrav 		return (EEXIST);
707875b66a0SJohn Baldwin 	}
70821885af5SDag-Erling Smørgrav 	sysctl_unregister_oid(oid);
70921885af5SDag-Erling Smørgrav 	oid->oid_parent = parent;
71021885af5SDag-Erling Smørgrav 	oid->oid_number = OID_AUTO;
71121885af5SDag-Erling Smørgrav 	sysctl_register_oid(oid);
712875b66a0SJohn Baldwin 	SYSCTL_XUNLOCK();
71321885af5SDag-Erling Smørgrav 	return (0);
71421885af5SDag-Erling Smørgrav }
71521885af5SDag-Erling Smørgrav 
71621885af5SDag-Erling Smørgrav /*
717ce02431fSDoug Rabson  * Register the kernel's oids on startup.
718ce02431fSDoug Rabson  */
719f41325dbSPeter Wemm SET_DECLARE(sysctl_set, struct sysctl_oid);
720ce02431fSDoug Rabson 
721107e7dc5SPeter Pentchev static void
722107e7dc5SPeter Pentchev sysctl_register_all(void *arg)
723ce02431fSDoug Rabson {
724f41325dbSPeter Wemm 	struct sysctl_oid **oidp;
725ce02431fSDoug Rabson 
7263e829b18SJohn Baldwin 	sx_init(&sysctlmemlock, "sysctl mem");
7273bd1da29SRobert Watson 	SYSCTL_INIT();
728875b66a0SJohn Baldwin 	SYSCTL_XLOCK();
729f41325dbSPeter Wemm 	SET_FOREACH(oidp, sysctl_set)
730f41325dbSPeter Wemm 		sysctl_register_oid(*oidp);
731875b66a0SJohn Baldwin 	SYSCTL_XUNLOCK();
732f41325dbSPeter Wemm }
733af3b2549SHans Petter Selasky SYSINIT(sysctl, SI_SUB_KMEM, SI_ORDER_FIRST, sysctl_register_all, 0);
734ce02431fSDoug Rabson 
735946bb7a2SPoul-Henning Kamp /*
736946bb7a2SPoul-Henning Kamp  * "Staff-functions"
737946bb7a2SPoul-Henning Kamp  *
73865d0bc13SPoul-Henning Kamp  * These functions implement a presently undocumented interface
73965d0bc13SPoul-Henning Kamp  * used by the sysctl program to walk the tree, and get the type
74065d0bc13SPoul-Henning Kamp  * so it can print the value.
74165d0bc13SPoul-Henning Kamp  * This interface is under work and consideration, and should probably
74265d0bc13SPoul-Henning Kamp  * be killed with a big axe by the first person who can find the time.
74365d0bc13SPoul-Henning Kamp  * (be aware though, that the proper interface isn't as obvious as it
74465d0bc13SPoul-Henning Kamp  * may seem, there are various conflicting requirements.
74565d0bc13SPoul-Henning Kamp  *
746946bb7a2SPoul-Henning Kamp  * {0,0}	printf the entire MIB-tree.
747946bb7a2SPoul-Henning Kamp  * {0,1,...}	return the name of the "..." OID.
74886415b71SPoul-Henning Kamp  * {0,2,...}	return the next OID.
749946bb7a2SPoul-Henning Kamp  * {0,3}	return the OID of the name in "new"
75065d0bc13SPoul-Henning Kamp  * {0,4,...}	return the kind & format info for the "..." OID.
7516105f815SLuigi Rizzo  * {0,5,...}	return the description the "..." OID.
752946bb7a2SPoul-Henning Kamp  */
753946bb7a2SPoul-Henning Kamp 
754df970488SRobert Watson #ifdef SYSCTL_DEBUG
755787d58f2SPoul-Henning Kamp static void
756ce02431fSDoug Rabson sysctl_sysctl_debug_dump_node(struct sysctl_oid_list *l, int i)
757787d58f2SPoul-Henning Kamp {
758ce02431fSDoug Rabson 	int k;
759ce02431fSDoug Rabson 	struct sysctl_oid *oidp;
760787d58f2SPoul-Henning Kamp 
761fca77320SMateusz Guzik 	SYSCTL_ASSERT_LOCKED();
762ce02431fSDoug Rabson 	SLIST_FOREACH(oidp, l, oid_link) {
763787d58f2SPoul-Henning Kamp 
764787d58f2SPoul-Henning Kamp 		for (k=0; k<i; k++)
765787d58f2SPoul-Henning Kamp 			printf(" ");
766787d58f2SPoul-Henning Kamp 
767ce02431fSDoug Rabson 		printf("%d %s ", oidp->oid_number, oidp->oid_name);
768787d58f2SPoul-Henning Kamp 
769787d58f2SPoul-Henning Kamp 		printf("%c%c",
770ce02431fSDoug Rabson 			oidp->oid_kind & CTLFLAG_RD ? 'R':' ',
771ce02431fSDoug Rabson 			oidp->oid_kind & CTLFLAG_WR ? 'W':' ');
772787d58f2SPoul-Henning Kamp 
773ce02431fSDoug Rabson 		if (oidp->oid_handler)
77461220614SPoul-Henning Kamp 			printf(" *Handler");
77561220614SPoul-Henning Kamp 
776ce02431fSDoug Rabson 		switch (oidp->oid_kind & CTLTYPE) {
777787d58f2SPoul-Henning Kamp 			case CTLTYPE_NODE:
778787d58f2SPoul-Henning Kamp 				printf(" Node\n");
779ce02431fSDoug Rabson 				if (!oidp->oid_handler) {
780787d58f2SPoul-Henning Kamp 					sysctl_sysctl_debug_dump_node(
781af3b2549SHans Petter Selasky 					    SYSCTL_CHILDREN(oidp), i + 2);
782787d58f2SPoul-Henning Kamp 				}
783787d58f2SPoul-Henning Kamp 				break;
784787d58f2SPoul-Henning Kamp 			case CTLTYPE_INT:    printf(" Int\n"); break;
785cbc134adSMatthew D Fleming 			case CTLTYPE_UINT:   printf(" u_int\n"); break;
786cbc134adSMatthew D Fleming 			case CTLTYPE_LONG:   printf(" Long\n"); break;
787cbc134adSMatthew D Fleming 			case CTLTYPE_ULONG:  printf(" u_long\n"); break;
788787d58f2SPoul-Henning Kamp 			case CTLTYPE_STRING: printf(" String\n"); break;
789cbc134adSMatthew D Fleming 			case CTLTYPE_U64:    printf(" uint64_t\n"); break;
790cbc134adSMatthew D Fleming 			case CTLTYPE_S64:    printf(" int64_t\n"); break;
791787d58f2SPoul-Henning Kamp 			case CTLTYPE_OPAQUE: printf(" Opaque/struct\n"); break;
792787d58f2SPoul-Henning Kamp 			default:	     printf("\n");
793787d58f2SPoul-Henning Kamp 		}
794787d58f2SPoul-Henning Kamp 
795787d58f2SPoul-Henning Kamp 	}
796787d58f2SPoul-Henning Kamp }
797787d58f2SPoul-Henning Kamp 
798787d58f2SPoul-Henning Kamp static int
79982d9ae4eSPoul-Henning Kamp sysctl_sysctl_debug(SYSCTL_HANDLER_ARGS)
800787d58f2SPoul-Henning Kamp {
801023a0e61SPeter Wemm 	int error;
802023a0e61SPeter Wemm 
803acd3428bSRobert Watson 	error = priv_check(req->td, PRIV_SYSCTL_DEBUG);
804023a0e61SPeter Wemm 	if (error)
80546003fb3SPawel Jakub Dawidek 		return (error);
806fca77320SMateusz Guzik 	SYSCTL_SLOCK();
807ce02431fSDoug Rabson 	sysctl_sysctl_debug_dump_node(&sysctl__children, 0);
808fca77320SMateusz Guzik 	SYSCTL_SUNLOCK();
80946003fb3SPawel Jakub Dawidek 	return (ENOENT);
810787d58f2SPoul-Henning Kamp }
811787d58f2SPoul-Henning Kamp 
812fca77320SMateusz Guzik SYSCTL_PROC(_sysctl, 0, debug, CTLTYPE_STRING|CTLFLAG_RD|CTLFLAG_MPSAFE,
813946bb7a2SPoul-Henning Kamp 	0, 0, sysctl_sysctl_debug, "-", "");
814df970488SRobert Watson #endif
8152e210993SPoul-Henning Kamp 
816946bb7a2SPoul-Henning Kamp static int
81782d9ae4eSPoul-Henning Kamp sysctl_sysctl_name(SYSCTL_HANDLER_ARGS)
818946bb7a2SPoul-Henning Kamp {
819946bb7a2SPoul-Henning Kamp 	int *name = (int *) arg1;
820946bb7a2SPoul-Henning Kamp 	u_int namelen = arg2;
821ce02431fSDoug Rabson 	int error = 0;
822ce02431fSDoug Rabson 	struct sysctl_oid *oid;
8237f4173ccSPoul-Henning Kamp 	struct sysctl_oid_list *lsp = &sysctl__children, *lsp2;
824946bb7a2SPoul-Henning Kamp 	char buf[10];
8252e210993SPoul-Henning Kamp 
826fca77320SMateusz Guzik 	SYSCTL_SLOCK();
827946bb7a2SPoul-Henning Kamp 	while (namelen) {
828946bb7a2SPoul-Henning Kamp 		if (!lsp) {
8292127f260SArchie Cobbs 			snprintf(buf,sizeof(buf),"%d",*name);
830946bb7a2SPoul-Henning Kamp 			if (req->oldidx)
831946bb7a2SPoul-Henning Kamp 				error = SYSCTL_OUT(req, ".", 1);
832946bb7a2SPoul-Henning Kamp 			if (!error)
833946bb7a2SPoul-Henning Kamp 				error = SYSCTL_OUT(req, buf, strlen(buf));
834946bb7a2SPoul-Henning Kamp 			if (error)
835ccecef29SMatthew D Fleming 				goto out;
836946bb7a2SPoul-Henning Kamp 			namelen--;
837946bb7a2SPoul-Henning Kamp 			name++;
838946bb7a2SPoul-Henning Kamp 			continue;
839946bb7a2SPoul-Henning Kamp 		}
8407f4173ccSPoul-Henning Kamp 		lsp2 = 0;
841ce02431fSDoug Rabson 		SLIST_FOREACH(oid, lsp, oid_link) {
842ce02431fSDoug Rabson 			if (oid->oid_number != *name)
843946bb7a2SPoul-Henning Kamp 				continue;
844946bb7a2SPoul-Henning Kamp 
845946bb7a2SPoul-Henning Kamp 			if (req->oldidx)
846946bb7a2SPoul-Henning Kamp 				error = SYSCTL_OUT(req, ".", 1);
847946bb7a2SPoul-Henning Kamp 			if (!error)
848ce02431fSDoug Rabson 				error = SYSCTL_OUT(req, oid->oid_name,
849ce02431fSDoug Rabson 					strlen(oid->oid_name));
850946bb7a2SPoul-Henning Kamp 			if (error)
851ccecef29SMatthew D Fleming 				goto out;
852946bb7a2SPoul-Henning Kamp 
853946bb7a2SPoul-Henning Kamp 			namelen--;
854946bb7a2SPoul-Henning Kamp 			name++;
855946bb7a2SPoul-Henning Kamp 
856ce02431fSDoug Rabson 			if ((oid->oid_kind & CTLTYPE) != CTLTYPE_NODE)
857946bb7a2SPoul-Henning Kamp 				break;
858946bb7a2SPoul-Henning Kamp 
859ce02431fSDoug Rabson 			if (oid->oid_handler)
860946bb7a2SPoul-Henning Kamp 				break;
861946bb7a2SPoul-Henning Kamp 
8625127ecb8SMatthew D Fleming 			lsp2 = SYSCTL_CHILDREN(oid);
863946bb7a2SPoul-Henning Kamp 			break;
864946bb7a2SPoul-Henning Kamp 		}
8657f4173ccSPoul-Henning Kamp 		lsp = lsp2;
866946bb7a2SPoul-Henning Kamp 	}
867ccecef29SMatthew D Fleming 	error = SYSCTL_OUT(req, "", 1);
868ccecef29SMatthew D Fleming  out:
869fca77320SMateusz Guzik 	SYSCTL_SUNLOCK();
870ccecef29SMatthew D Fleming 	return (error);
871946bb7a2SPoul-Henning Kamp }
872946bb7a2SPoul-Henning Kamp 
873ff66f6a4SRobert Watson /*
874ff66f6a4SRobert Watson  * XXXRW/JA: Shouldn't return name data for nodes that we don't permit in
875ff66f6a4SRobert Watson  * capability mode.
876ff66f6a4SRobert Watson  */
877fca77320SMateusz Guzik static SYSCTL_NODE(_sysctl, 1, name, CTLFLAG_RD | CTLFLAG_MPSAFE | CTLFLAG_CAPRD,
878ff66f6a4SRobert Watson     sysctl_sysctl_name, "");
879946bb7a2SPoul-Henning Kamp 
880946bb7a2SPoul-Henning Kamp static int
881ce02431fSDoug Rabson sysctl_sysctl_next_ls(struct sysctl_oid_list *lsp, int *name, u_int namelen,
882ce02431fSDoug Rabson 	int *next, int *len, int level, struct sysctl_oid **oidpp)
883946bb7a2SPoul-Henning Kamp {
884ce02431fSDoug Rabson 	struct sysctl_oid *oidp;
885946bb7a2SPoul-Henning Kamp 
886efe0abddSMateusz Guzik 	SYSCTL_ASSERT_LOCKED();
887946bb7a2SPoul-Henning Kamp 	*len = level;
888ce02431fSDoug Rabson 	SLIST_FOREACH(oidp, lsp, oid_link) {
889ce02431fSDoug Rabson 		*next = oidp->oid_number;
890ce02431fSDoug Rabson 		*oidpp = oidp;
891946bb7a2SPoul-Henning Kamp 
892306e6b83SMaxime Henrion 		if (oidp->oid_kind & CTLFLAG_SKIP)
893306e6b83SMaxime Henrion 			continue;
894306e6b83SMaxime Henrion 
895946bb7a2SPoul-Henning Kamp 		if (!namelen) {
896ce02431fSDoug Rabson 			if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
89746003fb3SPawel Jakub Dawidek 				return (0);
898ce02431fSDoug Rabson 			if (oidp->oid_handler)
899946bb7a2SPoul-Henning Kamp 				/* We really should call the handler here...*/
90046003fb3SPawel Jakub Dawidek 				return (0);
9015127ecb8SMatthew D Fleming 			lsp = SYSCTL_CHILDREN(oidp);
90261220614SPoul-Henning Kamp 			if (!sysctl_sysctl_next_ls(lsp, 0, 0, next+1,
903ce02431fSDoug Rabson 				len, level+1, oidpp))
90446003fb3SPawel Jakub Dawidek 				return (0);
90590623e1aSRobert Watson 			goto emptynode;
906946bb7a2SPoul-Henning Kamp 		}
907946bb7a2SPoul-Henning Kamp 
908ce02431fSDoug Rabson 		if (oidp->oid_number < *name)
909946bb7a2SPoul-Henning Kamp 			continue;
910946bb7a2SPoul-Henning Kamp 
911ce02431fSDoug Rabson 		if (oidp->oid_number > *name) {
912ce02431fSDoug Rabson 			if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
91346003fb3SPawel Jakub Dawidek 				return (0);
914ce02431fSDoug Rabson 			if (oidp->oid_handler)
91546003fb3SPawel Jakub Dawidek 				return (0);
9165127ecb8SMatthew D Fleming 			lsp = SYSCTL_CHILDREN(oidp);
917946bb7a2SPoul-Henning Kamp 			if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1,
918ce02431fSDoug Rabson 				next+1, len, level+1, oidpp))
919946bb7a2SPoul-Henning Kamp 				return (0);
92061220614SPoul-Henning Kamp 			goto next;
921946bb7a2SPoul-Henning Kamp 		}
922ce02431fSDoug Rabson 		if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
923946bb7a2SPoul-Henning Kamp 			continue;
924946bb7a2SPoul-Henning Kamp 
925ce02431fSDoug Rabson 		if (oidp->oid_handler)
926946bb7a2SPoul-Henning Kamp 			continue;
927946bb7a2SPoul-Henning Kamp 
9285127ecb8SMatthew D Fleming 		lsp = SYSCTL_CHILDREN(oidp);
929946bb7a2SPoul-Henning Kamp 		if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1, next+1,
930ce02431fSDoug Rabson 			len, level+1, oidpp))
931946bb7a2SPoul-Henning Kamp 			return (0);
93261220614SPoul-Henning Kamp 	next:
933946bb7a2SPoul-Henning Kamp 		namelen = 1;
93490623e1aSRobert Watson 	emptynode:
935946bb7a2SPoul-Henning Kamp 		*len = level;
936946bb7a2SPoul-Henning Kamp 	}
93746003fb3SPawel Jakub Dawidek 	return (1);
938946bb7a2SPoul-Henning Kamp }
939946bb7a2SPoul-Henning Kamp 
940946bb7a2SPoul-Henning Kamp static int
94182d9ae4eSPoul-Henning Kamp sysctl_sysctl_next(SYSCTL_HANDLER_ARGS)
942946bb7a2SPoul-Henning Kamp {
943946bb7a2SPoul-Henning Kamp 	int *name = (int *) arg1;
944946bb7a2SPoul-Henning Kamp 	u_int namelen = arg2;
945946bb7a2SPoul-Henning Kamp 	int i, j, error;
946946bb7a2SPoul-Henning Kamp 	struct sysctl_oid *oid;
947ce02431fSDoug Rabson 	struct sysctl_oid_list *lsp = &sysctl__children;
948946bb7a2SPoul-Henning Kamp 	int newoid[CTL_MAXNAME];
949946bb7a2SPoul-Henning Kamp 
950fca77320SMateusz Guzik 	SYSCTL_SLOCK();
951946bb7a2SPoul-Henning Kamp 	i = sysctl_sysctl_next_ls(lsp, name, namelen, newoid, &j, 1, &oid);
952fca77320SMateusz Guzik 	SYSCTL_SUNLOCK();
953946bb7a2SPoul-Henning Kamp 	if (i)
95446003fb3SPawel Jakub Dawidek 		return (ENOENT);
955946bb7a2SPoul-Henning Kamp 	error = SYSCTL_OUT(req, newoid, j * sizeof (int));
956946bb7a2SPoul-Henning Kamp 	return (error);
957946bb7a2SPoul-Henning Kamp }
958946bb7a2SPoul-Henning Kamp 
959ff66f6a4SRobert Watson /*
960ff66f6a4SRobert Watson  * XXXRW/JA: Shouldn't return next data for nodes that we don't permit in
961ff66f6a4SRobert Watson  * capability mode.
962ff66f6a4SRobert Watson  */
963fca77320SMateusz Guzik static SYSCTL_NODE(_sysctl, 2, next, CTLFLAG_RD | CTLFLAG_MPSAFE | CTLFLAG_CAPRD,
964ff66f6a4SRobert Watson     sysctl_sysctl_next, "");
965946bb7a2SPoul-Henning Kamp 
966946bb7a2SPoul-Henning Kamp static int
967ce02431fSDoug Rabson name2oid(char *name, int *oid, int *len, struct sysctl_oid **oidpp)
968946bb7a2SPoul-Henning Kamp {
969ce02431fSDoug Rabson 	struct sysctl_oid *oidp;
970ce02431fSDoug Rabson 	struct sysctl_oid_list *lsp = &sysctl__children;
971946bb7a2SPoul-Henning Kamp 	char *p;
972946bb7a2SPoul-Henning Kamp 
973efe0abddSMateusz Guzik 	SYSCTL_ASSERT_LOCKED();
974ddf9d243SEd Schouten 
975db9066f7SMarius Strobl 	for (*len = 0; *len < CTL_MAXNAME;) {
976db9066f7SMarius Strobl 		p = strsep(&name, ".");
977946bb7a2SPoul-Henning Kamp 
978ce02431fSDoug Rabson 		oidp = SLIST_FIRST(lsp);
979db9066f7SMarius Strobl 		for (;; oidp = SLIST_NEXT(oidp, oid_link)) {
980db9066f7SMarius Strobl 			if (oidp == NULL)
981db9066f7SMarius Strobl 				return (ENOENT);
982db9066f7SMarius Strobl 			if (strcmp(p, oidp->oid_name) == 0)
983db9066f7SMarius Strobl 				break;
984946bb7a2SPoul-Henning Kamp 		}
985ce02431fSDoug Rabson 		*oid++ = oidp->oid_number;
986946bb7a2SPoul-Henning Kamp 		(*len)++;
987946bb7a2SPoul-Henning Kamp 
988db9066f7SMarius Strobl 		if (name == NULL || *name == '\0') {
989ce02431fSDoug Rabson 			if (oidpp)
990ce02431fSDoug Rabson 				*oidpp = oidp;
991946bb7a2SPoul-Henning Kamp 			return (0);
992946bb7a2SPoul-Henning Kamp 		}
993946bb7a2SPoul-Henning Kamp 
994ce02431fSDoug Rabson 		if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
995946bb7a2SPoul-Henning Kamp 			break;
996946bb7a2SPoul-Henning Kamp 
997ce02431fSDoug Rabson 		if (oidp->oid_handler)
998946bb7a2SPoul-Henning Kamp 			break;
999946bb7a2SPoul-Henning Kamp 
10005127ecb8SMatthew D Fleming 		lsp = SYSCTL_CHILDREN(oidp);
1001946bb7a2SPoul-Henning Kamp 	}
100246003fb3SPawel Jakub Dawidek 	return (ENOENT);
1003946bb7a2SPoul-Henning Kamp }
1004946bb7a2SPoul-Henning Kamp 
1005946bb7a2SPoul-Henning Kamp static int
100682d9ae4eSPoul-Henning Kamp sysctl_sysctl_name2oid(SYSCTL_HANDLER_ARGS)
1007946bb7a2SPoul-Henning Kamp {
1008946bb7a2SPoul-Henning Kamp 	char *p;
1009dd6312a7SMatthew D Fleming 	int error, oid[CTL_MAXNAME], len = 0;
1010946bb7a2SPoul-Henning Kamp 	struct sysctl_oid *op = 0;
1011946bb7a2SPoul-Henning Kamp 
1012946bb7a2SPoul-Henning Kamp 	if (!req->newlen)
101346003fb3SPawel Jakub Dawidek 		return (ENOENT);
10146a5d592aSPoul-Henning Kamp 	if (req->newlen >= MAXPATHLEN)	/* XXX arbitrary, undocumented */
10156a5d592aSPoul-Henning Kamp 		return (ENAMETOOLONG);
1016946bb7a2SPoul-Henning Kamp 
1017a163d034SWarner Losh 	p = malloc(req->newlen+1, M_SYSCTL, M_WAITOK);
1018946bb7a2SPoul-Henning Kamp 
1019946bb7a2SPoul-Henning Kamp 	error = SYSCTL_IN(req, p, req->newlen);
1020946bb7a2SPoul-Henning Kamp 	if (error) {
1021946bb7a2SPoul-Henning Kamp 		free(p, M_SYSCTL);
1022946bb7a2SPoul-Henning Kamp 		return (error);
1023946bb7a2SPoul-Henning Kamp 	}
1024946bb7a2SPoul-Henning Kamp 
1025946bb7a2SPoul-Henning Kamp 	p [req->newlen] = '\0';
1026946bb7a2SPoul-Henning Kamp 
1027b564c5d6SMateusz Guzik 	SYSCTL_SLOCK();
1028946bb7a2SPoul-Henning Kamp 	error = name2oid(p, oid, &len, &op);
1029b564c5d6SMateusz Guzik 	SYSCTL_SUNLOCK();
1030946bb7a2SPoul-Henning Kamp 
1031946bb7a2SPoul-Henning Kamp 	free(p, M_SYSCTL);
1032946bb7a2SPoul-Henning Kamp 
1033946bb7a2SPoul-Henning Kamp 	if (error)
1034946bb7a2SPoul-Henning Kamp 		return (error);
1035946bb7a2SPoul-Henning Kamp 
1036946bb7a2SPoul-Henning Kamp 	error = SYSCTL_OUT(req, oid, len * sizeof *oid);
1037946bb7a2SPoul-Henning Kamp 	return (error);
1038946bb7a2SPoul-Henning Kamp }
1039946bb7a2SPoul-Henning Kamp 
1040ff66f6a4SRobert Watson /*
1041ff66f6a4SRobert Watson  * XXXRW/JA: Shouldn't return name2oid data for nodes that we don't permit in
1042ff66f6a4SRobert Watson  * capability mode.
1043ff66f6a4SRobert Watson  */
10442fee06f0SMatthew D Fleming SYSCTL_PROC(_sysctl, 3, name2oid,
1045ff66f6a4SRobert Watson     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_MPSAFE
1046ff66f6a4SRobert Watson     | CTLFLAG_CAPRW, 0, 0, sysctl_sysctl_name2oid, "I", "");
1047946bb7a2SPoul-Henning Kamp 
1048946bb7a2SPoul-Henning Kamp static int
104982d9ae4eSPoul-Henning Kamp sysctl_sysctl_oidfmt(SYSCTL_HANDLER_ARGS)
1050946bb7a2SPoul-Henning Kamp {
1051ce02431fSDoug Rabson 	struct sysctl_oid *oid;
1052226420a4SBrian Feldman 	int error;
1053946bb7a2SPoul-Henning Kamp 
1054fca77320SMateusz Guzik 	SYSCTL_SLOCK();
1055226420a4SBrian Feldman 	error = sysctl_find_oid(arg1, arg2, &oid, NULL, req);
1056226420a4SBrian Feldman 	if (error)
1057ccecef29SMatthew D Fleming 		goto out;
1058946bb7a2SPoul-Henning Kamp 
1059ccecef29SMatthew D Fleming 	if (oid->oid_fmt == NULL) {
1060ccecef29SMatthew D Fleming 		error = ENOENT;
1061ccecef29SMatthew D Fleming 		goto out;
1062ccecef29SMatthew D Fleming 	}
1063226420a4SBrian Feldman 	error = SYSCTL_OUT(req, &oid->oid_kind, sizeof(oid->oid_kind));
1064226420a4SBrian Feldman 	if (error)
1065ccecef29SMatthew D Fleming 		goto out;
1066226420a4SBrian Feldman 	error = SYSCTL_OUT(req, oid->oid_fmt, strlen(oid->oid_fmt) + 1);
1067ccecef29SMatthew D Fleming  out:
1068fca77320SMateusz Guzik 	SYSCTL_SUNLOCK();
106965d0bc13SPoul-Henning Kamp 	return (error);
1070946bb7a2SPoul-Henning Kamp }
1071946bb7a2SPoul-Henning Kamp 
107286415b71SPoul-Henning Kamp 
1073ff66f6a4SRobert Watson static SYSCTL_NODE(_sysctl, 4, oidfmt, CTLFLAG_RD|CTLFLAG_MPSAFE|CTLFLAG_CAPRD,
1074f3b86a5fSEd Schouten     sysctl_sysctl_oidfmt, "");
1075946bb7a2SPoul-Henning Kamp 
10766105f815SLuigi Rizzo static int
10776105f815SLuigi Rizzo sysctl_sysctl_oiddescr(SYSCTL_HANDLER_ARGS)
10786105f815SLuigi Rizzo {
10796105f815SLuigi Rizzo 	struct sysctl_oid *oid;
10806105f815SLuigi Rizzo 	int error;
10816105f815SLuigi Rizzo 
1082fca77320SMateusz Guzik 	SYSCTL_SLOCK();
10836105f815SLuigi Rizzo 	error = sysctl_find_oid(arg1, arg2, &oid, NULL, req);
10846105f815SLuigi Rizzo 	if (error)
1085ccecef29SMatthew D Fleming 		goto out;
10866105f815SLuigi Rizzo 
1087ccecef29SMatthew D Fleming 	if (oid->oid_descr == NULL) {
1088ccecef29SMatthew D Fleming 		error = ENOENT;
1089ccecef29SMatthew D Fleming 		goto out;
1090ccecef29SMatthew D Fleming 	}
10915937226dSPoul-Henning Kamp 	error = SYSCTL_OUT(req, oid->oid_descr, strlen(oid->oid_descr) + 1);
1092ccecef29SMatthew D Fleming  out:
1093fca77320SMateusz Guzik 	SYSCTL_SUNLOCK();
10946105f815SLuigi Rizzo 	return (error);
10956105f815SLuigi Rizzo }
10966105f815SLuigi Rizzo 
1097fca77320SMateusz Guzik static SYSCTL_NODE(_sysctl, 5, oiddescr, CTLFLAG_RD|CTLFLAG_MPSAFE|CTLFLAG_CAPRD,
1098ff66f6a4SRobert Watson     sysctl_sysctl_oiddescr, "");
10996105f815SLuigi Rizzo 
1100946bb7a2SPoul-Henning Kamp /*
1101946bb7a2SPoul-Henning Kamp  * Default "handler" functions.
1102946bb7a2SPoul-Henning Kamp  */
11032e210993SPoul-Henning Kamp 
1104ae0eb976SPoul-Henning Kamp /*
1105486bddb0SDoug Rabson  * Handle an int, signed or unsigned.
1106ae0eb976SPoul-Henning Kamp  * Two cases:
1107ae0eb976SPoul-Henning Kamp  *     a variable:  point arg1 at it.
1108ae0eb976SPoul-Henning Kamp  *     a constant:  pass it in arg2.
1109ae0eb976SPoul-Henning Kamp  */
1110ae0eb976SPoul-Henning Kamp 
11113a34a5c3SPoul-Henning Kamp int
111282d9ae4eSPoul-Henning Kamp sysctl_handle_int(SYSCTL_HANDLER_ARGS)
1113b396cd83SPoul-Henning Kamp {
11149e74cba3SDon Lewis 	int tmpout, error = 0;
1115b396cd83SPoul-Henning Kamp 
11169e74cba3SDon Lewis 	/*
11179e74cba3SDon Lewis 	 * Attempt to get a coherent snapshot by making a copy of the data.
11189e74cba3SDon Lewis 	 */
1119ae0eb976SPoul-Henning Kamp 	if (arg1)
11209e74cba3SDon Lewis 		tmpout = *(int *)arg1;
11211fbf1f71SBruce Evans 	else
11229e74cba3SDon Lewis 		tmpout = arg2;
11239e74cba3SDon Lewis 	error = SYSCTL_OUT(req, &tmpout, sizeof(int));
1124b396cd83SPoul-Henning Kamp 
1125ae0eb976SPoul-Henning Kamp 	if (error || !req->newptr)
1126ae0eb976SPoul-Henning Kamp 		return (error);
1127b396cd83SPoul-Henning Kamp 
1128ae0eb976SPoul-Henning Kamp 	if (!arg1)
1129ae0eb976SPoul-Henning Kamp 		error = EPERM;
1130ae0eb976SPoul-Henning Kamp 	else
1131ae0eb976SPoul-Henning Kamp 		error = SYSCTL_IN(req, arg1, sizeof(int));
1132ae0eb976SPoul-Henning Kamp 	return (error);
1133b396cd83SPoul-Henning Kamp }
1134b396cd83SPoul-Henning Kamp 
1135a4684d74SAndre Oppermann /*
1136a4684d74SAndre Oppermann  * Based on on sysctl_handle_int() convert milliseconds into ticks.
1137eddfbb76SRobert Watson  * Note: this is used by TCP.
1138a4684d74SAndre Oppermann  */
1139a4684d74SAndre Oppermann 
1140a4684d74SAndre Oppermann int
1141a4684d74SAndre Oppermann sysctl_msec_to_ticks(SYSCTL_HANDLER_ARGS)
1142a4684d74SAndre Oppermann {
1143a4684d74SAndre Oppermann 	int error, s, tt;
1144a4684d74SAndre Oppermann 
1145f6dfe47aSMarko Zec 	tt = *(int *)arg1;
1146a4684d74SAndre Oppermann 	s = (int)((int64_t)tt * 1000 / hz);
1147a4684d74SAndre Oppermann 
1148a4684d74SAndre Oppermann 	error = sysctl_handle_int(oidp, &s, 0, req);
1149a4684d74SAndre Oppermann 	if (error || !req->newptr)
1150a4684d74SAndre Oppermann 		return (error);
1151a4684d74SAndre Oppermann 
1152a4684d74SAndre Oppermann 	tt = (int)((int64_t)s * hz / 1000);
1153a4684d74SAndre Oppermann 	if (tt < 1)
1154a4684d74SAndre Oppermann 		return (EINVAL);
1155a4684d74SAndre Oppermann 
1156f6dfe47aSMarko Zec 	*(int *)arg1 = tt;
1157a4684d74SAndre Oppermann 	return (0);
1158a4684d74SAndre Oppermann }
1159a4684d74SAndre Oppermann 
1160a4684d74SAndre Oppermann 
1161ae0eb976SPoul-Henning Kamp /*
116218716f9fSMarius Strobl  * Handle a long, signed or unsigned.
116318716f9fSMarius Strobl  * Two cases:
116418716f9fSMarius Strobl  *     a variable:  point arg1 at it.
116518716f9fSMarius Strobl  *     a constant:  pass it in arg2.
1166069e9bc1SDoug Rabson  */
1167069e9bc1SDoug Rabson 
1168069e9bc1SDoug Rabson int
116982d9ae4eSPoul-Henning Kamp sysctl_handle_long(SYSCTL_HANDLER_ARGS)
1170069e9bc1SDoug Rabson {
1171069e9bc1SDoug Rabson 	int error = 0;
1172a7bc3102SPeter Wemm 	long tmplong;
1173a7bc3102SPeter Wemm #ifdef SCTL_MASK32
1174a7bc3102SPeter Wemm 	int tmpint;
1175a7bc3102SPeter Wemm #endif
1176069e9bc1SDoug Rabson 
11779e74cba3SDon Lewis 	/*
11789e74cba3SDon Lewis 	 * Attempt to get a coherent snapshot by making a copy of the data.
11799e74cba3SDon Lewis 	 */
1180bdc5f017SMarius Strobl 	if (arg1)
1181a7bc3102SPeter Wemm 		tmplong = *(long *)arg1;
1182bdc5f017SMarius Strobl 	else
1183bdc5f017SMarius Strobl 		tmplong = arg2;
1184a7bc3102SPeter Wemm #ifdef SCTL_MASK32
1185a7bc3102SPeter Wemm 	if (req->flags & SCTL_MASK32) {
1186a7bc3102SPeter Wemm 		tmpint = tmplong;
1187a7bc3102SPeter Wemm 		error = SYSCTL_OUT(req, &tmpint, sizeof(int));
1188a7bc3102SPeter Wemm 	} else
1189a7bc3102SPeter Wemm #endif
1190a7bc3102SPeter Wemm 		error = SYSCTL_OUT(req, &tmplong, sizeof(long));
1191069e9bc1SDoug Rabson 
1192069e9bc1SDoug Rabson 	if (error || !req->newptr)
1193069e9bc1SDoug Rabson 		return (error);
1194069e9bc1SDoug Rabson 
1195bdc5f017SMarius Strobl 	if (!arg1)
1196bdc5f017SMarius Strobl 		error = EPERM;
1197a7bc3102SPeter Wemm #ifdef SCTL_MASK32
1198bdc5f017SMarius Strobl 	else if (req->flags & SCTL_MASK32) {
1199a7bc3102SPeter Wemm 		error = SYSCTL_IN(req, &tmpint, sizeof(int));
1200a7bc3102SPeter Wemm 		*(long *)arg1 = (long)tmpint;
1201bdc5f017SMarius Strobl 	}
1202a7bc3102SPeter Wemm #endif
1203bdc5f017SMarius Strobl 	else
1204069e9bc1SDoug Rabson 		error = SYSCTL_IN(req, arg1, sizeof(long));
1205069e9bc1SDoug Rabson 	return (error);
1206069e9bc1SDoug Rabson }
1207069e9bc1SDoug Rabson 
1208069e9bc1SDoug Rabson /*
120918716f9fSMarius Strobl  * Handle a 64 bit int, signed or unsigned.
121018716f9fSMarius Strobl  * Two cases:
121118716f9fSMarius Strobl  *     a variable:  point arg1 at it.
121218716f9fSMarius Strobl  *     a constant:  pass it in arg2.
1213df82ff50SDavid Malone  */
1214df82ff50SDavid Malone int
1215cbc134adSMatthew D Fleming sysctl_handle_64(SYSCTL_HANDLER_ARGS)
1216df82ff50SDavid Malone {
1217df82ff50SDavid Malone 	int error = 0;
1218df82ff50SDavid Malone 	uint64_t tmpout;
1219df82ff50SDavid Malone 
1220df82ff50SDavid Malone 	/*
1221df82ff50SDavid Malone 	 * Attempt to get a coherent snapshot by making a copy of the data.
1222df82ff50SDavid Malone 	 */
1223bdc5f017SMarius Strobl 	if (arg1)
1224df82ff50SDavid Malone 		tmpout = *(uint64_t *)arg1;
1225bdc5f017SMarius Strobl 	else
1226bdc5f017SMarius Strobl 		tmpout = arg2;
1227df82ff50SDavid Malone 	error = SYSCTL_OUT(req, &tmpout, sizeof(uint64_t));
1228df82ff50SDavid Malone 
1229df82ff50SDavid Malone 	if (error || !req->newptr)
1230df82ff50SDavid Malone 		return (error);
1231df82ff50SDavid Malone 
1232bdc5f017SMarius Strobl 	if (!arg1)
1233bdc5f017SMarius Strobl 		error = EPERM;
1234bdc5f017SMarius Strobl 	else
1235df82ff50SDavid Malone 		error = SYSCTL_IN(req, arg1, sizeof(uint64_t));
1236df82ff50SDavid Malone 	return (error);
1237df82ff50SDavid Malone }
1238df82ff50SDavid Malone 
1239df82ff50SDavid Malone /*
1240ae0eb976SPoul-Henning Kamp  * Handle our generic '\0' terminated 'C' string.
1241ae0eb976SPoul-Henning Kamp  * Two cases:
1242ae0eb976SPoul-Henning Kamp  * 	a variable string:  point arg1 at it, arg2 is max length.
1243ae0eb976SPoul-Henning Kamp  * 	a constant string:  point arg1 at it, arg2 is zero.
1244ae0eb976SPoul-Henning Kamp  */
1245ae0eb976SPoul-Henning Kamp 
12463a34a5c3SPoul-Henning Kamp int
124782d9ae4eSPoul-Henning Kamp sysctl_handle_string(SYSCTL_HANDLER_ARGS)
1248b396cd83SPoul-Henning Kamp {
124937a107a4SGlen Barber 	size_t outlen;
125030d58d6bSMateusz Guzik 	int error = 0, ro_string = 0;
1251e80fb434SRobert Drehmel 
12526a3287f8SHans Petter Selasky 	/*
12536a3287f8SHans Petter Selasky 	 * A zero-length buffer indicates a fixed size read-only
12546a3287f8SHans Petter Selasky 	 * string:
12556a3287f8SHans Petter Selasky 	 */
125630d58d6bSMateusz Guzik 	if (arg2 == 0) {
12576a3287f8SHans Petter Selasky 		arg2 = strlen((char *)arg1) + 1;
125830d58d6bSMateusz Guzik 		ro_string = 1;
125930d58d6bSMateusz Guzik 	}
12603da1cf1eSHans Petter Selasky 
1261af3b2549SHans Petter Selasky 	if (req->oldptr != NULL) {
1262af3b2549SHans Petter Selasky 		char *tmparg;
126337a107a4SGlen Barber 
126430d58d6bSMateusz Guzik 		if (ro_string) {
126530d58d6bSMateusz Guzik 			tmparg = arg1;
126630d58d6bSMateusz Guzik 		} else {
1267af3b2549SHans Petter Selasky 			/* try to make a coherent snapshot of the string */
1268af3b2549SHans Petter Selasky 			tmparg = malloc(arg2, M_SYSCTLTMP, M_WAITOK);
1269af3b2549SHans Petter Selasky 			memcpy(tmparg, arg1, arg2);
127030d58d6bSMateusz Guzik 		}
1271af3b2549SHans Petter Selasky 
1272af3b2549SHans Petter Selasky 		outlen = strnlen(tmparg, arg2 - 1) + 1;
127337a107a4SGlen Barber 		error = SYSCTL_OUT(req, tmparg, outlen);
127437a107a4SGlen Barber 
127530d58d6bSMateusz Guzik 		if (!ro_string)
1276af3b2549SHans Petter Selasky 			free(tmparg, M_SYSCTLTMP);
1277af3b2549SHans Petter Selasky 	} else {
1278af3b2549SHans Petter Selasky 		outlen = strnlen((char *)arg1, arg2 - 1) + 1;
1279af3b2549SHans Petter Selasky 		error = SYSCTL_OUT(req, NULL, outlen);
1280af3b2549SHans Petter Selasky 	}
12816a5d592aSPoul-Henning Kamp 	if (error || !req->newptr)
1282ae0eb976SPoul-Henning Kamp 		return (error);
1283ae0eb976SPoul-Henning Kamp 
12846a5d592aSPoul-Henning Kamp 	if ((req->newlen - req->newidx) >= arg2) {
12856a5d592aSPoul-Henning Kamp 		error = EINVAL;
1286ae0eb976SPoul-Henning Kamp 	} else {
1287ae0eb976SPoul-Henning Kamp 		arg2 = (req->newlen - req->newidx);
1288ae0eb976SPoul-Henning Kamp 		error = SYSCTL_IN(req, arg1, arg2);
1289ae0eb976SPoul-Henning Kamp 		((char *)arg1)[arg2] = '\0';
1290b396cd83SPoul-Henning Kamp 	}
12912e210993SPoul-Henning Kamp 	return (error);
1292b396cd83SPoul-Henning Kamp }
1293b396cd83SPoul-Henning Kamp 
1294ae0eb976SPoul-Henning Kamp /*
1295ae0eb976SPoul-Henning Kamp  * Handle any kind of opaque data.
1296ae0eb976SPoul-Henning Kamp  * arg1 points to it, arg2 is the size.
1297ae0eb976SPoul-Henning Kamp  */
1298ae0eb976SPoul-Henning Kamp 
12993a34a5c3SPoul-Henning Kamp int
130082d9ae4eSPoul-Henning Kamp sysctl_handle_opaque(SYSCTL_HANDLER_ARGS)
1301b396cd83SPoul-Henning Kamp {
1302dcf59a59SBruce M Simpson 	int error, tries;
1303dcf59a59SBruce M Simpson 	u_int generation;
1304f0597024SBruce M Simpson 	struct sysctl_req req2;
1305b396cd83SPoul-Henning Kamp 
13069e74cba3SDon Lewis 	/*
1307dcf59a59SBruce M Simpson 	 * Attempt to get a coherent snapshot, by using the thread
1308dcf59a59SBruce M Simpson 	 * pre-emption counter updated from within mi_switch() to
1309dcf59a59SBruce M Simpson 	 * determine if we were pre-empted during a bcopy() or
1310dcf59a59SBruce M Simpson 	 * copyout(). Make 3 attempts at doing this before giving up.
1311dcf59a59SBruce M Simpson 	 * If we encounter an error, stop immediately.
13129e74cba3SDon Lewis 	 */
1313dcf59a59SBruce M Simpson 	tries = 0;
1314f0597024SBruce M Simpson 	req2 = *req;
1315f0597024SBruce M Simpson retry:
1316dcf59a59SBruce M Simpson 	generation = curthread->td_generation;
1317ae0eb976SPoul-Henning Kamp 	error = SYSCTL_OUT(req, arg1, arg2);
1318dcf59a59SBruce M Simpson 	if (error)
1319ae0eb976SPoul-Henning Kamp 		return (error);
1320dcf59a59SBruce M Simpson 	tries++;
1321f0597024SBruce M Simpson 	if (generation != curthread->td_generation && tries < 3) {
1322f0597024SBruce M Simpson 		*req = req2;
1323f0597024SBruce M Simpson 		goto retry;
1324f0597024SBruce M Simpson 	}
1325ae0eb976SPoul-Henning Kamp 
1326ae0eb976SPoul-Henning Kamp 	error = SYSCTL_IN(req, arg1, arg2);
1327ae0eb976SPoul-Henning Kamp 
1328ae0eb976SPoul-Henning Kamp 	return (error);
1329b396cd83SPoul-Henning Kamp }
1330ae0eb976SPoul-Henning Kamp 
1331deae269aSPoul-Henning Kamp /*
1332deae269aSPoul-Henning Kamp  * Transfer functions to/from kernel space.
1333deae269aSPoul-Henning Kamp  * XXX: rather untested at this point
1334deae269aSPoul-Henning Kamp  */
1335deae269aSPoul-Henning Kamp static int
1336069e9bc1SDoug Rabson sysctl_old_kernel(struct sysctl_req *req, const void *p, size_t l)
1337ae0eb976SPoul-Henning Kamp {
1338069e9bc1SDoug Rabson 	size_t i = 0;
1339deae269aSPoul-Henning Kamp 
1340deae269aSPoul-Henning Kamp 	if (req->oldptr) {
1341069e9bc1SDoug Rabson 		i = l;
13423a515572SThomas Moestl 		if (req->oldlen <= req->oldidx)
13433a515572SThomas Moestl 			i = 0;
13443a515572SThomas Moestl 		else
1345069e9bc1SDoug Rabson 			if (i > req->oldlen - req->oldidx)
1346069e9bc1SDoug Rabson 				i = req->oldlen - req->oldidx;
1347deae269aSPoul-Henning Kamp 		if (i > 0)
134809a8dfa2SBruce Evans 			bcopy(p, (char *)req->oldptr + req->oldidx, i);
1349ae0eb976SPoul-Henning Kamp 	}
13506b72d8dbSKonstantin Belousov 	req->oldidx += l;
13511c346c70SNate Williams 	if (req->oldptr && i != l)
1352ae0eb976SPoul-Henning Kamp 		return (ENOMEM);
13532e210993SPoul-Henning Kamp 	return (0);
1354ae0eb976SPoul-Henning Kamp }
1355ae0eb976SPoul-Henning Kamp 
1356deae269aSPoul-Henning Kamp static int
1357069e9bc1SDoug Rabson sysctl_new_kernel(struct sysctl_req *req, void *p, size_t l)
1358ae0eb976SPoul-Henning Kamp {
1359deae269aSPoul-Henning Kamp 	if (!req->newptr)
136046003fb3SPawel Jakub Dawidek 		return (0);
1361deae269aSPoul-Henning Kamp 	if (req->newlen - req->newidx < l)
1362ae0eb976SPoul-Henning Kamp 		return (EINVAL);
136309a8dfa2SBruce Evans 	bcopy((char *)req->newptr + req->newidx, p, l);
1364ae0eb976SPoul-Henning Kamp 	req->newidx += l;
1365ae0eb976SPoul-Henning Kamp 	return (0);
1366ae0eb976SPoul-Henning Kamp }
1367ae0eb976SPoul-Henning Kamp 
13681c346c70SNate Williams int
1369b40ce416SJulian Elischer kernel_sysctl(struct thread *td, int *name, u_int namelen, void *old,
1370a7bc3102SPeter Wemm     size_t *oldlenp, void *new, size_t newlen, size_t *retval, int flags)
13711c346c70SNate Williams {
13721c346c70SNate Williams 	int error = 0;
13731c346c70SNate Williams 	struct sysctl_req req;
13741c346c70SNate Williams 
13751c346c70SNate Williams 	bzero(&req, sizeof req);
13761c346c70SNate Williams 
1377ce178806SRobert Watson 	req.td = td;
1378a7bc3102SPeter Wemm 	req.flags = flags;
13791c346c70SNate Williams 
13801c346c70SNate Williams 	if (oldlenp) {
13811c346c70SNate Williams 		req.oldlen = *oldlenp;
13821c346c70SNate Williams 	}
1383a961520cSDon Lewis 	req.validlen = req.oldlen;
13841c346c70SNate Williams 
13851c346c70SNate Williams 	if (old) {
13861c346c70SNate Williams 		req.oldptr= old;
13871c346c70SNate Williams 	}
13881c346c70SNate Williams 
1389b8edb44cSDima Dorfman 	if (new != NULL) {
13901c346c70SNate Williams 		req.newlen = newlen;
13911c346c70SNate Williams 		req.newptr = new;
13921c346c70SNate Williams 	}
13931c346c70SNate Williams 
13941c346c70SNate Williams 	req.oldfunc = sysctl_old_kernel;
13951c346c70SNate Williams 	req.newfunc = sysctl_new_kernel;
139673d6f851SMatthew D Fleming 	req.lock = REQ_UNWIRED;
13971c346c70SNate Williams 
1398efe0abddSMateusz Guzik 	SYSCTL_SLOCK();
13991c346c70SNate Williams 	error = sysctl_root(0, name, namelen, &req);
1400efe0abddSMateusz Guzik 	SYSCTL_SUNLOCK();
1401f0597024SBruce M Simpson 
1402a961520cSDon Lewis 	if (req.lock == REQ_WIRED && req.validlen > 0)
1403a961520cSDon Lewis 		vsunlock(req.oldptr, req.validlen);
14041c346c70SNate Williams 
14051c346c70SNate Williams 	if (error && error != ENOMEM)
14061c346c70SNate Williams 		return (error);
14071c346c70SNate Williams 
14081c346c70SNate Williams 	if (retval) {
1409a961520cSDon Lewis 		if (req.oldptr && req.oldidx > req.validlen)
1410a961520cSDon Lewis 			*retval = req.validlen;
14111c346c70SNate Williams 		else
14121c346c70SNate Williams 			*retval = req.oldidx;
14131c346c70SNate Williams 	}
14141c346c70SNate Williams 	return (error);
14151c346c70SNate Williams }
14161c346c70SNate Williams 
14171890520aSJonathan Lemon int
1418b40ce416SJulian Elischer kernel_sysctlbyname(struct thread *td, char *name, void *old, size_t *oldlenp,
1419a7bc3102SPeter Wemm     void *new, size_t newlen, size_t *retval, int flags)
14201890520aSJonathan Lemon {
14211890520aSJonathan Lemon         int oid[CTL_MAXNAME];
14222f7f966cSMatt Jacob         size_t oidlen, plen;
14232f7f966cSMatt Jacob 	int error;
14241890520aSJonathan Lemon 
14251890520aSJonathan Lemon 	oid[0] = 0;		/* sysctl internal magic */
14261890520aSJonathan Lemon 	oid[1] = 3;		/* name2oid */
14271890520aSJonathan Lemon 	oidlen = sizeof(oid);
14281890520aSJonathan Lemon 
1429b40ce416SJulian Elischer 	error = kernel_sysctl(td, oid, 2, oid, &oidlen,
1430a7bc3102SPeter Wemm 	    (void *)name, strlen(name), &plen, flags);
14311890520aSJonathan Lemon 	if (error)
14321890520aSJonathan Lemon 		return (error);
14331890520aSJonathan Lemon 
1434b40ce416SJulian Elischer 	error = kernel_sysctl(td, oid, plen / sizeof(int), old, oldlenp,
1435a7bc3102SPeter Wemm 	    new, newlen, retval, flags);
14361890520aSJonathan Lemon 	return (error);
14371890520aSJonathan Lemon }
14381890520aSJonathan Lemon 
1439deae269aSPoul-Henning Kamp /*
1440deae269aSPoul-Henning Kamp  * Transfer function to/from user space.
1441deae269aSPoul-Henning Kamp  */
1442deae269aSPoul-Henning Kamp static int
1443069e9bc1SDoug Rabson sysctl_old_user(struct sysctl_req *req, const void *p, size_t l)
1444ae0eb976SPoul-Henning Kamp {
144547934cefSDon Lewis 	size_t i, len, origidx;
14465730afc9SAlan Cox 	int error;
1447ae0eb976SPoul-Henning Kamp 
144847934cefSDon Lewis 	origidx = req->oldidx;
144947934cefSDon Lewis 	req->oldidx += l;
14506b72d8dbSKonstantin Belousov 	if (req->oldptr == NULL)
145147934cefSDon Lewis 		return (0);
1452417ab24fSChristian S.J. Peron 	/*
1453417ab24fSChristian S.J. Peron 	 * If we have not wired the user supplied buffer and we are currently
1454417ab24fSChristian S.J. Peron 	 * holding locks, drop a witness warning, as it's possible that
1455417ab24fSChristian S.J. Peron 	 * write operations to the user page can sleep.
1456417ab24fSChristian S.J. Peron 	 */
1457417ab24fSChristian S.J. Peron 	if (req->lock != REQ_WIRED)
145826306795SJohn Baldwin 		WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
145926306795SJohn Baldwin 		    "sysctl_old_user()");
1460069e9bc1SDoug Rabson 	i = l;
1461a961520cSDon Lewis 	len = req->validlen;
146247934cefSDon Lewis 	if (len <= origidx)
14633a515572SThomas Moestl 		i = 0;
146447934cefSDon Lewis 	else {
146547934cefSDon Lewis 		if (i > len - origidx)
146647934cefSDon Lewis 			i = len - origidx;
14675730afc9SAlan Cox 		if (req->lock == REQ_WIRED) {
14685730afc9SAlan Cox 			error = copyout_nofault(p, (char *)req->oldptr +
14695730afc9SAlan Cox 			    origidx, i);
14705730afc9SAlan Cox 		} else
147147934cefSDon Lewis 			error = copyout(p, (char *)req->oldptr + origidx, i);
14725730afc9SAlan Cox 		if (error != 0)
1473ae0eb976SPoul-Henning Kamp 			return (error);
14745730afc9SAlan Cox 	}
147547934cefSDon Lewis 	if (i < l)
1476ae0eb976SPoul-Henning Kamp 		return (ENOMEM);
1477deae269aSPoul-Henning Kamp 	return (0);
1478ae0eb976SPoul-Henning Kamp }
1479ae0eb976SPoul-Henning Kamp 
1480deae269aSPoul-Henning Kamp static int
1481069e9bc1SDoug Rabson sysctl_new_user(struct sysctl_req *req, void *p, size_t l)
1482ae0eb976SPoul-Henning Kamp {
148316cd04a3SPoul-Henning Kamp 	int error;
1484deae269aSPoul-Henning Kamp 
1485deae269aSPoul-Henning Kamp 	if (!req->newptr)
148646003fb3SPawel Jakub Dawidek 		return (0);
1487deae269aSPoul-Henning Kamp 	if (req->newlen - req->newidx < l)
1488ae0eb976SPoul-Henning Kamp 		return (EINVAL);
1489d8339a26SChristian S.J. Peron 	WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
1490d8339a26SChristian S.J. Peron 	    "sysctl_new_user()");
149109a8dfa2SBruce Evans 	error = copyin((char *)req->newptr + req->newidx, p, l);
1492ae0eb976SPoul-Henning Kamp 	req->newidx += l;
1493ae0eb976SPoul-Henning Kamp 	return (error);
1494b396cd83SPoul-Henning Kamp }
1495b396cd83SPoul-Henning Kamp 
14960600730dSDon Lewis /*
14970600730dSDon Lewis  * Wire the user space destination buffer.  If set to a value greater than
14980600730dSDon Lewis  * zero, the len parameter limits the maximum amount of wired memory.
14990600730dSDon Lewis  */
150047934cefSDon Lewis int
15010600730dSDon Lewis sysctl_wire_old_buffer(struct sysctl_req *req, size_t len)
15020600730dSDon Lewis {
150347934cefSDon Lewis 	int ret;
1504433e2f47SDag-Erling Smørgrav 	size_t wiredlen;
150547934cefSDon Lewis 
150647934cefSDon Lewis 	wiredlen = (len > 0 && len < req->oldlen) ? len : req->oldlen;
150747934cefSDon Lewis 	ret = 0;
150873d6f851SMatthew D Fleming 	if (req->lock != REQ_WIRED && req->oldptr &&
15095be99846SBruce M Simpson 	    req->oldfunc == sysctl_old_user) {
15108ac3e8e9SDon Lewis 		if (wiredlen != 0) {
1511ce8660e3SDon Lewis 			ret = vslock(req->oldptr, wiredlen);
1512b4adfcf2SBrian Feldman 			if (ret != 0) {
1513b4adfcf2SBrian Feldman 				if (ret != ENOMEM)
15148ac3e8e9SDon Lewis 					return (ret);
1515b4adfcf2SBrian Feldman 				wiredlen = 0;
1516b4adfcf2SBrian Feldman 			}
15178ac3e8e9SDon Lewis 		}
15185be99846SBruce M Simpson 		req->lock = REQ_WIRED;
1519a961520cSDon Lewis 		req->validlen = wiredlen;
15200600730dSDon Lewis 	}
15218ac3e8e9SDon Lewis 	return (0);
152247934cefSDon Lewis }
15230600730dSDon Lewis 
15242e210993SPoul-Henning Kamp int
1525226420a4SBrian Feldman sysctl_find_oid(int *name, u_int namelen, struct sysctl_oid **noid,
1526226420a4SBrian Feldman     int *nindx, struct sysctl_req *req)
15272e210993SPoul-Henning Kamp {
1528d0bb6f25SMatthew D Fleming 	struct sysctl_oid_list *lsp;
1529ce02431fSDoug Rabson 	struct sysctl_oid *oid;
1530226420a4SBrian Feldman 	int indx;
15312e210993SPoul-Henning Kamp 
1532efe0abddSMateusz Guzik 	SYSCTL_ASSERT_LOCKED();
1533d0bb6f25SMatthew D Fleming 	lsp = &sysctl__children;
15342e210993SPoul-Henning Kamp 	indx = 0;
1535d0bb6f25SMatthew D Fleming 	while (indx < CTL_MAXNAME) {
1536d0bb6f25SMatthew D Fleming 		SLIST_FOREACH(oid, lsp, oid_link) {
1537d0bb6f25SMatthew D Fleming 			if (oid->oid_number == name[indx])
1538d0bb6f25SMatthew D Fleming 				break;
1539d0bb6f25SMatthew D Fleming 		}
1540d0bb6f25SMatthew D Fleming 		if (oid == NULL)
1541d0bb6f25SMatthew D Fleming 			return (ENOENT);
1542d0bb6f25SMatthew D Fleming 
15432e210993SPoul-Henning Kamp 		indx++;
1544ce02431fSDoug Rabson 		if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
1545d0bb6f25SMatthew D Fleming 			if (oid->oid_handler != NULL || indx == namelen) {
1546226420a4SBrian Feldman 				*noid = oid;
1547226420a4SBrian Feldman 				if (nindx != NULL)
1548226420a4SBrian Feldman 					*nindx = indx;
1549ccecef29SMatthew D Fleming 				KASSERT((oid->oid_kind & CTLFLAG_DYING) == 0,
1550ccecef29SMatthew D Fleming 				    ("%s found DYING node %p", __func__, oid));
1551226420a4SBrian Feldman 				return (0);
1552226420a4SBrian Feldman 			}
1553d0bb6f25SMatthew D Fleming 			lsp = SYSCTL_CHILDREN(oid);
1554226420a4SBrian Feldman 		} else if (indx == namelen) {
1555226420a4SBrian Feldman 			*noid = oid;
1556226420a4SBrian Feldman 			if (nindx != NULL)
1557226420a4SBrian Feldman 				*nindx = indx;
1558ccecef29SMatthew D Fleming 			KASSERT((oid->oid_kind & CTLFLAG_DYING) == 0,
1559ccecef29SMatthew D Fleming 			    ("%s found DYING node %p", __func__, oid));
1560226420a4SBrian Feldman 			return (0);
15612e210993SPoul-Henning Kamp 		} else {
1562226420a4SBrian Feldman 			return (ENOTDIR);
15632e210993SPoul-Henning Kamp 		}
15642e210993SPoul-Henning Kamp 	}
1565226420a4SBrian Feldman 	return (ENOENT);
1566226420a4SBrian Feldman }
1567226420a4SBrian Feldman 
1568226420a4SBrian Feldman /*
1569226420a4SBrian Feldman  * Traverse our tree, and find the right node, execute whatever it points
1570226420a4SBrian Feldman  * to, and return the resulting error code.
1571226420a4SBrian Feldman  */
1572226420a4SBrian Feldman 
157337c84183SPoul-Henning Kamp static int
157482d9ae4eSPoul-Henning Kamp sysctl_root(SYSCTL_HANDLER_ARGS)
1575226420a4SBrian Feldman {
1576226420a4SBrian Feldman 	struct sysctl_oid *oid;
1577fe41ca53SMatthew Dillon 	int error, indx, lvl;
1578226420a4SBrian Feldman 
1579f84f8f94SMateusz Guzik 	SYSCTL_ASSERT_SLOCKED();
1580ddf9d243SEd Schouten 
1581226420a4SBrian Feldman 	error = sysctl_find_oid(arg1, arg2, &oid, &indx, req);
1582226420a4SBrian Feldman 	if (error)
1583226420a4SBrian Feldman 		return (error);
1584226420a4SBrian Feldman 
1585226420a4SBrian Feldman 	if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
1586226420a4SBrian Feldman 		/*
1587226420a4SBrian Feldman 		 * You can't call a sysctl when it's a node, but has
1588226420a4SBrian Feldman 		 * no handler.  Inform the user that it's a node.
1589226420a4SBrian Feldman 		 * The indx may or may not be the same as namelen.
1590226420a4SBrian Feldman 		 */
1591226420a4SBrian Feldman 		if (oid->oid_handler == NULL)
1592226420a4SBrian Feldman 			return (EISDIR);
1593226420a4SBrian Feldman 	}
1594226420a4SBrian Feldman 
1595c2f413afSRobert Watson 	/* Is this sysctl writable? */
1596c2f413afSRobert Watson 	if (req->newptr && !(oid->oid_kind & CTLFLAG_WR))
15972e210993SPoul-Henning Kamp 		return (EPERM);
15982e210993SPoul-Henning Kamp 
15997906271fSRobert Watson 	KASSERT(req->td != NULL, ("sysctl_root(): req->td == NULL"));
16007906271fSRobert Watson 
1601ff66f6a4SRobert Watson #ifdef CAPABILITY_MODE
1602ff66f6a4SRobert Watson 	/*
1603ff66f6a4SRobert Watson 	 * If the process is in capability mode, then don't permit reading or
1604ff66f6a4SRobert Watson 	 * writing unless specifically granted for the node.
1605ff66f6a4SRobert Watson 	 */
1606ff66f6a4SRobert Watson 	if (IN_CAPABILITY_MODE(req->td)) {
1607ff66f6a4SRobert Watson 		if (req->oldptr && !(oid->oid_kind & CTLFLAG_CAPRD))
1608ff66f6a4SRobert Watson 			return (EPERM);
1609ff66f6a4SRobert Watson 		if (req->newptr && !(oid->oid_kind & CTLFLAG_CAPWR))
1610ff66f6a4SRobert Watson 			return (EPERM);
1611ff66f6a4SRobert Watson 	}
1612ff66f6a4SRobert Watson #endif
1613ff66f6a4SRobert Watson 
1614c2f413afSRobert Watson 	/* Is this sysctl sensitive to securelevels? */
1615c2f413afSRobert Watson 	if (req->newptr && (oid->oid_kind & CTLFLAG_SECURE)) {
1616fe41ca53SMatthew Dillon 		lvl = (oid->oid_kind & CTLMASK_SECURE) >> CTLSHIFT_SECURE;
1617fe41ca53SMatthew Dillon 		error = securelevel_gt(req->td->td_ucred, lvl);
1618c2f413afSRobert Watson 		if (error)
1619c2f413afSRobert Watson 			return (error);
1620c2f413afSRobert Watson 	}
1621c2f413afSRobert Watson 
1622c2f413afSRobert Watson 	/* Is this sysctl writable by only privileged users? */
1623c2f413afSRobert Watson 	if (req->newptr && !(oid->oid_kind & CTLFLAG_ANYBODY)) {
1624eb79e1c7SBjoern A. Zeeb 		int priv;
1625eb79e1c7SBjoern A. Zeeb 
1626c2f413afSRobert Watson 		if (oid->oid_kind & CTLFLAG_PRISON)
1627eb79e1c7SBjoern A. Zeeb 			priv = PRIV_SYSCTL_WRITEJAIL;
1628eb79e1c7SBjoern A. Zeeb #ifdef VIMAGE
1629eb79e1c7SBjoern A. Zeeb 		else if ((oid->oid_kind & CTLFLAG_VNET) &&
1630eb79e1c7SBjoern A. Zeeb 		     prison_owns_vnet(req->td->td_ucred))
1631eb79e1c7SBjoern A. Zeeb 			priv = PRIV_SYSCTL_WRITEJAIL;
1632eb79e1c7SBjoern A. Zeeb #endif
1633c2f413afSRobert Watson 		else
1634eb79e1c7SBjoern A. Zeeb 			priv = PRIV_SYSCTL_WRITE;
1635eb79e1c7SBjoern A. Zeeb 		error = priv_check(req->td, priv);
1636c2f413afSRobert Watson 		if (error)
1637c2f413afSRobert Watson 			return (error);
1638c2f413afSRobert Watson 	}
16393ac9f819SPoul-Henning Kamp 
1640ce02431fSDoug Rabson 	if (!oid->oid_handler)
164146003fb3SPawel Jakub Dawidek 		return (EINVAL);
16422e210993SPoul-Henning Kamp 
164363dba32bSPawel Jakub Dawidek 	if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
164400fbcda8SAlexander Kabaev 		arg1 = (int *)arg1 + indx;
164563dba32bSPawel Jakub Dawidek 		arg2 -= indx;
164663dba32bSPawel Jakub Dawidek 	} else {
164763dba32bSPawel Jakub Dawidek 		arg1 = oid->oid_arg1;
164863dba32bSPawel Jakub Dawidek 		arg2 = oid->oid_arg2;
164963dba32bSPawel Jakub Dawidek 	}
165063dba32bSPawel Jakub Dawidek #ifdef MAC
165130d239bcSRobert Watson 	error = mac_system_check_sysctl(req->td->td_ucred, oid, arg1, arg2,
1652ae0eb976SPoul-Henning Kamp 	    req);
165363dba32bSPawel Jakub Dawidek 	if (error != 0)
165463dba32bSPawel Jakub Dawidek 		return (error);
165563dba32bSPawel Jakub Dawidek #endif
1656b5c32cf4SGleb Smirnoff #ifdef VIMAGE
1657b5c32cf4SGleb Smirnoff 	if ((oid->oid_kind & CTLFLAG_VNET) && arg1 != NULL)
1658b5c32cf4SGleb Smirnoff 		arg1 = (void *)(curvnet->vnet_data_base + (uintptr_t)arg1);
1659b5c32cf4SGleb Smirnoff #endif
1660af3b2549SHans Petter Selasky 	error = sysctl_root_handler_locked(oid, arg1, arg2, req);
166163dba32bSPawel Jakub Dawidek 
1662ccecef29SMatthew D Fleming 	KFAIL_POINT_ERROR(_debug_fail_point, sysctl_running, error);
1663ccecef29SMatthew D Fleming 
1664226420a4SBrian Feldman 	return (error);
16652e210993SPoul-Henning Kamp }
16662e210993SPoul-Henning Kamp 
1667d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_
1668b8da2396SPoul-Henning Kamp struct sysctl_args {
1669b8da2396SPoul-Henning Kamp 	int	*name;
1670b8da2396SPoul-Henning Kamp 	u_int	namelen;
1671b8da2396SPoul-Henning Kamp 	void	*old;
1672b8da2396SPoul-Henning Kamp 	size_t	*oldlenp;
1673b8da2396SPoul-Henning Kamp 	void	*new;
1674b8da2396SPoul-Henning Kamp 	size_t	newlen;
1675b8da2396SPoul-Henning Kamp };
1676d2d3e875SBruce Evans #endif
1677df8bae1dSRodney W. Grimes int
16788451d0ddSKip Macy sys___sysctl(struct thread *td, struct sysctl_args *uap)
1679df8bae1dSRodney W. Grimes {
1680875b66a0SJohn Baldwin 	int error, i, name[CTL_MAXNAME];
1681069e9bc1SDoug Rabson 	size_t j;
1682b396cd83SPoul-Henning Kamp 
1683df8bae1dSRodney W. Grimes 	if (uap->namelen > CTL_MAXNAME || uap->namelen < 2)
1684df8bae1dSRodney W. Grimes 		return (EINVAL);
1685b396cd83SPoul-Henning Kamp 
1686797f2d22SPoul-Henning Kamp  	error = copyin(uap->name, &name, uap->namelen * sizeof(int));
1687797f2d22SPoul-Henning Kamp  	if (error)
1688df8bae1dSRodney W. Grimes 		return (error);
1689df8bae1dSRodney W. Grimes 
1690b40ce416SJulian Elischer 	error = userland_sysctl(td, name, uap->namelen,
1691b8da2396SPoul-Henning Kamp 		uap->old, uap->oldlenp, 0,
1692a7bc3102SPeter Wemm 		uap->new, uap->newlen, &j, 0);
1693deae269aSPoul-Henning Kamp 	if (error && error != ENOMEM)
1694ddf9d243SEd Schouten 		return (error);
16954cfe4790SEd Schouten 	if (uap->oldlenp) {
1696875b66a0SJohn Baldwin 		i = copyout(&j, uap->oldlenp, sizeof(j));
16974cfe4790SEd Schouten 		if (i)
16984cfe4790SEd Schouten 			return (i);
16994cfe4790SEd Schouten 	}
1700deae269aSPoul-Henning Kamp 	return (error);
1701b8da2396SPoul-Henning Kamp }
1702b8da2396SPoul-Henning Kamp 
1703b8da2396SPoul-Henning Kamp /*
1704b8da2396SPoul-Henning Kamp  * This is used from various compatibility syscalls too.  That's why name
1705b8da2396SPoul-Henning Kamp  * must be in kernel space.
1706b8da2396SPoul-Henning Kamp  */
1707b8da2396SPoul-Henning Kamp int
1708b40ce416SJulian Elischer userland_sysctl(struct thread *td, int *name, u_int namelen, void *old,
1709a7bc3102SPeter Wemm     size_t *oldlenp, int inkernel, void *new, size_t newlen, size_t *retval,
1710a7bc3102SPeter Wemm     int flags)
1711b8da2396SPoul-Henning Kamp {
17123e829b18SJohn Baldwin 	int error = 0, memlocked;
1713a961520cSDon Lewis 	struct sysctl_req req;
1714ae0eb976SPoul-Henning Kamp 
1715ae0eb976SPoul-Henning Kamp 	bzero(&req, sizeof req);
1716b8da2396SPoul-Henning Kamp 
1717ce178806SRobert Watson 	req.td = td;
1718a7bc3102SPeter Wemm 	req.flags = flags;
171916cd04a3SPoul-Henning Kamp 
1720b8da2396SPoul-Henning Kamp 	if (oldlenp) {
1721b8da2396SPoul-Henning Kamp 		if (inkernel) {
1722ae0eb976SPoul-Henning Kamp 			req.oldlen = *oldlenp;
1723b8da2396SPoul-Henning Kamp 		} else {
1724deae269aSPoul-Henning Kamp 			error = copyin(oldlenp, &req.oldlen, sizeof(*oldlenp));
1725b8da2396SPoul-Henning Kamp 			if (error)
1726b8da2396SPoul-Henning Kamp 				return (error);
1727b8da2396SPoul-Henning Kamp 		}
1728b8da2396SPoul-Henning Kamp 	}
1729a961520cSDon Lewis 	req.validlen = req.oldlen;
1730b8da2396SPoul-Henning Kamp 
1731ae0eb976SPoul-Henning Kamp 	if (old) {
173202c58685SPoul-Henning Kamp 		if (!useracc(old, req.oldlen, VM_PROT_WRITE))
1733ae0eb976SPoul-Henning Kamp 			return (EFAULT);
1734ae0eb976SPoul-Henning Kamp 		req.oldptr= old;
1735ae0eb976SPoul-Henning Kamp 	}
17362e210993SPoul-Henning Kamp 
1737b8edb44cSDima Dorfman 	if (new != NULL) {
173870ffc2fbSRobert Watson 		if (!useracc(new, newlen, VM_PROT_READ))
1739ae0eb976SPoul-Henning Kamp 			return (EFAULT);
1740ae0eb976SPoul-Henning Kamp 		req.newlen = newlen;
1741ae0eb976SPoul-Henning Kamp 		req.newptr = new;
1742b396cd83SPoul-Henning Kamp 	}
1743b396cd83SPoul-Henning Kamp 
1744ae0eb976SPoul-Henning Kamp 	req.oldfunc = sysctl_old_user;
1745ae0eb976SPoul-Henning Kamp 	req.newfunc = sysctl_new_user;
174673d6f851SMatthew D Fleming 	req.lock = REQ_UNWIRED;
17474b2af45fSPoul-Henning Kamp 
1748a56be37eSJohn Baldwin #ifdef KTRACE
1749a56be37eSJohn Baldwin 	if (KTRPOINT(curthread, KTR_SYSCTL))
1750a56be37eSJohn Baldwin 		ktrsysctl(name, namelen);
1751a56be37eSJohn Baldwin #endif
1752a56be37eSJohn Baldwin 
17533e829b18SJohn Baldwin 	if (req.oldlen > PAGE_SIZE) {
17543e829b18SJohn Baldwin 		memlocked = 1;
17553e829b18SJohn Baldwin 		sx_xlock(&sysctlmemlock);
17563e829b18SJohn Baldwin 	} else
17573e829b18SJohn Baldwin 		memlocked = 0;
17589ed47d01SJamie Gritton 	CURVNET_SET(TD_TO_VNET(td));
1759ae0eb976SPoul-Henning Kamp 
1760af80b2c9SKonstantin Belousov 	for (;;) {
1761a961520cSDon Lewis 		req.oldidx = 0;
1762a961520cSDon Lewis 		req.newidx = 0;
1763efe0abddSMateusz Guzik 		SYSCTL_SLOCK();
1764a961520cSDon Lewis 		error = sysctl_root(0, name, namelen, &req);
1765efe0abddSMateusz Guzik 		SYSCTL_SUNLOCK();
1766af80b2c9SKonstantin Belousov 		if (error != EAGAIN)
1767af80b2c9SKonstantin Belousov 			break;
17683d08a76bSMatthew D Fleming 		kern_yield(PRI_USER);
1769af80b2c9SKonstantin Belousov 	}
1770b396cd83SPoul-Henning Kamp 
177197021c24SMarko Zec 	CURVNET_RESTORE();
17724b2af45fSPoul-Henning Kamp 
1773ddf9d243SEd Schouten 	if (req.lock == REQ_WIRED && req.validlen > 0)
1774ddf9d243SEd Schouten 		vsunlock(req.oldptr, req.validlen);
17753e829b18SJohn Baldwin 	if (memlocked)
17763e829b18SJohn Baldwin 		sx_xunlock(&sysctlmemlock);
1777ddf9d243SEd Schouten 
1778deae269aSPoul-Henning Kamp 	if (error && error != ENOMEM)
1779deae269aSPoul-Henning Kamp 		return (error);
1780deae269aSPoul-Henning Kamp 
1781deae269aSPoul-Henning Kamp 	if (retval) {
1782a961520cSDon Lewis 		if (req.oldptr && req.oldidx > req.validlen)
1783a961520cSDon Lewis 			*retval = req.validlen;
1784deae269aSPoul-Henning Kamp 		else
1785deae269aSPoul-Henning Kamp 			*retval = req.oldidx;
1786b8da2396SPoul-Henning Kamp 	}
17872e210993SPoul-Henning Kamp 	return (error);
1788df8bae1dSRodney W. Grimes }
17894e657159SMatthew D Fleming 
17904e657159SMatthew D Fleming /*
179100f0e671SMatthew D Fleming  * Drain into a sysctl struct.  The user buffer should be wired if a page
179200f0e671SMatthew D Fleming  * fault would cause issue.
17934e657159SMatthew D Fleming  */
17944e657159SMatthew D Fleming static int
17954e657159SMatthew D Fleming sbuf_sysctl_drain(void *arg, const char *data, int len)
17964e657159SMatthew D Fleming {
17974e657159SMatthew D Fleming 	struct sysctl_req *req = arg;
17984e657159SMatthew D Fleming 	int error;
17994e657159SMatthew D Fleming 
18004e657159SMatthew D Fleming 	error = SYSCTL_OUT(req, data, len);
18014e657159SMatthew D Fleming 	KASSERT(error >= 0, ("Got unexpected negative value %d", error));
18024e657159SMatthew D Fleming 	return (error == 0 ? len : -error);
18034e657159SMatthew D Fleming }
18044e657159SMatthew D Fleming 
18054e657159SMatthew D Fleming struct sbuf *
18064e657159SMatthew D Fleming sbuf_new_for_sysctl(struct sbuf *s, char *buf, int length,
18074e657159SMatthew D Fleming     struct sysctl_req *req)
18084e657159SMatthew D Fleming {
18094e657159SMatthew D Fleming 
18104e657159SMatthew D Fleming 	s = sbuf_new(s, buf, length, SBUF_FIXEDLEN);
18114e657159SMatthew D Fleming 	sbuf_set_drain(s, sbuf_sysctl_drain, req);
18124e657159SMatthew D Fleming 	return (s);
18134e657159SMatthew D Fleming }
1814