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