1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1982, 1986, 1989, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This code is derived from software contributed to Berkeley by 8 * Mike Karels at Berkeley Software Design, Inc. 9 * 10 * Quite extensively rewritten by Poul-Henning Kamp of the FreeBSD 11 * project, to make these variables more userfriendly. 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 3. Neither the name of the University nor the names of its contributors 22 * may be used to endorse or promote products derived from this software 23 * without specific prior written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 28 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 35 * SUCH DAMAGE. 36 * 37 * @(#)kern_sysctl.c 8.4 (Berkeley) 4/14/94 38 */ 39 40 #include <sys/cdefs.h> 41 __FBSDID("$FreeBSD$"); 42 43 #include "opt_capsicum.h" 44 #include "opt_ddb.h" 45 #include "opt_ktrace.h" 46 47 #include <sys/param.h> 48 #include <sys/fail.h> 49 #include <sys/systm.h> 50 #include <sys/capsicum.h> 51 #include <sys/kernel.h> 52 #include <sys/limits.h> 53 #include <sys/sysctl.h> 54 #include <sys/malloc.h> 55 #include <sys/priv.h> 56 #include <sys/proc.h> 57 #include <sys/jail.h> 58 #include <sys/kdb.h> 59 #include <sys/lock.h> 60 #include <sys/mutex.h> 61 #include <sys/rmlock.h> 62 #include <sys/sbuf.h> 63 #include <sys/sx.h> 64 #include <sys/sysproto.h> 65 #include <sys/uio.h> 66 #ifdef KTRACE 67 #include <sys/ktrace.h> 68 #endif 69 70 #ifdef DDB 71 #include <ddb/ddb.h> 72 #include <ddb/db_lex.h> 73 #endif 74 75 #include <net/vnet.h> 76 77 #include <security/mac/mac_framework.h> 78 79 #include <vm/vm.h> 80 #include <vm/vm_extern.h> 81 82 static MALLOC_DEFINE(M_SYSCTL, "sysctl", "sysctl internal magic"); 83 static MALLOC_DEFINE(M_SYSCTLOID, "sysctloid", "sysctl dynamic oids"); 84 static MALLOC_DEFINE(M_SYSCTLTMP, "sysctltmp", "sysctl temp output buffer"); 85 86 /* 87 * The sysctllock protects the MIB tree. It also protects sysctl 88 * contexts used with dynamic sysctls. The sysctl_register_oid() and 89 * sysctl_unregister_oid() routines require the sysctllock to already 90 * be held, so the sysctl_wlock() and sysctl_wunlock() routines are 91 * provided for the few places in the kernel which need to use that 92 * API rather than using the dynamic API. Use of the dynamic API is 93 * strongly encouraged for most code. 94 * 95 * The sysctlmemlock is used to limit the amount of user memory wired for 96 * sysctl requests. This is implemented by serializing any userland 97 * sysctl requests larger than a single page via an exclusive lock. 98 */ 99 static struct rmlock sysctllock; 100 static struct sx __exclusive_cache_line sysctlmemlock; 101 102 #define SYSCTL_WLOCK() rm_wlock(&sysctllock) 103 #define SYSCTL_WUNLOCK() rm_wunlock(&sysctllock) 104 #define SYSCTL_RLOCK(tracker) rm_rlock(&sysctllock, (tracker)) 105 #define SYSCTL_RUNLOCK(tracker) rm_runlock(&sysctllock, (tracker)) 106 #define SYSCTL_WLOCKED() rm_wowned(&sysctllock) 107 #define SYSCTL_ASSERT_LOCKED() rm_assert(&sysctllock, RA_LOCKED) 108 #define SYSCTL_ASSERT_WLOCKED() rm_assert(&sysctllock, RA_WLOCKED) 109 #define SYSCTL_ASSERT_RLOCKED() rm_assert(&sysctllock, RA_RLOCKED) 110 #define SYSCTL_INIT() rm_init_flags(&sysctllock, "sysctl lock", \ 111 RM_SLEEPABLE) 112 #define SYSCTL_SLEEP(ch, wmesg, timo) \ 113 rm_sleep(ch, &sysctllock, 0, wmesg, timo) 114 115 static int sysctl_root(SYSCTL_HANDLER_ARGS); 116 117 /* Root list */ 118 struct sysctl_oid_list sysctl__children = SLIST_HEAD_INITIALIZER(&sysctl__children); 119 120 static int sysctl_remove_oid_locked(struct sysctl_oid *oidp, int del, 121 int recurse); 122 static int sysctl_old_kernel(struct sysctl_req *, const void *, size_t); 123 static int sysctl_new_kernel(struct sysctl_req *, void *, size_t); 124 125 static struct sysctl_oid * 126 sysctl_find_oidname(const char *name, struct sysctl_oid_list *list) 127 { 128 struct sysctl_oid *oidp; 129 130 SYSCTL_ASSERT_LOCKED(); 131 SLIST_FOREACH(oidp, list, oid_link) { 132 if (strcmp(oidp->oid_name, name) == 0) { 133 return (oidp); 134 } 135 } 136 return (NULL); 137 } 138 139 /* 140 * Initialization of the MIB tree. 141 * 142 * Order by number in each list. 143 */ 144 void 145 sysctl_wlock(void) 146 { 147 148 SYSCTL_WLOCK(); 149 } 150 151 void 152 sysctl_wunlock(void) 153 { 154 155 SYSCTL_WUNLOCK(); 156 } 157 158 static int 159 sysctl_root_handler_locked(struct sysctl_oid *oid, void *arg1, intmax_t arg2, 160 struct sysctl_req *req, struct rm_priotracker *tracker) 161 { 162 int error; 163 164 if (oid->oid_kind & CTLFLAG_DYN) 165 atomic_add_int(&oid->oid_running, 1); 166 167 if (tracker != NULL) 168 SYSCTL_RUNLOCK(tracker); 169 else 170 SYSCTL_WUNLOCK(); 171 172 if (!(oid->oid_kind & CTLFLAG_MPSAFE)) 173 mtx_lock(&Giant); 174 error = oid->oid_handler(oid, arg1, arg2, req); 175 if (!(oid->oid_kind & CTLFLAG_MPSAFE)) 176 mtx_unlock(&Giant); 177 178 KFAIL_POINT_ERROR(_debug_fail_point, sysctl_running, error); 179 180 if (tracker != NULL) 181 SYSCTL_RLOCK(tracker); 182 else 183 SYSCTL_WLOCK(); 184 185 if (oid->oid_kind & CTLFLAG_DYN) { 186 if (atomic_fetchadd_int(&oid->oid_running, -1) == 1 && 187 (oid->oid_kind & CTLFLAG_DYING) != 0) 188 wakeup(&oid->oid_running); 189 } 190 191 return (error); 192 } 193 194 static void 195 sysctl_load_tunable_by_oid_locked(struct sysctl_oid *oidp) 196 { 197 struct sysctl_req req; 198 struct sysctl_oid *curr; 199 char *penv = NULL; 200 char path[96]; 201 ssize_t rem = sizeof(path); 202 ssize_t len; 203 uint8_t data[512] __aligned(sizeof(uint64_t)); 204 int size; 205 int error; 206 207 path[--rem] = 0; 208 209 for (curr = oidp; curr != NULL; curr = SYSCTL_PARENT(curr)) { 210 len = strlen(curr->oid_name); 211 rem -= len; 212 if (curr != oidp) 213 rem -= 1; 214 if (rem < 0) { 215 printf("OID path exceeds %d bytes\n", (int)sizeof(path)); 216 return; 217 } 218 memcpy(path + rem, curr->oid_name, len); 219 if (curr != oidp) 220 path[rem + len] = '.'; 221 } 222 223 memset(&req, 0, sizeof(req)); 224 225 req.td = curthread; 226 req.oldfunc = sysctl_old_kernel; 227 req.newfunc = sysctl_new_kernel; 228 req.lock = REQ_UNWIRED; 229 230 switch (oidp->oid_kind & CTLTYPE) { 231 case CTLTYPE_INT: 232 if (getenv_array(path + rem, data, sizeof(data), &size, 233 sizeof(int), GETENV_SIGNED) == 0) 234 return; 235 req.newlen = size; 236 req.newptr = data; 237 break; 238 case CTLTYPE_UINT: 239 if (getenv_array(path + rem, data, sizeof(data), &size, 240 sizeof(int), GETENV_UNSIGNED) == 0) 241 return; 242 req.newlen = size; 243 req.newptr = data; 244 break; 245 case CTLTYPE_LONG: 246 if (getenv_array(path + rem, data, sizeof(data), &size, 247 sizeof(long), GETENV_SIGNED) == 0) 248 return; 249 req.newlen = size; 250 req.newptr = data; 251 break; 252 case CTLTYPE_ULONG: 253 if (getenv_array(path + rem, data, sizeof(data), &size, 254 sizeof(long), GETENV_UNSIGNED) == 0) 255 return; 256 req.newlen = size; 257 req.newptr = data; 258 break; 259 case CTLTYPE_S8: 260 if (getenv_array(path + rem, data, sizeof(data), &size, 261 sizeof(int8_t), GETENV_SIGNED) == 0) 262 return; 263 req.newlen = size; 264 req.newptr = data; 265 break; 266 case CTLTYPE_S16: 267 if (getenv_array(path + rem, data, sizeof(data), &size, 268 sizeof(int16_t), GETENV_SIGNED) == 0) 269 return; 270 req.newlen = size; 271 req.newptr = data; 272 break; 273 case CTLTYPE_S32: 274 if (getenv_array(path + rem, data, sizeof(data), &size, 275 sizeof(int32_t), GETENV_SIGNED) == 0) 276 return; 277 req.newlen = size; 278 req.newptr = data; 279 break; 280 case CTLTYPE_S64: 281 if (getenv_array(path + rem, data, sizeof(data), &size, 282 sizeof(int64_t), GETENV_SIGNED) == 0) 283 return; 284 req.newlen = size; 285 req.newptr = data; 286 break; 287 case CTLTYPE_U8: 288 if (getenv_array(path + rem, data, sizeof(data), &size, 289 sizeof(uint8_t), GETENV_UNSIGNED) == 0) 290 return; 291 req.newlen = size; 292 req.newptr = data; 293 break; 294 case CTLTYPE_U16: 295 if (getenv_array(path + rem, data, sizeof(data), &size, 296 sizeof(uint16_t), GETENV_UNSIGNED) == 0) 297 return; 298 req.newlen = size; 299 req.newptr = data; 300 break; 301 case CTLTYPE_U32: 302 if (getenv_array(path + rem, data, sizeof(data), &size, 303 sizeof(uint32_t), GETENV_UNSIGNED) == 0) 304 return; 305 req.newlen = size; 306 req.newptr = data; 307 break; 308 case CTLTYPE_U64: 309 if (getenv_array(path + rem, data, sizeof(data), &size, 310 sizeof(uint64_t), GETENV_UNSIGNED) == 0) 311 return; 312 req.newlen = size; 313 req.newptr = data; 314 break; 315 case CTLTYPE_STRING: 316 penv = kern_getenv(path + rem); 317 if (penv == NULL) 318 return; 319 req.newlen = strlen(penv); 320 req.newptr = penv; 321 break; 322 default: 323 return; 324 } 325 error = sysctl_root_handler_locked(oidp, oidp->oid_arg1, 326 oidp->oid_arg2, &req, NULL); 327 if (error != 0) 328 printf("Setting sysctl %s failed: %d\n", path + rem, error); 329 if (penv != NULL) 330 freeenv(penv); 331 } 332 333 /* 334 * Locate the path to a given oid. Returns the length of the resulting path, 335 * or -1 if the oid was not found. nodes must have room for CTL_MAXNAME 336 * elements and be NULL initialized. 337 */ 338 static int 339 sysctl_search_oid(struct sysctl_oid **nodes, struct sysctl_oid *needle) 340 { 341 int indx; 342 343 SYSCTL_ASSERT_LOCKED(); 344 indx = 0; 345 while (indx < CTL_MAXNAME && indx >= 0) { 346 if (nodes[indx] == NULL && indx == 0) 347 nodes[indx] = SLIST_FIRST(&sysctl__children); 348 else if (nodes[indx] == NULL) 349 nodes[indx] = SLIST_FIRST(&nodes[indx - 1]->oid_children); 350 else 351 nodes[indx] = SLIST_NEXT(nodes[indx], oid_link); 352 353 if (nodes[indx] == needle) 354 return (indx + 1); 355 356 if (nodes[indx] == NULL) { 357 indx--; 358 continue; 359 } 360 361 if ((nodes[indx]->oid_kind & CTLTYPE) == CTLTYPE_NODE) { 362 indx++; 363 continue; 364 } 365 } 366 return (-1); 367 } 368 369 static void 370 sysctl_warn_reuse(const char *func, struct sysctl_oid *leaf) 371 { 372 struct sysctl_oid *nodes[CTL_MAXNAME]; 373 char buf[128]; 374 struct sbuf sb; 375 int rc, i; 376 377 (void)sbuf_new(&sb, buf, sizeof(buf), SBUF_FIXEDLEN | SBUF_INCLUDENUL); 378 sbuf_set_drain(&sb, sbuf_printf_drain, NULL); 379 380 sbuf_printf(&sb, "%s: can't re-use a leaf (", __func__); 381 382 memset(nodes, 0, sizeof(nodes)); 383 rc = sysctl_search_oid(nodes, leaf); 384 if (rc > 0) { 385 for (i = 0; i < rc; i++) 386 sbuf_printf(&sb, "%s%.*s", nodes[i]->oid_name, 387 i != (rc - 1), "."); 388 } else { 389 sbuf_printf(&sb, "%s", leaf->oid_name); 390 } 391 sbuf_printf(&sb, ")!\n"); 392 393 (void)sbuf_finish(&sb); 394 } 395 396 #ifdef SYSCTL_DEBUG 397 static int 398 sysctl_reuse_test(SYSCTL_HANDLER_ARGS) 399 { 400 struct rm_priotracker tracker; 401 402 SYSCTL_RLOCK(&tracker); 403 sysctl_warn_reuse(__func__, oidp); 404 SYSCTL_RUNLOCK(&tracker); 405 return (0); 406 } 407 SYSCTL_PROC(_sysctl, 0, reuse_test, CTLTYPE_STRING|CTLFLAG_RD|CTLFLAG_MPSAFE, 408 0, 0, sysctl_reuse_test, "-", ""); 409 #endif 410 411 void 412 sysctl_register_oid(struct sysctl_oid *oidp) 413 { 414 struct sysctl_oid_list *parent = oidp->oid_parent; 415 struct sysctl_oid *p; 416 struct sysctl_oid *q; 417 int oid_number; 418 int timeout = 2; 419 420 /* 421 * First check if another oid with the same name already 422 * exists in the parent's list. 423 */ 424 SYSCTL_ASSERT_WLOCKED(); 425 p = sysctl_find_oidname(oidp->oid_name, parent); 426 if (p != NULL) { 427 if ((p->oid_kind & CTLTYPE) == CTLTYPE_NODE) { 428 p->oid_refcnt++; 429 return; 430 } else { 431 sysctl_warn_reuse(__func__, p); 432 return; 433 } 434 } 435 /* get current OID number */ 436 oid_number = oidp->oid_number; 437 438 #if (OID_AUTO >= 0) 439 #error "OID_AUTO is expected to be a negative value" 440 #endif 441 /* 442 * Any negative OID number qualifies as OID_AUTO. Valid OID 443 * numbers should always be positive. 444 * 445 * NOTE: DO NOT change the starting value here, change it in 446 * <sys/sysctl.h>, and make sure it is at least 256 to 447 * accommodate e.g. net.inet.raw as a static sysctl node. 448 */ 449 if (oid_number < 0) { 450 static int newoid; 451 452 /* 453 * By decrementing the next OID number we spend less 454 * time inserting the OIDs into a sorted list. 455 */ 456 if (--newoid < CTL_AUTO_START) 457 newoid = 0x7fffffff; 458 459 oid_number = newoid; 460 } 461 462 /* 463 * Insert the OID into the parent's list sorted by OID number. 464 */ 465 retry: 466 q = NULL; 467 SLIST_FOREACH(p, parent, oid_link) { 468 /* check if the current OID number is in use */ 469 if (oid_number == p->oid_number) { 470 /* get the next valid OID number */ 471 if (oid_number < CTL_AUTO_START || 472 oid_number == 0x7fffffff) { 473 /* wraparound - restart */ 474 oid_number = CTL_AUTO_START; 475 /* don't loop forever */ 476 if (!timeout--) 477 panic("sysctl: Out of OID numbers\n"); 478 goto retry; 479 } else { 480 oid_number++; 481 } 482 } else if (oid_number < p->oid_number) 483 break; 484 q = p; 485 } 486 /* check for non-auto OID number collision */ 487 if (oidp->oid_number >= 0 && oidp->oid_number < CTL_AUTO_START && 488 oid_number >= CTL_AUTO_START) { 489 printf("sysctl: OID number(%d) is already in use for '%s'\n", 490 oidp->oid_number, oidp->oid_name); 491 } 492 /* update the OID number, if any */ 493 oidp->oid_number = oid_number; 494 if (q != NULL) 495 SLIST_INSERT_AFTER(q, oidp, oid_link); 496 else 497 SLIST_INSERT_HEAD(parent, oidp, oid_link); 498 499 if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE && 500 #ifdef VIMAGE 501 (oidp->oid_kind & CTLFLAG_VNET) == 0 && 502 #endif 503 (oidp->oid_kind & CTLFLAG_TUN) != 0 && 504 (oidp->oid_kind & CTLFLAG_NOFETCH) == 0) { 505 /* only fetch value once */ 506 oidp->oid_kind |= CTLFLAG_NOFETCH; 507 /* try to fetch value from kernel environment */ 508 sysctl_load_tunable_by_oid_locked(oidp); 509 } 510 } 511 512 void 513 sysctl_register_disabled_oid(struct sysctl_oid *oidp) 514 { 515 516 /* 517 * Mark the leaf as dormant if it's not to be immediately enabled. 518 * We do not disable nodes as they can be shared between modules 519 * and it is always safe to access a node. 520 */ 521 KASSERT((oidp->oid_kind & CTLFLAG_DORMANT) == 0, 522 ("internal flag is set in oid_kind")); 523 if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE) 524 oidp->oid_kind |= CTLFLAG_DORMANT; 525 sysctl_register_oid(oidp); 526 } 527 528 void 529 sysctl_enable_oid(struct sysctl_oid *oidp) 530 { 531 532 SYSCTL_ASSERT_WLOCKED(); 533 if ((oidp->oid_kind & CTLTYPE) == CTLTYPE_NODE) { 534 KASSERT((oidp->oid_kind & CTLFLAG_DORMANT) == 0, 535 ("sysctl node is marked as dormant")); 536 return; 537 } 538 KASSERT((oidp->oid_kind & CTLFLAG_DORMANT) != 0, 539 ("enabling already enabled sysctl oid")); 540 oidp->oid_kind &= ~CTLFLAG_DORMANT; 541 } 542 543 void 544 sysctl_unregister_oid(struct sysctl_oid *oidp) 545 { 546 struct sysctl_oid *p; 547 int error; 548 549 SYSCTL_ASSERT_WLOCKED(); 550 if (oidp->oid_number == OID_AUTO) { 551 error = EINVAL; 552 } else { 553 error = ENOENT; 554 SLIST_FOREACH(p, oidp->oid_parent, oid_link) { 555 if (p == oidp) { 556 SLIST_REMOVE(oidp->oid_parent, oidp, 557 sysctl_oid, oid_link); 558 error = 0; 559 break; 560 } 561 } 562 } 563 564 /* 565 * This can happen when a module fails to register and is 566 * being unloaded afterwards. It should not be a panic() 567 * for normal use. 568 */ 569 if (error) { 570 printf("%s: failed(%d) to unregister sysctl(%s)\n", 571 __func__, error, oidp->oid_name); 572 } 573 } 574 575 /* Initialize a new context to keep track of dynamically added sysctls. */ 576 int 577 sysctl_ctx_init(struct sysctl_ctx_list *c) 578 { 579 580 if (c == NULL) { 581 return (EINVAL); 582 } 583 584 /* 585 * No locking here, the caller is responsible for not adding 586 * new nodes to a context until after this function has 587 * returned. 588 */ 589 TAILQ_INIT(c); 590 return (0); 591 } 592 593 /* Free the context, and destroy all dynamic oids registered in this context */ 594 int 595 sysctl_ctx_free(struct sysctl_ctx_list *clist) 596 { 597 struct sysctl_ctx_entry *e, *e1; 598 int error; 599 600 error = 0; 601 /* 602 * First perform a "dry run" to check if it's ok to remove oids. 603 * XXX FIXME 604 * XXX This algorithm is a hack. But I don't know any 605 * XXX better solution for now... 606 */ 607 SYSCTL_WLOCK(); 608 TAILQ_FOREACH(e, clist, link) { 609 error = sysctl_remove_oid_locked(e->entry, 0, 0); 610 if (error) 611 break; 612 } 613 /* 614 * Restore deregistered entries, either from the end, 615 * or from the place where error occurred. 616 * e contains the entry that was not unregistered 617 */ 618 if (error) 619 e1 = TAILQ_PREV(e, sysctl_ctx_list, link); 620 else 621 e1 = TAILQ_LAST(clist, sysctl_ctx_list); 622 while (e1 != NULL) { 623 sysctl_register_oid(e1->entry); 624 e1 = TAILQ_PREV(e1, sysctl_ctx_list, link); 625 } 626 if (error) { 627 SYSCTL_WUNLOCK(); 628 return(EBUSY); 629 } 630 /* Now really delete the entries */ 631 e = TAILQ_FIRST(clist); 632 while (e != NULL) { 633 e1 = TAILQ_NEXT(e, link); 634 error = sysctl_remove_oid_locked(e->entry, 1, 0); 635 if (error) 636 panic("sysctl_remove_oid: corrupt tree, entry: %s", 637 e->entry->oid_name); 638 free(e, M_SYSCTLOID); 639 e = e1; 640 } 641 SYSCTL_WUNLOCK(); 642 return (error); 643 } 644 645 /* Add an entry to the context */ 646 struct sysctl_ctx_entry * 647 sysctl_ctx_entry_add(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp) 648 { 649 struct sysctl_ctx_entry *e; 650 651 SYSCTL_ASSERT_WLOCKED(); 652 if (clist == NULL || oidp == NULL) 653 return(NULL); 654 e = malloc(sizeof(struct sysctl_ctx_entry), M_SYSCTLOID, M_WAITOK); 655 e->entry = oidp; 656 TAILQ_INSERT_HEAD(clist, e, link); 657 return (e); 658 } 659 660 /* Find an entry in the context */ 661 struct sysctl_ctx_entry * 662 sysctl_ctx_entry_find(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp) 663 { 664 struct sysctl_ctx_entry *e; 665 666 SYSCTL_ASSERT_WLOCKED(); 667 if (clist == NULL || oidp == NULL) 668 return(NULL); 669 TAILQ_FOREACH(e, clist, link) { 670 if(e->entry == oidp) 671 return(e); 672 } 673 return (e); 674 } 675 676 /* 677 * Delete an entry from the context. 678 * NOTE: this function doesn't free oidp! You have to remove it 679 * with sysctl_remove_oid(). 680 */ 681 int 682 sysctl_ctx_entry_del(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp) 683 { 684 struct sysctl_ctx_entry *e; 685 686 if (clist == NULL || oidp == NULL) 687 return (EINVAL); 688 SYSCTL_WLOCK(); 689 e = sysctl_ctx_entry_find(clist, oidp); 690 if (e != NULL) { 691 TAILQ_REMOVE(clist, e, link); 692 SYSCTL_WUNLOCK(); 693 free(e, M_SYSCTLOID); 694 return (0); 695 } else { 696 SYSCTL_WUNLOCK(); 697 return (ENOENT); 698 } 699 } 700 701 /* 702 * Remove dynamically created sysctl trees. 703 * oidp - top of the tree to be removed 704 * del - if 0 - just deregister, otherwise free up entries as well 705 * recurse - if != 0 traverse the subtree to be deleted 706 */ 707 int 708 sysctl_remove_oid(struct sysctl_oid *oidp, int del, int recurse) 709 { 710 int error; 711 712 SYSCTL_WLOCK(); 713 error = sysctl_remove_oid_locked(oidp, del, recurse); 714 SYSCTL_WUNLOCK(); 715 return (error); 716 } 717 718 int 719 sysctl_remove_name(struct sysctl_oid *parent, const char *name, 720 int del, int recurse) 721 { 722 struct sysctl_oid *p, *tmp; 723 int error; 724 725 error = ENOENT; 726 SYSCTL_WLOCK(); 727 SLIST_FOREACH_SAFE(p, SYSCTL_CHILDREN(parent), oid_link, tmp) { 728 if (strcmp(p->oid_name, name) == 0) { 729 error = sysctl_remove_oid_locked(p, del, recurse); 730 break; 731 } 732 } 733 SYSCTL_WUNLOCK(); 734 735 return (error); 736 } 737 738 739 static int 740 sysctl_remove_oid_locked(struct sysctl_oid *oidp, int del, int recurse) 741 { 742 struct sysctl_oid *p, *tmp; 743 int error; 744 745 SYSCTL_ASSERT_WLOCKED(); 746 if (oidp == NULL) 747 return(EINVAL); 748 if ((oidp->oid_kind & CTLFLAG_DYN) == 0) { 749 printf("Warning: can't remove non-dynamic nodes (%s)!\n", 750 oidp->oid_name); 751 return (EINVAL); 752 } 753 /* 754 * WARNING: normal method to do this should be through 755 * sysctl_ctx_free(). Use recursing as the last resort 756 * method to purge your sysctl tree of leftovers... 757 * However, if some other code still references these nodes, 758 * it will panic. 759 */ 760 if ((oidp->oid_kind & CTLTYPE) == CTLTYPE_NODE) { 761 if (oidp->oid_refcnt == 1) { 762 SLIST_FOREACH_SAFE(p, 763 SYSCTL_CHILDREN(oidp), oid_link, tmp) { 764 if (!recurse) { 765 printf("Warning: failed attempt to " 766 "remove oid %s with child %s\n", 767 oidp->oid_name, p->oid_name); 768 return (ENOTEMPTY); 769 } 770 error = sysctl_remove_oid_locked(p, del, 771 recurse); 772 if (error) 773 return (error); 774 } 775 } 776 } 777 if (oidp->oid_refcnt > 1 ) { 778 oidp->oid_refcnt--; 779 } else { 780 if (oidp->oid_refcnt == 0) { 781 printf("Warning: bad oid_refcnt=%u (%s)!\n", 782 oidp->oid_refcnt, oidp->oid_name); 783 return (EINVAL); 784 } 785 sysctl_unregister_oid(oidp); 786 if (del) { 787 /* 788 * Wait for all threads running the handler to drain. 789 * This preserves the previous behavior when the 790 * sysctl lock was held across a handler invocation, 791 * and is necessary for module unload correctness. 792 */ 793 while (oidp->oid_running > 0) { 794 oidp->oid_kind |= CTLFLAG_DYING; 795 SYSCTL_SLEEP(&oidp->oid_running, "oidrm", 0); 796 } 797 if (oidp->oid_descr) 798 free(__DECONST(char *, oidp->oid_descr), 799 M_SYSCTLOID); 800 if (oidp->oid_label) 801 free(__DECONST(char *, oidp->oid_label), 802 M_SYSCTLOID); 803 free(__DECONST(char *, oidp->oid_name), M_SYSCTLOID); 804 free(oidp, M_SYSCTLOID); 805 } 806 } 807 return (0); 808 } 809 /* 810 * Create new sysctls at run time. 811 * clist may point to a valid context initialized with sysctl_ctx_init(). 812 */ 813 struct sysctl_oid * 814 sysctl_add_oid(struct sysctl_ctx_list *clist, struct sysctl_oid_list *parent, 815 int number, const char *name, int kind, void *arg1, intmax_t arg2, 816 int (*handler)(SYSCTL_HANDLER_ARGS), const char *fmt, const char *descr, 817 const char *label) 818 { 819 struct sysctl_oid *oidp; 820 821 /* You have to hook up somewhere.. */ 822 if (parent == NULL) 823 return(NULL); 824 /* Check if the node already exists, otherwise create it */ 825 SYSCTL_WLOCK(); 826 oidp = sysctl_find_oidname(name, parent); 827 if (oidp != NULL) { 828 if ((oidp->oid_kind & CTLTYPE) == CTLTYPE_NODE) { 829 oidp->oid_refcnt++; 830 /* Update the context */ 831 if (clist != NULL) 832 sysctl_ctx_entry_add(clist, oidp); 833 SYSCTL_WUNLOCK(); 834 return (oidp); 835 } else { 836 sysctl_warn_reuse(__func__, oidp); 837 SYSCTL_WUNLOCK(); 838 return (NULL); 839 } 840 } 841 oidp = malloc(sizeof(struct sysctl_oid), M_SYSCTLOID, M_WAITOK|M_ZERO); 842 oidp->oid_parent = parent; 843 SLIST_INIT(&oidp->oid_children); 844 oidp->oid_number = number; 845 oidp->oid_refcnt = 1; 846 oidp->oid_name = strdup(name, M_SYSCTLOID); 847 oidp->oid_handler = handler; 848 oidp->oid_kind = CTLFLAG_DYN | kind; 849 oidp->oid_arg1 = arg1; 850 oidp->oid_arg2 = arg2; 851 oidp->oid_fmt = fmt; 852 if (descr != NULL) 853 oidp->oid_descr = strdup(descr, M_SYSCTLOID); 854 if (label != NULL) 855 oidp->oid_label = strdup(label, M_SYSCTLOID); 856 /* Update the context, if used */ 857 if (clist != NULL) 858 sysctl_ctx_entry_add(clist, oidp); 859 /* Register this oid */ 860 sysctl_register_oid(oidp); 861 SYSCTL_WUNLOCK(); 862 return (oidp); 863 } 864 865 /* 866 * Rename an existing oid. 867 */ 868 void 869 sysctl_rename_oid(struct sysctl_oid *oidp, const char *name) 870 { 871 char *newname; 872 char *oldname; 873 874 newname = strdup(name, M_SYSCTLOID); 875 SYSCTL_WLOCK(); 876 oldname = __DECONST(char *, oidp->oid_name); 877 oidp->oid_name = newname; 878 SYSCTL_WUNLOCK(); 879 free(oldname, M_SYSCTLOID); 880 } 881 882 /* 883 * Reparent an existing oid. 884 */ 885 int 886 sysctl_move_oid(struct sysctl_oid *oid, struct sysctl_oid_list *parent) 887 { 888 struct sysctl_oid *oidp; 889 890 SYSCTL_WLOCK(); 891 if (oid->oid_parent == parent) { 892 SYSCTL_WUNLOCK(); 893 return (0); 894 } 895 oidp = sysctl_find_oidname(oid->oid_name, parent); 896 if (oidp != NULL) { 897 SYSCTL_WUNLOCK(); 898 return (EEXIST); 899 } 900 sysctl_unregister_oid(oid); 901 oid->oid_parent = parent; 902 oid->oid_number = OID_AUTO; 903 sysctl_register_oid(oid); 904 SYSCTL_WUNLOCK(); 905 return (0); 906 } 907 908 /* 909 * Register the kernel's oids on startup. 910 */ 911 SET_DECLARE(sysctl_set, struct sysctl_oid); 912 913 static void 914 sysctl_register_all(void *arg) 915 { 916 struct sysctl_oid **oidp; 917 918 sx_init(&sysctlmemlock, "sysctl mem"); 919 SYSCTL_INIT(); 920 SYSCTL_WLOCK(); 921 SET_FOREACH(oidp, sysctl_set) 922 sysctl_register_oid(*oidp); 923 SYSCTL_WUNLOCK(); 924 } 925 SYSINIT(sysctl, SI_SUB_KMEM, SI_ORDER_FIRST, sysctl_register_all, NULL); 926 927 /* 928 * "Staff-functions" 929 * 930 * These functions implement a presently undocumented interface 931 * used by the sysctl program to walk the tree, and get the type 932 * so it can print the value. 933 * This interface is under work and consideration, and should probably 934 * be killed with a big axe by the first person who can find the time. 935 * (be aware though, that the proper interface isn't as obvious as it 936 * may seem, there are various conflicting requirements. 937 * 938 * {CTL_SYSCTL, CTL_SYSCTL_DEBUG} printf the entire MIB-tree. 939 * {CTL_SYSCTL, CTL_SYSCTL_NAME, ...} return the name of the "..." 940 * OID. 941 * {CTL_SYSCTL, CTL_SYSCTL_NEXT, ...} return the next OID. 942 * {CTL_SYSCTL, CTL_SYSCTL_NAME2OID} return the OID of the name in 943 * "new" 944 * {CTL_SYSCTL, CTL_SYSCTL_OIDFMT, ...} return the kind & format info 945 * for the "..." OID. 946 * {CTL_SYSCTL, CTL_SYSCTL_OIDDESCR, ...} return the description of the 947 * "..." OID. 948 * {CTL_SYSCTL, CTL_SYSCTL_OIDLABEL, ...} return the aggregation label of 949 * the "..." OID. 950 */ 951 952 #ifdef SYSCTL_DEBUG 953 static void 954 sysctl_sysctl_debug_dump_node(struct sysctl_oid_list *l, int i) 955 { 956 int k; 957 struct sysctl_oid *oidp; 958 959 SYSCTL_ASSERT_LOCKED(); 960 SLIST_FOREACH(oidp, l, oid_link) { 961 962 for (k=0; k<i; k++) 963 printf(" "); 964 965 printf("%d %s ", oidp->oid_number, oidp->oid_name); 966 967 printf("%c%c", 968 oidp->oid_kind & CTLFLAG_RD ? 'R':' ', 969 oidp->oid_kind & CTLFLAG_WR ? 'W':' '); 970 971 if (oidp->oid_handler) 972 printf(" *Handler"); 973 974 switch (oidp->oid_kind & CTLTYPE) { 975 case CTLTYPE_NODE: 976 printf(" Node\n"); 977 if (!oidp->oid_handler) { 978 sysctl_sysctl_debug_dump_node( 979 SYSCTL_CHILDREN(oidp), i + 2); 980 } 981 break; 982 case CTLTYPE_INT: printf(" Int\n"); break; 983 case CTLTYPE_UINT: printf(" u_int\n"); break; 984 case CTLTYPE_LONG: printf(" Long\n"); break; 985 case CTLTYPE_ULONG: printf(" u_long\n"); break; 986 case CTLTYPE_STRING: printf(" String\n"); break; 987 case CTLTYPE_S8: printf(" int8_t\n"); break; 988 case CTLTYPE_S16: printf(" int16_t\n"); break; 989 case CTLTYPE_S32: printf(" int32_t\n"); break; 990 case CTLTYPE_S64: printf(" int64_t\n"); break; 991 case CTLTYPE_U8: printf(" uint8_t\n"); break; 992 case CTLTYPE_U16: printf(" uint16_t\n"); break; 993 case CTLTYPE_U32: printf(" uint32_t\n"); break; 994 case CTLTYPE_U64: printf(" uint64_t\n"); break; 995 case CTLTYPE_OPAQUE: printf(" Opaque/struct\n"); break; 996 default: printf("\n"); 997 } 998 999 } 1000 } 1001 1002 static int 1003 sysctl_sysctl_debug(SYSCTL_HANDLER_ARGS) 1004 { 1005 struct rm_priotracker tracker; 1006 int error; 1007 1008 error = priv_check(req->td, PRIV_SYSCTL_DEBUG); 1009 if (error) 1010 return (error); 1011 SYSCTL_RLOCK(&tracker); 1012 sysctl_sysctl_debug_dump_node(&sysctl__children, 0); 1013 SYSCTL_RUNLOCK(&tracker); 1014 return (ENOENT); 1015 } 1016 1017 SYSCTL_PROC(_sysctl, CTL_SYSCTL_DEBUG, debug, CTLTYPE_STRING | CTLFLAG_RD | 1018 CTLFLAG_MPSAFE, 0, 0, sysctl_sysctl_debug, "-", ""); 1019 #endif 1020 1021 static int 1022 sysctl_sysctl_name(SYSCTL_HANDLER_ARGS) 1023 { 1024 int *name = (int *) arg1; 1025 u_int namelen = arg2; 1026 int error; 1027 struct sysctl_oid *oid; 1028 struct sysctl_oid_list *lsp = &sysctl__children, *lsp2; 1029 struct rm_priotracker tracker; 1030 char buf[10]; 1031 1032 error = sysctl_wire_old_buffer(req, 0); 1033 if (error) 1034 return (error); 1035 1036 SYSCTL_RLOCK(&tracker); 1037 while (namelen) { 1038 if (!lsp) { 1039 snprintf(buf,sizeof(buf),"%d",*name); 1040 if (req->oldidx) 1041 error = SYSCTL_OUT(req, ".", 1); 1042 if (!error) 1043 error = SYSCTL_OUT(req, buf, strlen(buf)); 1044 if (error) 1045 goto out; 1046 namelen--; 1047 name++; 1048 continue; 1049 } 1050 lsp2 = NULL; 1051 SLIST_FOREACH(oid, lsp, oid_link) { 1052 if (oid->oid_number != *name) 1053 continue; 1054 1055 if (req->oldidx) 1056 error = SYSCTL_OUT(req, ".", 1); 1057 if (!error) 1058 error = SYSCTL_OUT(req, oid->oid_name, 1059 strlen(oid->oid_name)); 1060 if (error) 1061 goto out; 1062 1063 namelen--; 1064 name++; 1065 1066 if ((oid->oid_kind & CTLTYPE) != CTLTYPE_NODE) 1067 break; 1068 1069 if (oid->oid_handler) 1070 break; 1071 1072 lsp2 = SYSCTL_CHILDREN(oid); 1073 break; 1074 } 1075 lsp = lsp2; 1076 } 1077 error = SYSCTL_OUT(req, "", 1); 1078 out: 1079 SYSCTL_RUNLOCK(&tracker); 1080 return (error); 1081 } 1082 1083 /* 1084 * XXXRW/JA: Shouldn't return name data for nodes that we don't permit in 1085 * capability mode. 1086 */ 1087 static SYSCTL_NODE(_sysctl, CTL_SYSCTL_NAME, name, CTLFLAG_RD | 1088 CTLFLAG_MPSAFE | CTLFLAG_CAPRD, sysctl_sysctl_name, ""); 1089 1090 static int 1091 sysctl_sysctl_next_ls(struct sysctl_oid_list *lsp, int *name, u_int namelen, 1092 int *next, int *len, int level, struct sysctl_oid **oidpp) 1093 { 1094 struct sysctl_oid *oidp; 1095 1096 SYSCTL_ASSERT_LOCKED(); 1097 *len = level; 1098 SLIST_FOREACH(oidp, lsp, oid_link) { 1099 *next = oidp->oid_number; 1100 *oidpp = oidp; 1101 1102 if ((oidp->oid_kind & (CTLFLAG_SKIP | CTLFLAG_DORMANT)) != 0) 1103 continue; 1104 1105 if (!namelen) { 1106 if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE) 1107 return (0); 1108 if (oidp->oid_handler) 1109 /* We really should call the handler here...*/ 1110 return (0); 1111 lsp = SYSCTL_CHILDREN(oidp); 1112 if (!sysctl_sysctl_next_ls(lsp, 0, 0, next+1, 1113 len, level+1, oidpp)) 1114 return (0); 1115 goto emptynode; 1116 } 1117 1118 if (oidp->oid_number < *name) 1119 continue; 1120 1121 if (oidp->oid_number > *name) { 1122 if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE) 1123 return (0); 1124 if (oidp->oid_handler) 1125 return (0); 1126 lsp = SYSCTL_CHILDREN(oidp); 1127 if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1, 1128 next+1, len, level+1, oidpp)) 1129 return (0); 1130 goto next; 1131 } 1132 if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE) 1133 continue; 1134 1135 if (oidp->oid_handler) 1136 continue; 1137 1138 lsp = SYSCTL_CHILDREN(oidp); 1139 if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1, next+1, 1140 len, level+1, oidpp)) 1141 return (0); 1142 next: 1143 namelen = 1; 1144 emptynode: 1145 *len = level; 1146 } 1147 return (1); 1148 } 1149 1150 static int 1151 sysctl_sysctl_next(SYSCTL_HANDLER_ARGS) 1152 { 1153 int *name = (int *) arg1; 1154 u_int namelen = arg2; 1155 int i, j, error; 1156 struct sysctl_oid *oid; 1157 struct sysctl_oid_list *lsp = &sysctl__children; 1158 struct rm_priotracker tracker; 1159 int newoid[CTL_MAXNAME]; 1160 1161 SYSCTL_RLOCK(&tracker); 1162 i = sysctl_sysctl_next_ls(lsp, name, namelen, newoid, &j, 1, &oid); 1163 SYSCTL_RUNLOCK(&tracker); 1164 if (i) 1165 return (ENOENT); 1166 error = SYSCTL_OUT(req, newoid, j * sizeof (int)); 1167 return (error); 1168 } 1169 1170 /* 1171 * XXXRW/JA: Shouldn't return next data for nodes that we don't permit in 1172 * capability mode. 1173 */ 1174 static SYSCTL_NODE(_sysctl, CTL_SYSCTL_NEXT, next, CTLFLAG_RD | 1175 CTLFLAG_MPSAFE | CTLFLAG_CAPRD, sysctl_sysctl_next, ""); 1176 1177 static int 1178 name2oid(char *name, int *oid, int *len, struct sysctl_oid **oidpp) 1179 { 1180 struct sysctl_oid *oidp; 1181 struct sysctl_oid_list *lsp = &sysctl__children; 1182 char *p; 1183 1184 SYSCTL_ASSERT_LOCKED(); 1185 1186 for (*len = 0; *len < CTL_MAXNAME;) { 1187 p = strsep(&name, "."); 1188 1189 oidp = SLIST_FIRST(lsp); 1190 for (;; oidp = SLIST_NEXT(oidp, oid_link)) { 1191 if (oidp == NULL) 1192 return (ENOENT); 1193 if (strcmp(p, oidp->oid_name) == 0) 1194 break; 1195 } 1196 *oid++ = oidp->oid_number; 1197 (*len)++; 1198 1199 if (name == NULL || *name == '\0') { 1200 if (oidpp) 1201 *oidpp = oidp; 1202 return (0); 1203 } 1204 1205 if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE) 1206 break; 1207 1208 if (oidp->oid_handler) 1209 break; 1210 1211 lsp = SYSCTL_CHILDREN(oidp); 1212 } 1213 return (ENOENT); 1214 } 1215 1216 static int 1217 sysctl_sysctl_name2oid(SYSCTL_HANDLER_ARGS) 1218 { 1219 char *p; 1220 int error, oid[CTL_MAXNAME], len = 0; 1221 struct sysctl_oid *op = NULL; 1222 struct rm_priotracker tracker; 1223 char buf[32]; 1224 1225 if (!req->newlen) 1226 return (ENOENT); 1227 if (req->newlen >= MAXPATHLEN) /* XXX arbitrary, undocumented */ 1228 return (ENAMETOOLONG); 1229 1230 p = buf; 1231 if (req->newlen >= sizeof(buf)) 1232 p = malloc(req->newlen+1, M_SYSCTL, M_WAITOK); 1233 1234 error = SYSCTL_IN(req, p, req->newlen); 1235 if (error) { 1236 if (p != buf) 1237 free(p, M_SYSCTL); 1238 return (error); 1239 } 1240 1241 p [req->newlen] = '\0'; 1242 1243 SYSCTL_RLOCK(&tracker); 1244 error = name2oid(p, oid, &len, &op); 1245 SYSCTL_RUNLOCK(&tracker); 1246 1247 if (p != buf) 1248 free(p, M_SYSCTL); 1249 1250 if (error) 1251 return (error); 1252 1253 error = SYSCTL_OUT(req, oid, len * sizeof *oid); 1254 return (error); 1255 } 1256 1257 /* 1258 * XXXRW/JA: Shouldn't return name2oid data for nodes that we don't permit in 1259 * capability mode. 1260 */ 1261 SYSCTL_PROC(_sysctl, CTL_SYSCTL_NAME2OID, name2oid, CTLTYPE_INT | CTLFLAG_RW | 1262 CTLFLAG_ANYBODY | CTLFLAG_MPSAFE | CTLFLAG_CAPRW, 0, 0, 1263 sysctl_sysctl_name2oid, "I", ""); 1264 1265 static int 1266 sysctl_sysctl_oidfmt(SYSCTL_HANDLER_ARGS) 1267 { 1268 struct sysctl_oid *oid; 1269 struct rm_priotracker tracker; 1270 int error; 1271 1272 error = sysctl_wire_old_buffer(req, 0); 1273 if (error) 1274 return (error); 1275 1276 SYSCTL_RLOCK(&tracker); 1277 error = sysctl_find_oid(arg1, arg2, &oid, NULL, req); 1278 if (error) 1279 goto out; 1280 1281 if (oid->oid_fmt == NULL) { 1282 error = ENOENT; 1283 goto out; 1284 } 1285 error = SYSCTL_OUT(req, &oid->oid_kind, sizeof(oid->oid_kind)); 1286 if (error) 1287 goto out; 1288 error = SYSCTL_OUT(req, oid->oid_fmt, strlen(oid->oid_fmt) + 1); 1289 out: 1290 SYSCTL_RUNLOCK(&tracker); 1291 return (error); 1292 } 1293 1294 1295 static SYSCTL_NODE(_sysctl, CTL_SYSCTL_OIDFMT, oidfmt, CTLFLAG_RD | 1296 CTLFLAG_MPSAFE | CTLFLAG_CAPRD, sysctl_sysctl_oidfmt, ""); 1297 1298 static int 1299 sysctl_sysctl_oiddescr(SYSCTL_HANDLER_ARGS) 1300 { 1301 struct sysctl_oid *oid; 1302 struct rm_priotracker tracker; 1303 int error; 1304 1305 error = sysctl_wire_old_buffer(req, 0); 1306 if (error) 1307 return (error); 1308 1309 SYSCTL_RLOCK(&tracker); 1310 error = sysctl_find_oid(arg1, arg2, &oid, NULL, req); 1311 if (error) 1312 goto out; 1313 1314 if (oid->oid_descr == NULL) { 1315 error = ENOENT; 1316 goto out; 1317 } 1318 error = SYSCTL_OUT(req, oid->oid_descr, strlen(oid->oid_descr) + 1); 1319 out: 1320 SYSCTL_RUNLOCK(&tracker); 1321 return (error); 1322 } 1323 1324 static SYSCTL_NODE(_sysctl, CTL_SYSCTL_OIDDESCR, oiddescr, CTLFLAG_RD | 1325 CTLFLAG_MPSAFE|CTLFLAG_CAPRD, sysctl_sysctl_oiddescr, ""); 1326 1327 static int 1328 sysctl_sysctl_oidlabel(SYSCTL_HANDLER_ARGS) 1329 { 1330 struct sysctl_oid *oid; 1331 struct rm_priotracker tracker; 1332 int error; 1333 1334 error = sysctl_wire_old_buffer(req, 0); 1335 if (error) 1336 return (error); 1337 1338 SYSCTL_RLOCK(&tracker); 1339 error = sysctl_find_oid(arg1, arg2, &oid, NULL, req); 1340 if (error) 1341 goto out; 1342 1343 if (oid->oid_label == NULL) { 1344 error = ENOENT; 1345 goto out; 1346 } 1347 error = SYSCTL_OUT(req, oid->oid_label, strlen(oid->oid_label) + 1); 1348 out: 1349 SYSCTL_RUNLOCK(&tracker); 1350 return (error); 1351 } 1352 1353 static SYSCTL_NODE(_sysctl, CTL_SYSCTL_OIDLABEL, oidlabel, CTLFLAG_RD | 1354 CTLFLAG_MPSAFE | CTLFLAG_CAPRD, sysctl_sysctl_oidlabel, ""); 1355 1356 /* 1357 * Default "handler" functions. 1358 */ 1359 1360 /* 1361 * Handle a bool. 1362 * Two cases: 1363 * a variable: point arg1 at it. 1364 * a constant: pass it in arg2. 1365 */ 1366 1367 int 1368 sysctl_handle_bool(SYSCTL_HANDLER_ARGS) 1369 { 1370 uint8_t temp; 1371 int error; 1372 1373 /* 1374 * Attempt to get a coherent snapshot by making a copy of the data. 1375 */ 1376 if (arg1) 1377 temp = *(bool *)arg1 ? 1 : 0; 1378 else 1379 temp = arg2 ? 1 : 0; 1380 1381 error = SYSCTL_OUT(req, &temp, sizeof(temp)); 1382 if (error || !req->newptr) 1383 return (error); 1384 1385 if (!arg1) 1386 error = EPERM; 1387 else { 1388 error = SYSCTL_IN(req, &temp, sizeof(temp)); 1389 if (!error) 1390 *(bool *)arg1 = temp ? 1 : 0; 1391 } 1392 return (error); 1393 } 1394 1395 /* 1396 * Handle an int8_t, signed or unsigned. 1397 * Two cases: 1398 * a variable: point arg1 at it. 1399 * a constant: pass it in arg2. 1400 */ 1401 1402 int 1403 sysctl_handle_8(SYSCTL_HANDLER_ARGS) 1404 { 1405 int8_t tmpout; 1406 int error = 0; 1407 1408 /* 1409 * Attempt to get a coherent snapshot by making a copy of the data. 1410 */ 1411 if (arg1) 1412 tmpout = *(int8_t *)arg1; 1413 else 1414 tmpout = arg2; 1415 error = SYSCTL_OUT(req, &tmpout, sizeof(tmpout)); 1416 1417 if (error || !req->newptr) 1418 return (error); 1419 1420 if (!arg1) 1421 error = EPERM; 1422 else 1423 error = SYSCTL_IN(req, arg1, sizeof(tmpout)); 1424 return (error); 1425 } 1426 1427 /* 1428 * Handle an int16_t, signed or unsigned. 1429 * Two cases: 1430 * a variable: point arg1 at it. 1431 * a constant: pass it in arg2. 1432 */ 1433 1434 int 1435 sysctl_handle_16(SYSCTL_HANDLER_ARGS) 1436 { 1437 int16_t tmpout; 1438 int error = 0; 1439 1440 /* 1441 * Attempt to get a coherent snapshot by making a copy of the data. 1442 */ 1443 if (arg1) 1444 tmpout = *(int16_t *)arg1; 1445 else 1446 tmpout = arg2; 1447 error = SYSCTL_OUT(req, &tmpout, sizeof(tmpout)); 1448 1449 if (error || !req->newptr) 1450 return (error); 1451 1452 if (!arg1) 1453 error = EPERM; 1454 else 1455 error = SYSCTL_IN(req, arg1, sizeof(tmpout)); 1456 return (error); 1457 } 1458 1459 /* 1460 * Handle an int32_t, signed or unsigned. 1461 * Two cases: 1462 * a variable: point arg1 at it. 1463 * a constant: pass it in arg2. 1464 */ 1465 1466 int 1467 sysctl_handle_32(SYSCTL_HANDLER_ARGS) 1468 { 1469 int32_t tmpout; 1470 int error = 0; 1471 1472 /* 1473 * Attempt to get a coherent snapshot by making a copy of the data. 1474 */ 1475 if (arg1) 1476 tmpout = *(int32_t *)arg1; 1477 else 1478 tmpout = arg2; 1479 error = SYSCTL_OUT(req, &tmpout, sizeof(tmpout)); 1480 1481 if (error || !req->newptr) 1482 return (error); 1483 1484 if (!arg1) 1485 error = EPERM; 1486 else 1487 error = SYSCTL_IN(req, arg1, sizeof(tmpout)); 1488 return (error); 1489 } 1490 1491 /* 1492 * Handle an int, signed or unsigned. 1493 * Two cases: 1494 * a variable: point arg1 at it. 1495 * a constant: pass it in arg2. 1496 */ 1497 1498 int 1499 sysctl_handle_int(SYSCTL_HANDLER_ARGS) 1500 { 1501 int tmpout, error = 0; 1502 1503 /* 1504 * Attempt to get a coherent snapshot by making a copy of the data. 1505 */ 1506 if (arg1) 1507 tmpout = *(int *)arg1; 1508 else 1509 tmpout = arg2; 1510 error = SYSCTL_OUT(req, &tmpout, sizeof(int)); 1511 1512 if (error || !req->newptr) 1513 return (error); 1514 1515 if (!arg1) 1516 error = EPERM; 1517 else 1518 error = SYSCTL_IN(req, arg1, sizeof(int)); 1519 return (error); 1520 } 1521 1522 /* 1523 * Based on on sysctl_handle_int() convert milliseconds into ticks. 1524 * Note: this is used by TCP. 1525 */ 1526 1527 int 1528 sysctl_msec_to_ticks(SYSCTL_HANDLER_ARGS) 1529 { 1530 int error, s, tt; 1531 1532 tt = *(int *)arg1; 1533 s = (int)((int64_t)tt * 1000 / hz); 1534 1535 error = sysctl_handle_int(oidp, &s, 0, req); 1536 if (error || !req->newptr) 1537 return (error); 1538 1539 tt = (int)((int64_t)s * hz / 1000); 1540 if (tt < 1) 1541 return (EINVAL); 1542 1543 *(int *)arg1 = tt; 1544 return (0); 1545 } 1546 1547 1548 /* 1549 * Handle a long, signed or unsigned. 1550 * Two cases: 1551 * a variable: point arg1 at it. 1552 * a constant: pass it in arg2. 1553 */ 1554 1555 int 1556 sysctl_handle_long(SYSCTL_HANDLER_ARGS) 1557 { 1558 int error = 0; 1559 long tmplong; 1560 #ifdef SCTL_MASK32 1561 int tmpint; 1562 #endif 1563 1564 /* 1565 * Attempt to get a coherent snapshot by making a copy of the data. 1566 */ 1567 if (arg1) 1568 tmplong = *(long *)arg1; 1569 else 1570 tmplong = arg2; 1571 #ifdef SCTL_MASK32 1572 if (req->flags & SCTL_MASK32) { 1573 tmpint = tmplong; 1574 error = SYSCTL_OUT(req, &tmpint, sizeof(int)); 1575 } else 1576 #endif 1577 error = SYSCTL_OUT(req, &tmplong, sizeof(long)); 1578 1579 if (error || !req->newptr) 1580 return (error); 1581 1582 if (!arg1) 1583 error = EPERM; 1584 #ifdef SCTL_MASK32 1585 else if (req->flags & SCTL_MASK32) { 1586 error = SYSCTL_IN(req, &tmpint, sizeof(int)); 1587 *(long *)arg1 = (long)tmpint; 1588 } 1589 #endif 1590 else 1591 error = SYSCTL_IN(req, arg1, sizeof(long)); 1592 return (error); 1593 } 1594 1595 /* 1596 * Handle a 64 bit int, signed or unsigned. 1597 * Two cases: 1598 * a variable: point arg1 at it. 1599 * a constant: pass it in arg2. 1600 */ 1601 int 1602 sysctl_handle_64(SYSCTL_HANDLER_ARGS) 1603 { 1604 int error = 0; 1605 uint64_t tmpout; 1606 1607 /* 1608 * Attempt to get a coherent snapshot by making a copy of the data. 1609 */ 1610 if (arg1) 1611 tmpout = *(uint64_t *)arg1; 1612 else 1613 tmpout = arg2; 1614 error = SYSCTL_OUT(req, &tmpout, sizeof(uint64_t)); 1615 1616 if (error || !req->newptr) 1617 return (error); 1618 1619 if (!arg1) 1620 error = EPERM; 1621 else 1622 error = SYSCTL_IN(req, arg1, sizeof(uint64_t)); 1623 return (error); 1624 } 1625 1626 /* 1627 * Handle our generic '\0' terminated 'C' string. 1628 * Two cases: 1629 * a variable string: point arg1 at it, arg2 is max length. 1630 * a constant string: point arg1 at it, arg2 is zero. 1631 */ 1632 1633 int 1634 sysctl_handle_string(SYSCTL_HANDLER_ARGS) 1635 { 1636 size_t outlen; 1637 int error = 0, ro_string = 0; 1638 1639 /* 1640 * A zero-length buffer indicates a fixed size read-only 1641 * string. In ddb, don't worry about trying to make a malloced 1642 * snapshot. 1643 */ 1644 if (arg2 == 0 || kdb_active) { 1645 arg2 = strlen((char *)arg1) + 1; 1646 ro_string = 1; 1647 } 1648 1649 if (req->oldptr != NULL) { 1650 char *tmparg; 1651 1652 if (ro_string) { 1653 tmparg = arg1; 1654 } else { 1655 /* try to make a coherent snapshot of the string */ 1656 tmparg = malloc(arg2, M_SYSCTLTMP, M_WAITOK); 1657 memcpy(tmparg, arg1, arg2); 1658 } 1659 1660 outlen = strnlen(tmparg, arg2 - 1) + 1; 1661 error = SYSCTL_OUT(req, tmparg, outlen); 1662 1663 if (!ro_string) 1664 free(tmparg, M_SYSCTLTMP); 1665 } else { 1666 outlen = strnlen((char *)arg1, arg2 - 1) + 1; 1667 error = SYSCTL_OUT(req, NULL, outlen); 1668 } 1669 if (error || !req->newptr) 1670 return (error); 1671 1672 if ((req->newlen - req->newidx) >= arg2) { 1673 error = EINVAL; 1674 } else { 1675 arg2 = (req->newlen - req->newidx); 1676 error = SYSCTL_IN(req, arg1, arg2); 1677 ((char *)arg1)[arg2] = '\0'; 1678 } 1679 return (error); 1680 } 1681 1682 /* 1683 * Handle any kind of opaque data. 1684 * arg1 points to it, arg2 is the size. 1685 */ 1686 1687 int 1688 sysctl_handle_opaque(SYSCTL_HANDLER_ARGS) 1689 { 1690 int error, tries; 1691 u_int generation; 1692 struct sysctl_req req2; 1693 1694 /* 1695 * Attempt to get a coherent snapshot, by using the thread 1696 * pre-emption counter updated from within mi_switch() to 1697 * determine if we were pre-empted during a bcopy() or 1698 * copyout(). Make 3 attempts at doing this before giving up. 1699 * If we encounter an error, stop immediately. 1700 */ 1701 tries = 0; 1702 req2 = *req; 1703 retry: 1704 generation = curthread->td_generation; 1705 error = SYSCTL_OUT(req, arg1, arg2); 1706 if (error) 1707 return (error); 1708 tries++; 1709 if (generation != curthread->td_generation && tries < 3) { 1710 *req = req2; 1711 goto retry; 1712 } 1713 1714 error = SYSCTL_IN(req, arg1, arg2); 1715 1716 return (error); 1717 } 1718 1719 /* 1720 * Based on on sysctl_handle_int() convert microseconds to a sbintime. 1721 */ 1722 int 1723 sysctl_usec_to_sbintime(SYSCTL_HANDLER_ARGS) 1724 { 1725 int error; 1726 int64_t tt; 1727 sbintime_t sb; 1728 1729 tt = *(int64_t *)arg1; 1730 sb = sbttous(tt); 1731 1732 error = sysctl_handle_64(oidp, &sb, 0, req); 1733 if (error || !req->newptr) 1734 return (error); 1735 1736 tt = ustosbt(sb); 1737 *(int64_t *)arg1 = tt; 1738 1739 return (0); 1740 } 1741 1742 /* 1743 * Based on on sysctl_handle_int() convert milliseconds to a sbintime. 1744 */ 1745 int 1746 sysctl_msec_to_sbintime(SYSCTL_HANDLER_ARGS) 1747 { 1748 int error; 1749 int64_t tt; 1750 sbintime_t sb; 1751 1752 tt = *(int64_t *)arg1; 1753 sb = sbttoms(tt); 1754 1755 error = sysctl_handle_64(oidp, &sb, 0, req); 1756 if (error || !req->newptr) 1757 return (error); 1758 1759 tt = mstosbt(sb); 1760 *(int64_t *)arg1 = tt; 1761 1762 return (0); 1763 } 1764 1765 /* 1766 * Convert seconds to a struct timeval. Intended for use with 1767 * intervals and thus does not permit negative seconds. 1768 */ 1769 int 1770 sysctl_sec_to_timeval(SYSCTL_HANDLER_ARGS) 1771 { 1772 struct timeval *tv; 1773 int error, secs; 1774 1775 tv = arg1; 1776 secs = tv->tv_sec; 1777 1778 error = sysctl_handle_int(oidp, &secs, 0, req); 1779 if (error || req->newptr == NULL) 1780 return (error); 1781 1782 if (secs < 0) 1783 return (EINVAL); 1784 tv->tv_sec = secs; 1785 1786 return (0); 1787 } 1788 1789 /* 1790 * Transfer functions to/from kernel space. 1791 * XXX: rather untested at this point 1792 */ 1793 static int 1794 sysctl_old_kernel(struct sysctl_req *req, const void *p, size_t l) 1795 { 1796 size_t i = 0; 1797 1798 if (req->oldptr) { 1799 i = l; 1800 if (req->oldlen <= req->oldidx) 1801 i = 0; 1802 else 1803 if (i > req->oldlen - req->oldidx) 1804 i = req->oldlen - req->oldidx; 1805 if (i > 0) 1806 bcopy(p, (char *)req->oldptr + req->oldidx, i); 1807 } 1808 req->oldidx += l; 1809 if (req->oldptr && i != l) 1810 return (ENOMEM); 1811 return (0); 1812 } 1813 1814 static int 1815 sysctl_new_kernel(struct sysctl_req *req, void *p, size_t l) 1816 { 1817 if (!req->newptr) 1818 return (0); 1819 if (req->newlen - req->newidx < l) 1820 return (EINVAL); 1821 bcopy((const char *)req->newptr + req->newidx, p, l); 1822 req->newidx += l; 1823 return (0); 1824 } 1825 1826 int 1827 kernel_sysctl(struct thread *td, int *name, u_int namelen, void *old, 1828 size_t *oldlenp, void *new, size_t newlen, size_t *retval, int flags) 1829 { 1830 int error = 0; 1831 struct sysctl_req req; 1832 1833 bzero(&req, sizeof req); 1834 1835 req.td = td; 1836 req.flags = flags; 1837 1838 if (oldlenp) { 1839 req.oldlen = *oldlenp; 1840 } 1841 req.validlen = req.oldlen; 1842 1843 if (old) { 1844 req.oldptr= old; 1845 } 1846 1847 if (new != NULL) { 1848 req.newlen = newlen; 1849 req.newptr = new; 1850 } 1851 1852 req.oldfunc = sysctl_old_kernel; 1853 req.newfunc = sysctl_new_kernel; 1854 req.lock = REQ_UNWIRED; 1855 1856 error = sysctl_root(0, name, namelen, &req); 1857 1858 if (req.lock == REQ_WIRED && req.validlen > 0) 1859 vsunlock(req.oldptr, req.validlen); 1860 1861 if (error && error != ENOMEM) 1862 return (error); 1863 1864 if (retval) { 1865 if (req.oldptr && req.oldidx > req.validlen) 1866 *retval = req.validlen; 1867 else 1868 *retval = req.oldidx; 1869 } 1870 return (error); 1871 } 1872 1873 int 1874 kernel_sysctlbyname(struct thread *td, char *name, void *old, size_t *oldlenp, 1875 void *new, size_t newlen, size_t *retval, int flags) 1876 { 1877 int oid[CTL_MAXNAME]; 1878 size_t oidlen, plen; 1879 int error; 1880 1881 oid[0] = CTL_SYSCTL; 1882 oid[1] = CTL_SYSCTL_NAME2OID; 1883 oidlen = sizeof(oid); 1884 1885 error = kernel_sysctl(td, oid, 2, oid, &oidlen, 1886 (void *)name, strlen(name), &plen, flags); 1887 if (error) 1888 return (error); 1889 1890 error = kernel_sysctl(td, oid, plen / sizeof(int), old, oldlenp, 1891 new, newlen, retval, flags); 1892 return (error); 1893 } 1894 1895 /* 1896 * Transfer function to/from user space. 1897 */ 1898 static int 1899 sysctl_old_user(struct sysctl_req *req, const void *p, size_t l) 1900 { 1901 size_t i, len, origidx; 1902 int error; 1903 1904 origidx = req->oldidx; 1905 req->oldidx += l; 1906 if (req->oldptr == NULL) 1907 return (0); 1908 /* 1909 * If we have not wired the user supplied buffer and we are currently 1910 * holding locks, drop a witness warning, as it's possible that 1911 * write operations to the user page can sleep. 1912 */ 1913 if (req->lock != REQ_WIRED) 1914 WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, 1915 "sysctl_old_user()"); 1916 i = l; 1917 len = req->validlen; 1918 if (len <= origidx) 1919 i = 0; 1920 else { 1921 if (i > len - origidx) 1922 i = len - origidx; 1923 if (req->lock == REQ_WIRED) { 1924 error = copyout_nofault(p, (char *)req->oldptr + 1925 origidx, i); 1926 } else 1927 error = copyout(p, (char *)req->oldptr + origidx, i); 1928 if (error != 0) 1929 return (error); 1930 } 1931 if (i < l) 1932 return (ENOMEM); 1933 return (0); 1934 } 1935 1936 static int 1937 sysctl_new_user(struct sysctl_req *req, void *p, size_t l) 1938 { 1939 int error; 1940 1941 if (!req->newptr) 1942 return (0); 1943 if (req->newlen - req->newidx < l) 1944 return (EINVAL); 1945 WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, 1946 "sysctl_new_user()"); 1947 error = copyin((const char *)req->newptr + req->newidx, p, l); 1948 req->newidx += l; 1949 return (error); 1950 } 1951 1952 /* 1953 * Wire the user space destination buffer. If set to a value greater than 1954 * zero, the len parameter limits the maximum amount of wired memory. 1955 */ 1956 int 1957 sysctl_wire_old_buffer(struct sysctl_req *req, size_t len) 1958 { 1959 int ret; 1960 size_t wiredlen; 1961 1962 wiredlen = (len > 0 && len < req->oldlen) ? len : req->oldlen; 1963 ret = 0; 1964 if (req->lock != REQ_WIRED && req->oldptr && 1965 req->oldfunc == sysctl_old_user) { 1966 if (wiredlen != 0) { 1967 ret = vslock(req->oldptr, wiredlen); 1968 if (ret != 0) { 1969 if (ret != ENOMEM) 1970 return (ret); 1971 wiredlen = 0; 1972 } 1973 } 1974 req->lock = REQ_WIRED; 1975 req->validlen = wiredlen; 1976 } 1977 return (0); 1978 } 1979 1980 int 1981 sysctl_find_oid(int *name, u_int namelen, struct sysctl_oid **noid, 1982 int *nindx, struct sysctl_req *req) 1983 { 1984 struct sysctl_oid_list *lsp; 1985 struct sysctl_oid *oid; 1986 int indx; 1987 1988 SYSCTL_ASSERT_LOCKED(); 1989 lsp = &sysctl__children; 1990 indx = 0; 1991 while (indx < CTL_MAXNAME) { 1992 SLIST_FOREACH(oid, lsp, oid_link) { 1993 if (oid->oid_number == name[indx]) 1994 break; 1995 } 1996 if (oid == NULL) 1997 return (ENOENT); 1998 1999 indx++; 2000 if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) { 2001 if (oid->oid_handler != NULL || indx == namelen) { 2002 *noid = oid; 2003 if (nindx != NULL) 2004 *nindx = indx; 2005 KASSERT((oid->oid_kind & CTLFLAG_DYING) == 0, 2006 ("%s found DYING node %p", __func__, oid)); 2007 return (0); 2008 } 2009 lsp = SYSCTL_CHILDREN(oid); 2010 } else if (indx == namelen) { 2011 if ((oid->oid_kind & CTLFLAG_DORMANT) != 0) 2012 return (ENOENT); 2013 *noid = oid; 2014 if (nindx != NULL) 2015 *nindx = indx; 2016 KASSERT((oid->oid_kind & CTLFLAG_DYING) == 0, 2017 ("%s found DYING node %p", __func__, oid)); 2018 return (0); 2019 } else { 2020 return (ENOTDIR); 2021 } 2022 } 2023 return (ENOENT); 2024 } 2025 2026 /* 2027 * Traverse our tree, and find the right node, execute whatever it points 2028 * to, and return the resulting error code. 2029 */ 2030 2031 static int 2032 sysctl_root(SYSCTL_HANDLER_ARGS) 2033 { 2034 struct sysctl_oid *oid; 2035 struct rm_priotracker tracker; 2036 int error, indx, lvl; 2037 2038 SYSCTL_RLOCK(&tracker); 2039 2040 error = sysctl_find_oid(arg1, arg2, &oid, &indx, req); 2041 if (error) 2042 goto out; 2043 2044 if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) { 2045 /* 2046 * You can't call a sysctl when it's a node, but has 2047 * no handler. Inform the user that it's a node. 2048 * The indx may or may not be the same as namelen. 2049 */ 2050 if (oid->oid_handler == NULL) { 2051 error = EISDIR; 2052 goto out; 2053 } 2054 } 2055 2056 /* Is this sysctl writable? */ 2057 if (req->newptr && !(oid->oid_kind & CTLFLAG_WR)) { 2058 error = EPERM; 2059 goto out; 2060 } 2061 2062 KASSERT(req->td != NULL, ("sysctl_root(): req->td == NULL")); 2063 2064 #ifdef CAPABILITY_MODE 2065 /* 2066 * If the process is in capability mode, then don't permit reading or 2067 * writing unless specifically granted for the node. 2068 */ 2069 if (IN_CAPABILITY_MODE(req->td)) { 2070 if ((req->oldptr && !(oid->oid_kind & CTLFLAG_CAPRD)) || 2071 (req->newptr && !(oid->oid_kind & CTLFLAG_CAPWR))) { 2072 error = EPERM; 2073 goto out; 2074 } 2075 } 2076 #endif 2077 2078 /* Is this sysctl sensitive to securelevels? */ 2079 if (req->newptr && (oid->oid_kind & CTLFLAG_SECURE)) { 2080 lvl = (oid->oid_kind & CTLMASK_SECURE) >> CTLSHIFT_SECURE; 2081 error = securelevel_gt(req->td->td_ucred, lvl); 2082 if (error) 2083 goto out; 2084 } 2085 2086 /* Is this sysctl writable by only privileged users? */ 2087 if (req->newptr && !(oid->oid_kind & CTLFLAG_ANYBODY)) { 2088 int priv; 2089 2090 if (oid->oid_kind & CTLFLAG_PRISON) 2091 priv = PRIV_SYSCTL_WRITEJAIL; 2092 #ifdef VIMAGE 2093 else if ((oid->oid_kind & CTLFLAG_VNET) && 2094 prison_owns_vnet(req->td->td_ucred)) 2095 priv = PRIV_SYSCTL_WRITEJAIL; 2096 #endif 2097 else 2098 priv = PRIV_SYSCTL_WRITE; 2099 error = priv_check(req->td, priv); 2100 if (error) 2101 goto out; 2102 } 2103 2104 if (!oid->oid_handler) { 2105 error = EINVAL; 2106 goto out; 2107 } 2108 2109 if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) { 2110 arg1 = (int *)arg1 + indx; 2111 arg2 -= indx; 2112 } else { 2113 arg1 = oid->oid_arg1; 2114 arg2 = oid->oid_arg2; 2115 } 2116 #ifdef MAC 2117 error = mac_system_check_sysctl(req->td->td_ucred, oid, arg1, arg2, 2118 req); 2119 if (error != 0) 2120 goto out; 2121 #endif 2122 #ifdef VIMAGE 2123 if ((oid->oid_kind & CTLFLAG_VNET) && arg1 != NULL) 2124 arg1 = (void *)(curvnet->vnet_data_base + (uintptr_t)arg1); 2125 #endif 2126 error = sysctl_root_handler_locked(oid, arg1, arg2, req, &tracker); 2127 2128 out: 2129 SYSCTL_RUNLOCK(&tracker); 2130 return (error); 2131 } 2132 2133 #ifndef _SYS_SYSPROTO_H_ 2134 struct sysctl_args { 2135 int *name; 2136 u_int namelen; 2137 void *old; 2138 size_t *oldlenp; 2139 void *new; 2140 size_t newlen; 2141 }; 2142 #endif 2143 int 2144 sys___sysctl(struct thread *td, struct sysctl_args *uap) 2145 { 2146 int error, i, name[CTL_MAXNAME]; 2147 size_t j; 2148 2149 if (uap->namelen > CTL_MAXNAME || uap->namelen < 2) 2150 return (EINVAL); 2151 2152 error = copyin(uap->name, &name, uap->namelen * sizeof(int)); 2153 if (error) 2154 return (error); 2155 2156 error = userland_sysctl(td, name, uap->namelen, 2157 uap->old, uap->oldlenp, 0, 2158 uap->new, uap->newlen, &j, 0); 2159 if (error && error != ENOMEM) 2160 return (error); 2161 if (uap->oldlenp) { 2162 i = copyout(&j, uap->oldlenp, sizeof(j)); 2163 if (i) 2164 return (i); 2165 } 2166 return (error); 2167 } 2168 2169 int 2170 kern___sysctlbyname(struct thread *td, const char *oname, size_t namelen, 2171 void *old, size_t *oldlenp, void *new, size_t newlen, size_t *retval, 2172 int flags, bool inkernel) 2173 { 2174 int oid[CTL_MAXNAME]; 2175 char namebuf[16]; 2176 char *name; 2177 size_t oidlen; 2178 int error; 2179 2180 if (namelen > MAXPATHLEN || namelen == 0) 2181 return (EINVAL); 2182 name = namebuf; 2183 if (namelen > sizeof(namebuf)) 2184 name = malloc(namelen, M_SYSCTL, M_WAITOK); 2185 error = copyin(oname, name, namelen); 2186 if (error != 0) 2187 goto out; 2188 2189 oid[0] = CTL_SYSCTL; 2190 oid[1] = CTL_SYSCTL_NAME2OID; 2191 oidlen = sizeof(oid); 2192 error = kernel_sysctl(td, oid, 2, oid, &oidlen, (void *)name, namelen, 2193 retval, flags); 2194 if (error != 0) 2195 goto out; 2196 error = userland_sysctl(td, oid, *retval / sizeof(int), old, oldlenp, 2197 inkernel, new, newlen, retval, flags); 2198 2199 out: 2200 if (namelen > sizeof(namebuf)) 2201 free(name, M_SYSCTL); 2202 return (error); 2203 } 2204 2205 #ifndef _SYS_SYSPROTO_H_ 2206 struct __sysctlbyname_args { 2207 const char *name; 2208 size_t namelen; 2209 void *old; 2210 size_t *oldlenp; 2211 void *new; 2212 size_t newlen; 2213 }; 2214 #endif 2215 int 2216 sys___sysctlbyname(struct thread *td, struct __sysctlbyname_args *uap) 2217 { 2218 size_t rv; 2219 int error; 2220 2221 error = kern___sysctlbyname(td, uap->name, uap->namelen, uap->old, 2222 uap->oldlenp, uap->new, uap->newlen, &rv, 0, 0); 2223 if (error != 0) 2224 return (error); 2225 if (uap->oldlenp != NULL) 2226 error = copyout(&rv, uap->oldlenp, sizeof(rv)); 2227 2228 return (error); 2229 } 2230 2231 /* 2232 * This is used from various compatibility syscalls too. That's why name 2233 * must be in kernel space. 2234 */ 2235 int 2236 userland_sysctl(struct thread *td, int *name, u_int namelen, void *old, 2237 size_t *oldlenp, int inkernel, const void *new, size_t newlen, 2238 size_t *retval, int flags) 2239 { 2240 int error = 0, memlocked; 2241 struct sysctl_req req; 2242 2243 bzero(&req, sizeof req); 2244 2245 req.td = td; 2246 req.flags = flags; 2247 2248 if (oldlenp) { 2249 if (inkernel) { 2250 req.oldlen = *oldlenp; 2251 } else { 2252 error = copyin(oldlenp, &req.oldlen, sizeof(*oldlenp)); 2253 if (error) 2254 return (error); 2255 } 2256 } 2257 req.validlen = req.oldlen; 2258 req.oldptr = old; 2259 2260 if (new != NULL) { 2261 req.newlen = newlen; 2262 req.newptr = new; 2263 } 2264 2265 req.oldfunc = sysctl_old_user; 2266 req.newfunc = sysctl_new_user; 2267 req.lock = REQ_UNWIRED; 2268 2269 #ifdef KTRACE 2270 if (KTRPOINT(curthread, KTR_SYSCTL)) 2271 ktrsysctl(name, namelen); 2272 #endif 2273 memlocked = 0; 2274 if (req.oldptr && req.oldlen > 4 * PAGE_SIZE) { 2275 memlocked = 1; 2276 sx_xlock(&sysctlmemlock); 2277 } 2278 CURVNET_SET(TD_TO_VNET(td)); 2279 2280 for (;;) { 2281 req.oldidx = 0; 2282 req.newidx = 0; 2283 error = sysctl_root(0, name, namelen, &req); 2284 if (error != EAGAIN) 2285 break; 2286 kern_yield(PRI_USER); 2287 } 2288 2289 CURVNET_RESTORE(); 2290 2291 if (req.lock == REQ_WIRED && req.validlen > 0) 2292 vsunlock(req.oldptr, req.validlen); 2293 if (memlocked) 2294 sx_xunlock(&sysctlmemlock); 2295 2296 if (error && error != ENOMEM) 2297 return (error); 2298 2299 if (retval) { 2300 if (req.oldptr && req.oldidx > req.validlen) 2301 *retval = req.validlen; 2302 else 2303 *retval = req.oldidx; 2304 } 2305 return (error); 2306 } 2307 2308 /* 2309 * Drain into a sysctl struct. The user buffer should be wired if a page 2310 * fault would cause issue. 2311 */ 2312 static int 2313 sbuf_sysctl_drain(void *arg, const char *data, int len) 2314 { 2315 struct sysctl_req *req = arg; 2316 int error; 2317 2318 error = SYSCTL_OUT(req, data, len); 2319 KASSERT(error >= 0, ("Got unexpected negative value %d", error)); 2320 return (error == 0 ? len : -error); 2321 } 2322 2323 struct sbuf * 2324 sbuf_new_for_sysctl(struct sbuf *s, char *buf, int length, 2325 struct sysctl_req *req) 2326 { 2327 2328 /* Supply a default buffer size if none given. */ 2329 if (buf == NULL && length == 0) 2330 length = 64; 2331 s = sbuf_new(s, buf, length, SBUF_FIXEDLEN | SBUF_INCLUDENUL); 2332 sbuf_set_drain(s, sbuf_sysctl_drain, req); 2333 return (s); 2334 } 2335 2336 #ifdef DDB 2337 2338 /* The current OID the debugger is working with */ 2339 static struct sysctl_oid *g_ddb_oid; 2340 2341 /* The current flags specified by the user */ 2342 static int g_ddb_sysctl_flags; 2343 2344 /* Check to see if the last sysctl printed */ 2345 static int g_ddb_sysctl_printed; 2346 2347 static const int ctl_sign[CTLTYPE+1] = { 2348 [CTLTYPE_INT] = 1, 2349 [CTLTYPE_LONG] = 1, 2350 [CTLTYPE_S8] = 1, 2351 [CTLTYPE_S16] = 1, 2352 [CTLTYPE_S32] = 1, 2353 [CTLTYPE_S64] = 1, 2354 }; 2355 2356 static const int ctl_size[CTLTYPE+1] = { 2357 [CTLTYPE_INT] = sizeof(int), 2358 [CTLTYPE_UINT] = sizeof(u_int), 2359 [CTLTYPE_LONG] = sizeof(long), 2360 [CTLTYPE_ULONG] = sizeof(u_long), 2361 [CTLTYPE_S8] = sizeof(int8_t), 2362 [CTLTYPE_S16] = sizeof(int16_t), 2363 [CTLTYPE_S32] = sizeof(int32_t), 2364 [CTLTYPE_S64] = sizeof(int64_t), 2365 [CTLTYPE_U8] = sizeof(uint8_t), 2366 [CTLTYPE_U16] = sizeof(uint16_t), 2367 [CTLTYPE_U32] = sizeof(uint32_t), 2368 [CTLTYPE_U64] = sizeof(uint64_t), 2369 }; 2370 2371 #define DB_SYSCTL_NAME_ONLY 0x001 /* Compare with -N */ 2372 #define DB_SYSCTL_VALUE_ONLY 0x002 /* Compare with -n */ 2373 #define DB_SYSCTL_OPAQUE 0x004 /* Compare with -o */ 2374 #define DB_SYSCTL_HEX 0x008 /* Compare with -x */ 2375 2376 #define DB_SYSCTL_SAFE_ONLY 0x100 /* Only simple types */ 2377 2378 static const char db_sysctl_modifs[] = { 2379 'N', 'n', 'o', 'x', 2380 }; 2381 2382 static const int db_sysctl_modif_values[] = { 2383 DB_SYSCTL_NAME_ONLY, DB_SYSCTL_VALUE_ONLY, 2384 DB_SYSCTL_OPAQUE, DB_SYSCTL_HEX, 2385 }; 2386 2387 /* Handlers considered safe to print while recursing */ 2388 static int (* const db_safe_handlers[])(SYSCTL_HANDLER_ARGS) = { 2389 sysctl_handle_bool, 2390 sysctl_handle_8, 2391 sysctl_handle_16, 2392 sysctl_handle_32, 2393 sysctl_handle_64, 2394 sysctl_handle_int, 2395 sysctl_handle_long, 2396 sysctl_handle_string, 2397 sysctl_handle_opaque, 2398 }; 2399 2400 /* 2401 * Use in place of sysctl_old_kernel to print sysctl values. 2402 * 2403 * Compare to the output handling in show_var from sbin/sysctl/sysctl.c 2404 */ 2405 static int 2406 sysctl_old_ddb(struct sysctl_req *req, const void *ptr, size_t len) 2407 { 2408 const u_char *val, *p; 2409 const char *sep1; 2410 size_t intlen, slen; 2411 uintmax_t umv; 2412 intmax_t mv; 2413 int sign, ctltype, hexlen, xflag, error; 2414 2415 /* Suppress false-positive GCC uninitialized variable warnings */ 2416 mv = 0; 2417 umv = 0; 2418 2419 slen = len; 2420 val = p = ptr; 2421 2422 if (ptr == NULL) { 2423 error = 0; 2424 goto out; 2425 } 2426 2427 /* We are going to print */ 2428 g_ddb_sysctl_printed = 1; 2429 2430 xflag = g_ddb_sysctl_flags & DB_SYSCTL_HEX; 2431 2432 ctltype = (g_ddb_oid->oid_kind & CTLTYPE); 2433 sign = ctl_sign[ctltype]; 2434 intlen = ctl_size[ctltype]; 2435 2436 switch (ctltype) { 2437 case CTLTYPE_NODE: 2438 case CTLTYPE_STRING: 2439 db_printf("%.*s", (int) len, (const char *) p); 2440 error = 0; 2441 goto out; 2442 2443 case CTLTYPE_INT: 2444 case CTLTYPE_UINT: 2445 case CTLTYPE_LONG: 2446 case CTLTYPE_ULONG: 2447 case CTLTYPE_S8: 2448 case CTLTYPE_S16: 2449 case CTLTYPE_S32: 2450 case CTLTYPE_S64: 2451 case CTLTYPE_U8: 2452 case CTLTYPE_U16: 2453 case CTLTYPE_U32: 2454 case CTLTYPE_U64: 2455 hexlen = 2 + (intlen * CHAR_BIT + 3) / 4; 2456 sep1 = ""; 2457 while (len >= intlen) { 2458 switch (ctltype) { 2459 case CTLTYPE_INT: 2460 case CTLTYPE_UINT: 2461 umv = *(const u_int *)p; 2462 mv = *(const int *)p; 2463 break; 2464 case CTLTYPE_LONG: 2465 case CTLTYPE_ULONG: 2466 umv = *(const u_long *)p; 2467 mv = *(const long *)p; 2468 break; 2469 case CTLTYPE_S8: 2470 case CTLTYPE_U8: 2471 umv = *(const uint8_t *)p; 2472 mv = *(const int8_t *)p; 2473 break; 2474 case CTLTYPE_S16: 2475 case CTLTYPE_U16: 2476 umv = *(const uint16_t *)p; 2477 mv = *(const int16_t *)p; 2478 break; 2479 case CTLTYPE_S32: 2480 case CTLTYPE_U32: 2481 umv = *(const uint32_t *)p; 2482 mv = *(const int32_t *)p; 2483 break; 2484 case CTLTYPE_S64: 2485 case CTLTYPE_U64: 2486 umv = *(const uint64_t *)p; 2487 mv = *(const int64_t *)p; 2488 break; 2489 } 2490 2491 db_printf("%s", sep1); 2492 if (xflag) 2493 db_printf("%#0*jx", hexlen, umv); 2494 else if (!sign) 2495 db_printf("%ju", umv); 2496 else if (g_ddb_oid->oid_fmt[1] == 'K') { 2497 /* Kelvins are currently unsupported. */ 2498 error = EOPNOTSUPP; 2499 goto out; 2500 } else 2501 db_printf("%jd", mv); 2502 2503 sep1 = " "; 2504 len -= intlen; 2505 p += intlen; 2506 } 2507 error = 0; 2508 goto out; 2509 2510 case CTLTYPE_OPAQUE: 2511 /* TODO: Support struct functions. */ 2512 2513 /* FALLTHROUGH */ 2514 default: 2515 db_printf("Format:%s Length:%zu Dump:0x", 2516 g_ddb_oid->oid_fmt, len); 2517 while (len-- && (xflag || p < val + 16)) 2518 db_printf("%02x", *p++); 2519 if (!xflag && len > 16) 2520 db_printf("..."); 2521 error = 0; 2522 goto out; 2523 } 2524 2525 out: 2526 req->oldidx += slen; 2527 return (error); 2528 } 2529 2530 /* 2531 * Avoid setting new sysctl values from the debugger 2532 */ 2533 static int 2534 sysctl_new_ddb(struct sysctl_req *req, void *p, size_t l) 2535 { 2536 2537 if (!req->newptr) 2538 return (0); 2539 2540 /* Changing sysctls from the debugger is currently unsupported */ 2541 return (EPERM); 2542 } 2543 2544 /* 2545 * Run a sysctl handler with the DDB oldfunc and newfunc attached. 2546 * Instead of copying any output to a buffer we'll dump it right to 2547 * the console. 2548 */ 2549 static int 2550 db_sysctl(struct sysctl_oid *oidp, int *name, u_int namelen, 2551 void *old, size_t *oldlenp, size_t *retval, int flags) 2552 { 2553 struct sysctl_req req; 2554 int error; 2555 2556 /* Setup the request */ 2557 bzero(&req, sizeof req); 2558 req.td = kdb_thread; 2559 req.oldfunc = sysctl_old_ddb; 2560 req.newfunc = sysctl_new_ddb; 2561 req.lock = REQ_UNWIRED; 2562 if (oldlenp) { 2563 req.oldlen = *oldlenp; 2564 } 2565 req.validlen = req.oldlen; 2566 if (old) { 2567 req.oldptr = old; 2568 } 2569 2570 /* Setup our globals for sysctl_old_ddb */ 2571 g_ddb_oid = oidp; 2572 g_ddb_sysctl_flags = flags; 2573 g_ddb_sysctl_printed = 0; 2574 2575 error = sysctl_root(0, name, namelen, &req); 2576 2577 /* Reset globals */ 2578 g_ddb_oid = NULL; 2579 g_ddb_sysctl_flags = 0; 2580 2581 if (retval) { 2582 if (req.oldptr && req.oldidx > req.validlen) 2583 *retval = req.validlen; 2584 else 2585 *retval = req.oldidx; 2586 } 2587 return (error); 2588 } 2589 2590 /* 2591 * Show a sysctl's name 2592 */ 2593 static void 2594 db_show_oid_name(int *oid, size_t nlen) 2595 { 2596 struct sysctl_oid *oidp; 2597 int qoid[CTL_MAXNAME+2]; 2598 int error; 2599 2600 qoid[0] = 0; 2601 memcpy(qoid + 2, oid, nlen * sizeof(int)); 2602 qoid[1] = 1; 2603 2604 error = sysctl_find_oid(qoid, nlen + 2, &oidp, NULL, NULL); 2605 if (error) 2606 db_error("sysctl name oid"); 2607 2608 error = db_sysctl(oidp, qoid, nlen + 2, NULL, NULL, NULL, 0); 2609 if (error) 2610 db_error("sysctl name"); 2611 } 2612 2613 /* 2614 * Check to see if an OID is safe to print from ddb. 2615 */ 2616 static bool 2617 db_oid_safe(const struct sysctl_oid *oidp) 2618 { 2619 for (unsigned int i = 0; i < nitems(db_safe_handlers); ++i) { 2620 if (oidp->oid_handler == db_safe_handlers[i]) 2621 return (true); 2622 } 2623 2624 return (false); 2625 } 2626 2627 /* 2628 * Show a sysctl at a specific OID 2629 * Compare to the input handling in show_var from sbin/sysctl/sysctl.c 2630 */ 2631 static int 2632 db_show_oid(struct sysctl_oid *oidp, int *oid, size_t nlen, int flags) 2633 { 2634 int error, xflag, oflag, Nflag, nflag; 2635 size_t len; 2636 2637 xflag = flags & DB_SYSCTL_HEX; 2638 oflag = flags & DB_SYSCTL_OPAQUE; 2639 nflag = flags & DB_SYSCTL_VALUE_ONLY; 2640 Nflag = flags & DB_SYSCTL_NAME_ONLY; 2641 2642 if ((oidp->oid_kind & CTLTYPE) == CTLTYPE_OPAQUE && 2643 (!xflag && !oflag)) 2644 return (0); 2645 2646 if (Nflag) { 2647 db_show_oid_name(oid, nlen); 2648 error = 0; 2649 goto out; 2650 } 2651 2652 if (!nflag) { 2653 db_show_oid_name(oid, nlen); 2654 db_printf(": "); 2655 } 2656 2657 if ((flags & DB_SYSCTL_SAFE_ONLY) && !db_oid_safe(oidp)) { 2658 db_printf("Skipping, unsafe to print while recursing."); 2659 error = 0; 2660 goto out; 2661 } 2662 2663 /* Try once, and ask about the size */ 2664 len = 0; 2665 error = db_sysctl(oidp, oid, nlen, 2666 NULL, NULL, &len, flags); 2667 if (error) 2668 goto out; 2669 2670 if (!g_ddb_sysctl_printed) 2671 /* Lie about the size */ 2672 error = db_sysctl(oidp, oid, nlen, 2673 (void *) 1, &len, NULL, flags); 2674 2675 out: 2676 db_printf("\n"); 2677 return (error); 2678 } 2679 2680 /* 2681 * Show all sysctls under a specific OID 2682 * Compare to sysctl_all from sbin/sysctl/sysctl.c 2683 */ 2684 static int 2685 db_show_sysctl_all(int *oid, size_t len, int flags) 2686 { 2687 struct sysctl_oid *oidp; 2688 int name1[CTL_MAXNAME + 2], name2[CTL_MAXNAME + 2]; 2689 size_t l1, l2; 2690 2691 name1[0] = CTL_SYSCTL; 2692 name1[1] = CTL_SYSCTL_NEXT; 2693 l1 = 2; 2694 if (len) { 2695 memcpy(name1+2, oid, len * sizeof(int)); 2696 l1 +=len; 2697 } else { 2698 name1[2] = 1; 2699 l1++; 2700 } 2701 for (;;) { 2702 int i, error; 2703 2704 l2 = sizeof(name2); 2705 error = kernel_sysctl(kdb_thread, name1, l1, 2706 name2, &l2, NULL, 0, &l2, 0); 2707 if (error != 0) { 2708 if (error == ENOENT) 2709 return (0); 2710 else 2711 db_error("sysctl(getnext)"); 2712 } 2713 2714 l2 /= sizeof(int); 2715 2716 if (l2 < (unsigned int)len) 2717 return (0); 2718 2719 for (i = 0; i < len; i++) 2720 if (name2[i] != oid[i]) 2721 return (0); 2722 2723 /* Find the OID in question */ 2724 error = sysctl_find_oid(name2, l2, &oidp, NULL, NULL); 2725 if (error) 2726 return (error); 2727 2728 i = db_show_oid(oidp, name2, l2, flags | DB_SYSCTL_SAFE_ONLY); 2729 2730 if (db_pager_quit) 2731 return (0); 2732 2733 memcpy(name1+2, name2, l2 * sizeof(int)); 2734 l1 = 2 + l2; 2735 } 2736 } 2737 2738 /* 2739 * Show a sysctl by its user facing string 2740 */ 2741 static int 2742 db_sysctlbyname(char *name, int flags) 2743 { 2744 struct sysctl_oid *oidp; 2745 int oid[CTL_MAXNAME]; 2746 int error, nlen; 2747 2748 error = name2oid(name, oid, &nlen, &oidp); 2749 if (error) { 2750 return (error); 2751 } 2752 2753 if ((oidp->oid_kind & CTLTYPE) == CTLTYPE_NODE) { 2754 db_show_sysctl_all(oid, nlen, flags); 2755 } else { 2756 error = db_show_oid(oidp, oid, nlen, flags); 2757 } 2758 2759 return (error); 2760 } 2761 2762 static void 2763 db_sysctl_cmd_usage(void) 2764 { 2765 db_printf( 2766 " sysctl [/Nnox] <sysctl> \n" 2767 " \n" 2768 " <sysctl> The name of the sysctl to show. \n" 2769 " \n" 2770 " Show a sysctl by hooking into SYSCTL_IN and SYSCTL_OUT. \n" 2771 " This will work for most sysctls, but should not be used \n" 2772 " with sysctls that are known to malloc. \n" 2773 " \n" 2774 " While recursing any \"unsafe\" sysctls will be skipped. \n" 2775 " Call sysctl directly on the sysctl to try printing the \n" 2776 " skipped sysctl. This is unsafe and may make the ddb \n" 2777 " session unusable. \n" 2778 " \n" 2779 " Arguments: \n" 2780 " /N Display only the name of the sysctl. \n" 2781 " /n Display only the value of the sysctl. \n" 2782 " /o Display opaque values. \n" 2783 " /x Display the sysctl in hex. \n" 2784 " \n" 2785 "For example: \n" 2786 "sysctl vm.v_free_min \n" 2787 "vn.v_free_min: 12669 \n" 2788 ); 2789 } 2790 2791 /* 2792 * Show a specific sysctl similar to sysctl (8). 2793 */ 2794 DB_FUNC(sysctl, db_sysctl_cmd, db_cmd_table, CS_OWN, NULL) 2795 { 2796 char name[TOK_STRING_SIZE]; 2797 int error, i, t, flags; 2798 2799 /* Parse the modifiers */ 2800 t = db_read_token(); 2801 if (t == tSLASH || t == tMINUS) { 2802 t = db_read_token(); 2803 if (t != tIDENT) { 2804 db_printf("Bad modifier\n"); 2805 error = EINVAL; 2806 goto out; 2807 } 2808 db_strcpy(modif, db_tok_string); 2809 } 2810 else { 2811 db_unread_token(t); 2812 modif[0] = '\0'; 2813 } 2814 2815 flags = 0; 2816 for (i = 0; i < nitems(db_sysctl_modifs); i++) { 2817 if (strchr(modif, db_sysctl_modifs[i])) { 2818 flags |= db_sysctl_modif_values[i]; 2819 } 2820 } 2821 2822 /* Parse the sysctl names */ 2823 t = db_read_token(); 2824 if (t != tIDENT) { 2825 db_printf("Need sysctl name\n"); 2826 error = EINVAL; 2827 goto out; 2828 } 2829 2830 /* Copy the name into a temporary buffer */ 2831 db_strcpy(name, db_tok_string); 2832 2833 /* Ensure there is no trailing cruft */ 2834 t = db_read_token(); 2835 if (t != tEOL) { 2836 db_printf("Unexpected sysctl argument\n"); 2837 error = EINVAL; 2838 goto out; 2839 } 2840 2841 error = db_sysctlbyname(name, flags); 2842 if (error == ENOENT) { 2843 db_printf("unknown oid: '%s'\n", db_tok_string); 2844 goto out; 2845 } else if (error) { 2846 db_printf("%s: error: %d\n", db_tok_string, error); 2847 goto out; 2848 } 2849 2850 out: 2851 /* Ensure we eat all of our text */ 2852 db_flush_lex(); 2853 2854 if (error == EINVAL) { 2855 db_sysctl_cmd_usage(); 2856 } 2857 } 2858 2859 #endif /* DDB */ 2860