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