1 /* $NetBSD: kern_sysctl.c,v 1.205 2006/10/12 01:32:17 christos Exp $ */ 2 3 /*- 4 * Copyright (c) 2003 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Andrew Brown. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 /*- 40 * Copyright (c) 1982, 1986, 1989, 1993 41 * The Regents of the University of California. All rights reserved. 42 * 43 * This code is derived from software contributed to Berkeley by 44 * Mike Karels at Berkeley Software Design, Inc. 45 * 46 * Redistribution and use in source and binary forms, with or without 47 * modification, are permitted provided that the following conditions 48 * are met: 49 * 1. Redistributions of source code must retain the above copyright 50 * notice, this list of conditions and the following disclaimer. 51 * 2. Redistributions in binary form must reproduce the above copyright 52 * notice, this list of conditions and the following disclaimer in the 53 * documentation and/or other materials provided with the distribution. 54 * 3. Neither the name of the University nor the names of its contributors 55 * may be used to endorse or promote products derived from this software 56 * without specific prior written permission. 57 * 58 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 59 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 60 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 61 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 62 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 63 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 64 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 65 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 66 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 67 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 68 * SUCH DAMAGE. 69 * 70 * @(#)kern_sysctl.c 8.9 (Berkeley) 5/20/95 71 */ 72 73 /* 74 * sysctl system call. 75 */ 76 77 #include <sys/cdefs.h> 78 __KERNEL_RCSID(0, "$NetBSD: kern_sysctl.c,v 1.205 2006/10/12 01:32:17 christos Exp $"); 79 80 #include "opt_defcorename.h" 81 #include "opt_ktrace.h" 82 #include "ksyms.h" 83 84 #include <sys/param.h> 85 #define __COMPAT_SYSCTL 86 #include <sys/sysctl.h> 87 #include <sys/systm.h> 88 #include <sys/buf.h> 89 #include <sys/ksyms.h> 90 #include <sys/malloc.h> 91 #include <sys/mount.h> 92 #include <sys/sa.h> 93 #include <sys/syscallargs.h> 94 #include <sys/kauth.h> 95 #ifdef KTRACE 96 #include <sys/ktrace.h> 97 #endif 98 #include <machine/stdarg.h> 99 100 #define MAXDESCLEN 1024 101 MALLOC_DEFINE(M_SYSCTLNODE, "sysctlnode", "sysctl node structures"); 102 MALLOC_DEFINE(M_SYSCTLDATA, "sysctldata", "misc sysctl data"); 103 104 static int sysctl_mmap(SYSCTLFN_PROTO); 105 static int sysctl_alloc(struct sysctlnode *, int); 106 static int sysctl_realloc(struct sysctlnode *); 107 108 static int sysctl_cvt_in(struct lwp *, int *, const void *, size_t, 109 struct sysctlnode *); 110 static int sysctl_cvt_out(struct lwp *, int, const struct sysctlnode *, 111 void *, size_t, size_t *); 112 113 static int sysctl_log_add(struct sysctllog **, const struct sysctlnode *); 114 static int sysctl_log_realloc(struct sysctllog *); 115 116 struct sysctllog { 117 const struct sysctlnode *log_root; 118 int *log_num; 119 int log_size, log_left; 120 }; 121 122 /* 123 * the "root" of the new sysctl tree 124 */ 125 struct sysctlnode sysctl_root = { 126 .sysctl_flags = SYSCTL_VERSION| 127 CTLFLAG_ROOT|CTLFLAG_READWRITE| 128 CTLTYPE_NODE, 129 .sysctl_num = 0, 130 /* 131 * XXX once all ports are on gcc3, we can get rid of this 132 * ugliness and simply make it into 133 * 134 * .sysctl_size = sizeof(struct sysctlnode), 135 */ 136 sysc_init_field(_sysctl_size, sizeof(struct sysctlnode)), 137 .sysctl_name = "(root)", 138 }; 139 140 /* 141 * link set of functions that add nodes at boot time (see also 142 * sysctl_buildtree()) 143 */ 144 __link_set_decl(sysctl_funcs, sysctl_setup_func); 145 146 /* 147 * The `sysctl_lock' is intended to serialize access to the sysctl 148 * tree. Given that it is now (a) dynamic, and (b) most consumers of 149 * sysctl are going to be copying data out, the old `sysctl_memlock' 150 * has been `upgraded' to simply guard the whole tree. 151 * 152 * The two new data here are to keep track of the locked chunk of 153 * memory, if there is one, so that it can be released more easily 154 * from anywhere. 155 */ 156 struct lock sysctl_treelock; 157 caddr_t sysctl_memaddr; 158 size_t sysctl_memsize; 159 160 /* 161 * Attributes stored in the kernel. 162 */ 163 char hostname[MAXHOSTNAMELEN]; 164 int hostnamelen; 165 166 char domainname[MAXHOSTNAMELEN]; 167 int domainnamelen; 168 169 long hostid; 170 171 #ifndef DEFCORENAME 172 #define DEFCORENAME "%n.core" 173 #endif 174 char defcorename[MAXPATHLEN] = DEFCORENAME; 175 176 /* 177 * ******************************************************************** 178 * Section 0: Some simple glue 179 * ******************************************************************** 180 * By wrapping copyin(), copyout(), and copyinstr() like this, we can 181 * stop caring about who's calling us and simplify some code a bunch. 182 * ******************************************************************** 183 */ 184 static inline int 185 sysctl_copyin(struct lwp *l, const void *uaddr, void *kaddr, size_t len) 186 { 187 int error; 188 189 if (l != NULL) { 190 error = copyin(uaddr, kaddr, len); 191 #ifdef KTRACE 192 if (!error && KTRPOINT(l->l_proc, KTR_MIB)) { 193 struct iovec iov; 194 195 iov.iov_base = (void *)(vaddr_t)uaddr; 196 iov.iov_len = len; 197 ktrgenio(l, -1, UIO_WRITE, &iov, len, error); 198 } 199 #endif 200 201 } else { 202 error = kcopy(uaddr, kaddr, len); 203 } 204 205 return error; 206 } 207 208 static inline int 209 sysctl_copyout(struct lwp *l, const void *kaddr, void *uaddr, size_t len) 210 { 211 int error; 212 213 if (l != NULL) { 214 error = copyout(kaddr, uaddr, len); 215 #ifdef KTRACE 216 if (!error && KTRPOINT(l->l_proc, KTR_MIB)) { 217 struct iovec iov; 218 219 iov.iov_base = (void *)(vaddr_t)uaddr; 220 iov.iov_len = len; 221 ktrgenio(l, -1, UIO_READ, &iov, len, error); 222 } 223 #endif 224 } else { 225 error = kcopy(kaddr, uaddr, len); 226 } 227 228 return error; 229 } 230 231 static inline int 232 sysctl_copyinstr(struct lwp *l, const void *uaddr, void *kaddr, 233 size_t len, size_t *done) 234 { 235 int error; 236 237 if (l != NULL) { 238 error = copyinstr(uaddr, kaddr, len, done); 239 #ifdef KTRACE 240 if (!error && KTRPOINT(l->l_proc, KTR_MIB)) { 241 struct iovec iov; 242 243 iov.iov_base = (void *)(vaddr_t)uaddr; 244 iov.iov_len = len; 245 ktrgenio(l, -1, UIO_WRITE, &iov, len, error); 246 } 247 #endif 248 } else { 249 error = copystr(uaddr, kaddr, len, done); 250 } 251 252 return error; 253 } 254 255 /* 256 * ******************************************************************** 257 * Initialize sysctl subsystem. 258 * ******************************************************************** 259 */ 260 void 261 sysctl_init(void) 262 { 263 sysctl_setup_func * const *sysctl_setup, f; 264 265 lockinit(&sysctl_treelock, PRIBIO|PCATCH, "sysctl", 0, 0); 266 267 /* 268 * dynamic mib numbers start here 269 */ 270 sysctl_root.sysctl_num = CREATE_BASE; 271 272 __link_set_foreach(sysctl_setup, sysctl_funcs) { 273 /* 274 * XXX - why do i have to coerce the pointers like this? 275 */ 276 f = (void*)*sysctl_setup; 277 (*f)(NULL); 278 } 279 280 /* 281 * setting this means no more permanent nodes can be added, 282 * trees that claim to be readonly at the root now are, and if 283 * the main tree is readonly, *everything* is. 284 */ 285 sysctl_root.sysctl_flags |= CTLFLAG_PERMANENT; 286 287 } 288 289 /* 290 * ******************************************************************** 291 * The main native sysctl system call itself. 292 * ******************************************************************** 293 */ 294 int 295 sys___sysctl(struct lwp *l, void *v, register_t *retval __unused) 296 { 297 struct sys___sysctl_args /* { 298 syscallarg(const int *) name; 299 syscallarg(u_int) namelen; 300 syscallarg(void *) old; 301 syscallarg(size_t *) oldlenp; 302 syscallarg(const void *) new; 303 syscallarg(size_t) newlen; 304 } */ *uap = v; 305 int error, nerror, name[CTL_MAXNAME]; 306 size_t oldlen, savelen, *oldlenp; 307 308 /* 309 * get oldlen 310 */ 311 oldlen = 0; 312 oldlenp = SCARG(uap, oldlenp); 313 if (oldlenp != NULL) { 314 error = copyin(oldlenp, &oldlen, sizeof(oldlen)); 315 if (error) 316 return (error); 317 } 318 savelen = oldlen; 319 320 /* 321 * top-level sysctl names may or may not be non-terminal, but 322 * we don't care 323 */ 324 if (SCARG(uap, namelen) > CTL_MAXNAME || SCARG(uap, namelen) < 1) 325 return (EINVAL); 326 error = copyin(SCARG(uap, name), &name, 327 SCARG(uap, namelen) * sizeof(int)); 328 if (error) 329 return (error); 330 331 #ifdef KTRACE 332 if (KTRPOINT(l->l_proc, KTR_MIB)) 333 ktrmib(l, name, SCARG(uap, namelen)); 334 #endif 335 /* 336 * wire old so that copyout() is less likely to fail? 337 */ 338 error = sysctl_lock(l, SCARG(uap, old), savelen); 339 if (error) 340 return (error); 341 342 /* 343 * do sysctl work (NULL means main built-in default tree) 344 */ 345 error = sysctl_dispatch(&name[0], SCARG(uap, namelen), 346 SCARG(uap, old), &oldlen, 347 SCARG(uap, new), SCARG(uap, newlen), 348 &name[0], l, NULL); 349 350 /* 351 * release the sysctl lock 352 */ 353 sysctl_unlock(l); 354 355 /* 356 * set caller's oldlen to new value even in the face of an 357 * error (if this gets an error and they didn't have one, they 358 * get this one) 359 */ 360 if (oldlenp) { 361 nerror = copyout(&oldlen, oldlenp, sizeof(oldlen)); 362 if (error == 0) 363 error = nerror; 364 } 365 366 /* 367 * if the only problem is that we weren't given enough space, 368 * that's an ENOMEM error 369 */ 370 if (error == 0 && SCARG(uap, old) != NULL && savelen < oldlen) 371 error = ENOMEM; 372 373 return (error); 374 } 375 376 /* 377 * ******************************************************************** 378 * Section 1: How the tree is used 379 * ******************************************************************** 380 * Implementations of sysctl for emulations should typically need only 381 * these three functions in this order: lock the tree, dispatch 382 * request into it, unlock the tree. 383 * ******************************************************************** 384 */ 385 int 386 sysctl_lock(struct lwp *l, void *oldp, size_t savelen) 387 { 388 int error = 0; 389 390 error = lockmgr(&sysctl_treelock, LK_EXCLUSIVE, NULL); 391 if (error) 392 return (error); 393 394 if (l != NULL && oldp != NULL && savelen) { 395 396 /* 397 * be lazy - memory is locked for short time only, so 398 * just do a basic check against system limit 399 */ 400 401 if (uvmexp.wired + atop(savelen) > uvmexp.wiredmax) { 402 lockmgr(&sysctl_treelock, LK_RELEASE, NULL); 403 return (ENOMEM); 404 } 405 error = uvm_vslock(l->l_proc->p_vmspace, oldp, savelen, 406 VM_PROT_WRITE); 407 if (error) { 408 (void) lockmgr(&sysctl_treelock, LK_RELEASE, NULL); 409 return (error); 410 } 411 sysctl_memaddr = oldp; 412 sysctl_memsize = savelen; 413 } 414 415 return (0); 416 } 417 418 /* 419 * ******************************************************************** 420 * the main sysctl dispatch routine. scans the given tree and picks a 421 * function to call based on what it finds. 422 * ******************************************************************** 423 */ 424 int 425 sysctl_dispatch(SYSCTLFN_ARGS) 426 { 427 int error; 428 sysctlfn fn; 429 int ni; 430 431 if (rnode && SYSCTL_VERS(rnode->sysctl_flags) != SYSCTL_VERSION) { 432 printf("sysctl_dispatch: rnode %p wrong version\n", rnode); 433 error = EINVAL; 434 goto out; 435 } 436 437 fn = NULL; 438 error = sysctl_locate(l, name, namelen, &rnode, &ni); 439 440 if (rnode->sysctl_func != NULL) { 441 /* 442 * the node we ended up at has a function, so call it. it can 443 * hand off to query or create if it wants to. 444 */ 445 fn = rnode->sysctl_func; 446 } else if (error == 0) { 447 /* 448 * we found the node they were looking for, so do a lookup. 449 */ 450 fn = (sysctlfn)sysctl_lookup; /* XXX may write to rnode */ 451 } else if (error == ENOENT && (ni + 1) == namelen && name[ni] < 0) { 452 /* 453 * prospective parent node found, but the terminal node was 454 * not. generic operations associate with the parent. 455 */ 456 switch (name[ni]) { 457 case CTL_QUERY: 458 fn = sysctl_query; 459 break; 460 case CTL_CREATE: 461 #if NKSYMS > 0 462 case CTL_CREATESYM: 463 #endif /* NKSYMS > 0 */ 464 fn = (sysctlfn)sysctl_create; /* we own the rnode */ 465 break; 466 case CTL_DESTROY: 467 fn = (sysctlfn)sysctl_destroy; /* we own the rnode */ 468 break; 469 case CTL_MMAP: 470 fn = (sysctlfn)sysctl_mmap; /* we own the rnode */ 471 break; 472 case CTL_DESCRIBE: 473 fn = sysctl_describe; 474 break; 475 default: 476 error = EOPNOTSUPP; 477 break; 478 } 479 } 480 481 /* 482 * after all of that, maybe we found someone who knows how to 483 * get us what we want? 484 */ 485 if (fn != NULL) 486 error = (*fn)(name + ni, namelen - ni, oldp, oldlenp, 487 newp, newlen, name, l, rnode); 488 else if (error == 0) 489 error = EOPNOTSUPP; 490 491 out: 492 return (error); 493 } 494 495 /* 496 * ******************************************************************** 497 * Releases the tree lock. Note that if uvm_vslock() was called when 498 * the lock was taken, we release that memory now. By keeping track 499 * of where and how much by ourselves, the lock can be released much 500 * more easily from anywhere. 501 * ******************************************************************** 502 */ 503 void 504 sysctl_unlock(struct lwp *l) 505 { 506 507 if (l != NULL && sysctl_memsize != 0) { 508 uvm_vsunlock(l->l_proc->p_vmspace, sysctl_memaddr, 509 sysctl_memsize); 510 sysctl_memsize = 0; 511 } 512 513 (void) lockmgr(&sysctl_treelock, LK_RELEASE, NULL); 514 } 515 516 /* 517 * ******************************************************************** 518 * Section 2: The main tree interfaces 519 * ******************************************************************** 520 * This is how sysctl_dispatch() does its work, and you can too, by 521 * calling these routines from helpers (though typically only 522 * sysctl_lookup() will be used). The tree MUST BE LOCKED when these 523 * are called. 524 * ******************************************************************** 525 */ 526 527 /* 528 * sysctl_locate -- Finds the node matching the given mib under the 529 * given tree (via rv). If no tree is given, we fall back to the 530 * native tree. The current process (via l) is used for access 531 * control on the tree (some nodes may be traversable only by root) and 532 * on return, nip will show how many numbers in the mib were consumed. 533 */ 534 int 535 sysctl_locate(struct lwp *l, const int *name, u_int namelen, 536 const struct sysctlnode **rnode, int *nip) 537 { 538 const struct sysctlnode *node, *pnode; 539 int tn, si, ni, error, alias; 540 541 /* 542 * basic checks and setup 543 */ 544 if (*rnode == NULL) 545 *rnode = &sysctl_root; 546 if (nip) 547 *nip = 0; 548 if (namelen == 0) 549 return (0); 550 551 /* 552 * search starts from "root" 553 */ 554 pnode = *rnode; 555 if (SYSCTL_VERS(pnode->sysctl_flags) != SYSCTL_VERSION) { 556 printf("sysctl_locate: pnode %p wrong version\n", pnode); 557 return (EINVAL); 558 } 559 node = pnode->sysctl_child; 560 error = 0; 561 562 /* 563 * scan for node to which new node should be attached 564 */ 565 for (ni = 0; ni < namelen; ni++) { 566 /* 567 * walked off bottom of tree 568 */ 569 if (node == NULL) { 570 if (SYSCTL_TYPE(pnode->sysctl_flags) == CTLTYPE_NODE) 571 error = ENOENT; 572 else 573 error = ENOTDIR; 574 break; 575 } 576 /* 577 * can anyone traverse this node or only root? 578 */ 579 if (l != NULL && (pnode->sysctl_flags & CTLFLAG_PRIVATE) && 580 (error = kauth_authorize_system(l->l_cred, 581 KAUTH_SYSTEM_SYSCTL, KAUTH_REQ_SYSTEM_SYSCTL_PRVT, 582 NULL, NULL, NULL)) != 0) 583 return (error); 584 /* 585 * find a child node with the right number 586 */ 587 tn = name[ni]; 588 alias = 0; 589 590 si = 0; 591 /* 592 * Note: ANYNUMBER only matches positive integers. 593 * Since ANYNUMBER is only permitted on single-node 594 * sub-trees (eg proc), check before the loop and skip 595 * it if we can. 596 */ 597 if ((node[si].sysctl_flags & CTLFLAG_ANYNUMBER) && (tn >= 0)) 598 goto foundit; 599 for (; si < pnode->sysctl_clen; si++) { 600 if (node[si].sysctl_num == tn) { 601 if (node[si].sysctl_flags & CTLFLAG_ALIAS) { 602 if (alias++ == 4) 603 break; 604 else { 605 tn = node[si].sysctl_alias; 606 si = -1; 607 } 608 } else 609 goto foundit; 610 } 611 } 612 /* 613 * if we ran off the end, it obviously doesn't exist 614 */ 615 error = ENOENT; 616 break; 617 618 /* 619 * so far so good, move on down the line 620 */ 621 foundit: 622 pnode = &node[si]; 623 if (SYSCTL_TYPE(pnode->sysctl_flags) == CTLTYPE_NODE) 624 node = node[si].sysctl_child; 625 else 626 node = NULL; 627 } 628 629 *rnode = pnode; 630 if (nip) 631 *nip = ni; 632 633 return (error); 634 } 635 636 /* 637 * sysctl_query -- The auto-discovery engine. Copies out the structs 638 * describing nodes under the given node and handles overlay trees. 639 */ 640 int 641 sysctl_query(SYSCTLFN_ARGS) 642 { 643 int error, ni, elim, v; 644 size_t out, left, t; 645 const struct sysctlnode *enode, *onode; 646 struct sysctlnode qnode; 647 648 if (SYSCTL_VERS(rnode->sysctl_flags) != SYSCTL_VERSION) { 649 printf("sysctl_query: rnode %p wrong version\n", rnode); 650 return (EINVAL); 651 } 652 653 if (SYSCTL_TYPE(rnode->sysctl_flags) != CTLTYPE_NODE) 654 return (ENOTDIR); 655 if (namelen != 1 || name[0] != CTL_QUERY) 656 return (EINVAL); 657 658 error = 0; 659 out = 0; 660 left = *oldlenp; 661 elim = 0; 662 enode = NULL; 663 664 /* 665 * translate the given request to a current node 666 */ 667 error = sysctl_cvt_in(l, &v, newp, newlen, &qnode); 668 if (error) 669 return (error); 670 671 /* 672 * if the request specifies a version, check it 673 */ 674 if (qnode.sysctl_ver != 0) { 675 enode = rnode; 676 if (qnode.sysctl_ver != enode->sysctl_ver && 677 qnode.sysctl_ver != sysctl_rootof(enode)->sysctl_ver) 678 return (EINVAL); 679 } 680 681 /* 682 * process has overlay tree 683 */ 684 if (l && l->l_proc->p_emul->e_sysctlovly) { 685 enode = l->l_proc->p_emul->e_sysctlovly; 686 elim = (name - oname); 687 error = sysctl_locate(l, oname, elim, &enode, NULL); 688 if (error == 0) { 689 /* ah, found parent in overlay */ 690 elim = enode->sysctl_clen; 691 enode = enode->sysctl_child; 692 } else { 693 error = 0; 694 elim = 0; 695 enode = NULL; 696 } 697 } 698 699 for (ni = 0; ni < rnode->sysctl_clen; ni++) { 700 onode = &rnode->sysctl_child[ni]; 701 if (enode && enode->sysctl_num == onode->sysctl_num) { 702 if (SYSCTL_TYPE(enode->sysctl_flags) != CTLTYPE_NODE) 703 onode = enode; 704 if (--elim > 0) 705 enode++; 706 else 707 enode = NULL; 708 } 709 error = sysctl_cvt_out(l, v, onode, oldp, left, &t); 710 if (error) 711 return (error); 712 if (oldp != NULL) 713 oldp = (char*)oldp + t; 714 out += t; 715 left -= MIN(left, t); 716 } 717 718 /* 719 * overlay trees *MUST* be entirely consumed 720 */ 721 KASSERT(enode == NULL); 722 723 *oldlenp = out; 724 725 return (error); 726 } 727 728 /* 729 * sysctl_create -- Adds a node (the description of which is taken 730 * from newp) to the tree, returning a copy of it in the space pointed 731 * to by oldp. In the event that the requested slot is already taken 732 * (either by name or by number), the offending node is returned 733 * instead. Yes, this is complex, but we want to make sure everything 734 * is proper. 735 */ 736 #ifdef SYSCTL_DEBUG_CREATE 737 int _sysctl_create(SYSCTLFN_ARGS); 738 int 739 _sysctl_create(SYSCTLFN_ARGS) 740 #else 741 int 742 sysctl_create(SYSCTLFN_ARGS) 743 #endif 744 { 745 struct sysctlnode nnode, *node, *pnode; 746 int error, ni, at, nm, type, sz, flags, anum, v; 747 void *own; 748 749 error = 0; 750 own = NULL; 751 anum = -1; 752 753 if (SYSCTL_VERS(rnode->sysctl_flags) != SYSCTL_VERSION) { 754 printf("sysctl_create: rnode %p wrong version\n", rnode); 755 return (EINVAL); 756 } 757 758 if (namelen != 1 || (name[namelen - 1] != CTL_CREATE 759 #if NKSYMS > 0 760 && name[namelen - 1] != CTL_CREATESYM 761 #endif /* NKSYMS > 0 */ 762 )) 763 return (EINVAL); 764 765 /* 766 * processes can only add nodes at securelevel 0, must be 767 * root, and can't add nodes to a parent that's not writeable 768 */ 769 if (l != NULL) { 770 #ifndef SYSCTL_DISALLOW_CREATE 771 error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_SYSCTL, 772 KAUTH_REQ_SYSTEM_SYSCTL_ADD, NULL, NULL, NULL); 773 if (error) 774 return (error); 775 if (!(rnode->sysctl_flags & CTLFLAG_READWRITE)) 776 #endif /* SYSCTL_DISALLOW_CREATE */ 777 return (EPERM); 778 } 779 780 /* 781 * nothing can add a node if: 782 * we've finished initial set up and 783 * the tree itself is not writeable or 784 * the entire sysctl system is not writeable 785 */ 786 if ((sysctl_root.sysctl_flags & CTLFLAG_PERMANENT) && 787 (!(sysctl_rootof(rnode)->sysctl_flags & CTLFLAG_READWRITE) || 788 !(sysctl_root.sysctl_flags & CTLFLAG_READWRITE))) 789 return (EPERM); 790 791 /* 792 * it must be a "node", not a "int" or something 793 */ 794 if (SYSCTL_TYPE(rnode->sysctl_flags) != CTLTYPE_NODE) 795 return (ENOTDIR); 796 if (rnode->sysctl_flags & CTLFLAG_ALIAS) { 797 printf("sysctl_create: attempt to add node to aliased " 798 "node %p\n", rnode); 799 return (EINVAL); 800 } 801 pnode = __UNCONST(rnode); /* we are adding children to this node */ 802 803 if (newp == NULL) 804 return (EINVAL); 805 error = sysctl_cvt_in(l, &v, newp, newlen, &nnode); 806 if (error) 807 return (error); 808 809 /* 810 * nodes passed in don't *have* parents 811 */ 812 if (nnode.sysctl_parent != NULL) 813 return (EINVAL); 814 815 /* 816 * if we are indeed adding it, it should be a "good" name and 817 * number 818 */ 819 nm = nnode.sysctl_num; 820 #if NKSYMS > 0 821 if (nm == CTL_CREATESYM) 822 nm = CTL_CREATE; 823 #endif /* NKSYMS > 0 */ 824 if (nm < 0 && nm != CTL_CREATE) 825 return (EINVAL); 826 sz = 0; 827 828 /* 829 * the name can't start with a digit 830 */ 831 if (nnode.sysctl_name[sz] >= '0' && 832 nnode.sysctl_name[sz] <= '9') 833 return (EINVAL); 834 835 /* 836 * the name must be only alphanumerics or - or _, longer than 837 * 0 bytes and less that SYSCTL_NAMELEN 838 */ 839 while (sz < SYSCTL_NAMELEN && nnode.sysctl_name[sz] != '\0') { 840 if ((nnode.sysctl_name[sz] >= '0' && 841 nnode.sysctl_name[sz] <= '9') || 842 (nnode.sysctl_name[sz] >= 'A' && 843 nnode.sysctl_name[sz] <= 'Z') || 844 (nnode.sysctl_name[sz] >= 'a' && 845 nnode.sysctl_name[sz] <= 'z') || 846 nnode.sysctl_name[sz] == '-' || 847 nnode.sysctl_name[sz] == '_') 848 sz++; 849 else 850 return (EINVAL); 851 } 852 if (sz == 0 || sz == SYSCTL_NAMELEN) 853 return (EINVAL); 854 855 /* 856 * various checks revolve around size vs type, etc 857 */ 858 type = SYSCTL_TYPE(nnode.sysctl_flags); 859 flags = SYSCTL_FLAGS(nnode.sysctl_flags); 860 sz = nnode.sysctl_size; 861 862 /* 863 * find out if there's a collision, and if so, let the caller 864 * know what they collided with 865 */ 866 node = pnode->sysctl_child; 867 at = 0; 868 if (node) { 869 if ((flags | node->sysctl_flags) & CTLFLAG_ANYNUMBER) 870 /* No siblings for a CTLFLAG_ANYNUMBER node */ 871 return EINVAL; 872 for (ni = 0; ni < pnode->sysctl_clen; ni++) { 873 if (nm == node[ni].sysctl_num || 874 strcmp(nnode.sysctl_name, node[ni].sysctl_name) == 0) { 875 /* 876 * ignore error here, since we 877 * are already fixed on EEXIST 878 */ 879 (void)sysctl_cvt_out(l, v, &node[ni], oldp, 880 *oldlenp, oldlenp); 881 return (EEXIST); 882 } 883 if (nm > node[ni].sysctl_num) 884 at++; 885 } 886 } 887 888 /* 889 * use sysctl_ver to add to the tree iff it hasn't changed 890 */ 891 if (nnode.sysctl_ver != 0) { 892 /* 893 * a specified value must match either the parent 894 * node's version or the root node's version 895 */ 896 if (nnode.sysctl_ver != sysctl_rootof(rnode)->sysctl_ver && 897 nnode.sysctl_ver != rnode->sysctl_ver) { 898 return (EINVAL); 899 } 900 } 901 902 /* 903 * only the kernel can assign functions to entries 904 */ 905 if (l != NULL && nnode.sysctl_func != NULL) 906 return (EPERM); 907 908 /* 909 * only the kernel can create permanent entries, and only then 910 * before the kernel is finished setting itself up 911 */ 912 if (l != NULL && (flags & ~SYSCTL_USERFLAGS)) 913 return (EPERM); 914 if ((flags & CTLFLAG_PERMANENT) & 915 (sysctl_root.sysctl_flags & CTLFLAG_PERMANENT)) 916 return (EPERM); 917 if ((flags & (CTLFLAG_OWNDATA | CTLFLAG_IMMEDIATE)) == 918 (CTLFLAG_OWNDATA | CTLFLAG_IMMEDIATE)) 919 return (EINVAL); 920 if ((flags & CTLFLAG_IMMEDIATE) && 921 type != CTLTYPE_INT && type != CTLTYPE_QUAD) 922 return (EINVAL); 923 924 /* 925 * check size, or set it if unset and we can figure it out. 926 * kernel created nodes are allowed to have a function instead 927 * of a size (or a data pointer). 928 */ 929 switch (type) { 930 case CTLTYPE_NODE: 931 /* 932 * only *i* can assert the size of a node 933 */ 934 if (flags & CTLFLAG_ALIAS) { 935 anum = nnode.sysctl_alias; 936 if (anum < 0) 937 return (EINVAL); 938 nnode.sysctl_alias = 0; 939 } 940 if (sz != 0 || nnode.sysctl_data != NULL) 941 return (EINVAL); 942 if (nnode.sysctl_csize != 0 || 943 nnode.sysctl_clen != 0 || 944 nnode.sysctl_child != 0) 945 return (EINVAL); 946 if (flags & CTLFLAG_OWNDATA) 947 return (EINVAL); 948 sz = sizeof(struct sysctlnode); 949 break; 950 case CTLTYPE_INT: 951 /* 952 * since an int is an int, if the size is not given or 953 * is wrong, we can "int-uit" it. 954 */ 955 if (sz != 0 && sz != sizeof(int)) 956 return (EINVAL); 957 sz = sizeof(int); 958 break; 959 case CTLTYPE_STRING: 960 /* 961 * strings are a little more tricky 962 */ 963 if (sz == 0) { 964 if (l == NULL) { 965 if (nnode.sysctl_func == NULL) { 966 if (nnode.sysctl_data == NULL) 967 return (EINVAL); 968 else 969 sz = strlen(nnode.sysctl_data) + 970 1; 971 } 972 } else if (nnode.sysctl_data == NULL && 973 flags & CTLFLAG_OWNDATA) { 974 return (EINVAL); 975 } else { 976 char *vp, *e; 977 size_t s; 978 979 /* 980 * we want a rough idea of what the 981 * size is now 982 */ 983 vp = malloc(PAGE_SIZE, M_SYSCTLDATA, 984 M_WAITOK|M_CANFAIL); 985 if (vp == NULL) 986 return (ENOMEM); 987 e = nnode.sysctl_data; 988 do { 989 error = copyinstr(e, vp, PAGE_SIZE, &s); 990 if (error) { 991 if (error != ENAMETOOLONG) { 992 free(vp, M_SYSCTLDATA); 993 return (error); 994 } 995 e += PAGE_SIZE; 996 if ((e - 32 * PAGE_SIZE) > 997 (char*)nnode.sysctl_data) { 998 free(vp, M_SYSCTLDATA); 999 return (ERANGE); 1000 } 1001 } 1002 } while (error != 0); 1003 sz = s + (e - (char*)nnode.sysctl_data); 1004 free(vp, M_SYSCTLDATA); 1005 } 1006 } 1007 break; 1008 case CTLTYPE_QUAD: 1009 if (sz != 0 && sz != sizeof(u_quad_t)) 1010 return (EINVAL); 1011 sz = sizeof(u_quad_t); 1012 break; 1013 case CTLTYPE_STRUCT: 1014 if (sz == 0) { 1015 if (l != NULL || nnode.sysctl_func == NULL) 1016 return (EINVAL); 1017 if (flags & CTLFLAG_OWNDATA) 1018 return (EINVAL); 1019 } 1020 break; 1021 default: 1022 return (EINVAL); 1023 } 1024 1025 /* 1026 * at this point, if sz is zero, we *must* have a 1027 * function to go with it and we can't own it. 1028 */ 1029 1030 /* 1031 * l ptr own 1032 * 0 0 0 -> EINVAL (if no func) 1033 * 0 0 1 -> own 1034 * 0 1 0 -> kptr 1035 * 0 1 1 -> kptr 1036 * 1 0 0 -> EINVAL 1037 * 1 0 1 -> own 1038 * 1 1 0 -> kptr, no own (fault on lookup) 1039 * 1 1 1 -> uptr, own 1040 */ 1041 if (type != CTLTYPE_NODE) { 1042 if (sz != 0) { 1043 if (flags & CTLFLAG_OWNDATA) { 1044 own = malloc(sz, M_SYSCTLDATA, 1045 M_WAITOK|M_CANFAIL); 1046 if (own == NULL) 1047 return ENOMEM; 1048 if (nnode.sysctl_data == NULL) 1049 memset(own, 0, sz); 1050 else { 1051 error = sysctl_copyin(l, 1052 nnode.sysctl_data, own, sz); 1053 if (error != 0) { 1054 free(own, M_SYSCTLDATA); 1055 return (error); 1056 } 1057 } 1058 } else if ((nnode.sysctl_data != NULL) && 1059 !(flags & CTLFLAG_IMMEDIATE)) { 1060 #if NKSYMS > 0 1061 if (name[namelen - 1] == CTL_CREATESYM) { 1062 char symname[128]; /* XXX enough? */ 1063 u_long symaddr; 1064 size_t symlen; 1065 1066 error = sysctl_copyinstr(l, 1067 nnode.sysctl_data, symname, 1068 sizeof(symname), &symlen); 1069 if (error) 1070 return (error); 1071 error = ksyms_getval(NULL, symname, 1072 &symaddr, KSYMS_EXTERN); 1073 if (error) 1074 return (error); /* EINVAL? */ 1075 nnode.sysctl_data = (void*)symaddr; 1076 } 1077 #endif /* NKSYMS > 0 */ 1078 /* 1079 * Ideally, we'd like to verify here 1080 * that this address is acceptable, 1081 * but... 1082 * 1083 * - it might be valid now, only to 1084 * become invalid later 1085 * 1086 * - it might be invalid only for the 1087 * moment and valid later 1088 * 1089 * - or something else. 1090 * 1091 * Since we can't get a good answer, 1092 * we'll just accept the address as 1093 * given, and fault on individual 1094 * lookups. 1095 */ 1096 } 1097 } else if (nnode.sysctl_func == NULL) 1098 return (EINVAL); 1099 } 1100 1101 /* 1102 * a process can't assign a function to a node, and the kernel 1103 * can't create a node that has no function or data. 1104 * (XXX somewhat redundant check) 1105 */ 1106 if (l != NULL || nnode.sysctl_func == NULL) { 1107 if (type != CTLTYPE_NODE && 1108 nnode.sysctl_data == NULL && 1109 !(flags & CTLFLAG_IMMEDIATE) && 1110 own == NULL) 1111 return (EINVAL); 1112 } 1113 1114 #ifdef SYSCTL_DISALLOW_KWRITE 1115 /* 1116 * a process can't create a writable node unless it refers to 1117 * new data. 1118 */ 1119 if (l != NULL && own == NULL && type != CTLTYPE_NODE && 1120 (flags & CTLFLAG_READWRITE) != CTLFLAG_READONLY && 1121 !(flags & CTLFLAG_IMMEDIATE)) 1122 return (EPERM); 1123 #endif /* SYSCTL_DISALLOW_KWRITE */ 1124 1125 /* 1126 * make sure there's somewhere to put the new stuff. 1127 */ 1128 if (pnode->sysctl_child == NULL) { 1129 if (flags & CTLFLAG_ANYNUMBER) 1130 error = sysctl_alloc(pnode, 1); 1131 else 1132 error = sysctl_alloc(pnode, 0); 1133 if (error) { 1134 if (own != NULL) 1135 free(own, M_SYSCTLDATA); 1136 return (error); 1137 } 1138 } 1139 node = pnode->sysctl_child; 1140 1141 /* 1142 * no collisions, so pick a good dynamic number if we need to. 1143 */ 1144 if (nm == CTL_CREATE) { 1145 nm = ++sysctl_root.sysctl_num; 1146 for (ni = 0; ni < pnode->sysctl_clen; ni++) { 1147 if (nm == node[ni].sysctl_num) { 1148 nm++; 1149 ni = -1; 1150 } else if (nm > node[ni].sysctl_num) 1151 at = ni + 1; 1152 } 1153 } 1154 1155 /* 1156 * oops...ran out of space 1157 */ 1158 if (pnode->sysctl_clen == pnode->sysctl_csize) { 1159 error = sysctl_realloc(pnode); 1160 if (error) { 1161 if (own != NULL) 1162 free(own, M_SYSCTLDATA); 1163 return (error); 1164 } 1165 node = pnode->sysctl_child; 1166 } 1167 1168 /* 1169 * insert new node data 1170 */ 1171 if (at < pnode->sysctl_clen) { 1172 int t; 1173 1174 /* 1175 * move the nodes that should come after the new one 1176 */ 1177 memmove(&node[at + 1], &node[at], 1178 (pnode->sysctl_clen - at) * sizeof(struct sysctlnode)); 1179 memset(&node[at], 0, sizeof(struct sysctlnode)); 1180 node[at].sysctl_parent = pnode; 1181 /* 1182 * and...reparent any children of any moved nodes 1183 */ 1184 for (ni = at; ni <= pnode->sysctl_clen; ni++) 1185 if (SYSCTL_TYPE(node[ni].sysctl_flags) == CTLTYPE_NODE) 1186 for (t = 0; t < node[ni].sysctl_clen; t++) 1187 node[ni].sysctl_child[t].sysctl_parent = 1188 &node[ni]; 1189 } 1190 node = &node[at]; 1191 pnode->sysctl_clen++; 1192 1193 strlcpy(node->sysctl_name, nnode.sysctl_name, 1194 sizeof(node->sysctl_name)); 1195 node->sysctl_num = nm; 1196 node->sysctl_size = sz; 1197 node->sysctl_flags = SYSCTL_VERSION|type|flags; /* XXX other trees */ 1198 node->sysctl_csize = 0; 1199 node->sysctl_clen = 0; 1200 if (own) { 1201 node->sysctl_data = own; 1202 node->sysctl_flags |= CTLFLAG_OWNDATA; 1203 } else if (flags & CTLFLAG_ALIAS) { 1204 node->sysctl_alias = anum; 1205 } else if (flags & CTLFLAG_IMMEDIATE) { 1206 switch (type) { 1207 case CTLTYPE_INT: 1208 node->sysctl_idata = nnode.sysctl_idata; 1209 break; 1210 case CTLTYPE_QUAD: 1211 node->sysctl_qdata = nnode.sysctl_qdata; 1212 break; 1213 } 1214 } else { 1215 node->sysctl_data = nnode.sysctl_data; 1216 node->sysctl_flags &= ~CTLFLAG_OWNDATA; 1217 } 1218 node->sysctl_func = nnode.sysctl_func; 1219 node->sysctl_child = NULL; 1220 /* node->sysctl_parent should already be done */ 1221 1222 /* 1223 * update "version" on path to "root" 1224 */ 1225 for (; rnode->sysctl_parent != NULL; rnode = rnode->sysctl_parent) 1226 ; 1227 pnode = node; 1228 for (nm = rnode->sysctl_ver + 1; pnode != NULL; 1229 pnode = pnode->sysctl_parent) 1230 pnode->sysctl_ver = nm; 1231 1232 /* If this fails, the node is already added - the user won't know! */ 1233 error = sysctl_cvt_out(l, v, node, oldp, *oldlenp, oldlenp); 1234 1235 return (error); 1236 } 1237 1238 /* 1239 * ******************************************************************** 1240 * A wrapper around sysctl_create() that prints the thing we're trying 1241 * to add. 1242 * ******************************************************************** 1243 */ 1244 #ifdef SYSCTL_DEBUG_CREATE 1245 int 1246 sysctl_create(SYSCTLFN_ARGS) 1247 { 1248 const struct sysctlnode *node; 1249 int k, rc, ni, nl = namelen + (name - oname); 1250 1251 node = newp; 1252 1253 printf("namelen %d (", nl); 1254 for (ni = 0; ni < nl - 1; ni++) 1255 printf(" %d", oname[ni]); 1256 printf(" %d )\t[%s]\tflags %08x (%08x %d %zu)\n", 1257 k = node->sysctl_num, 1258 node->sysctl_name, 1259 node->sysctl_flags, 1260 SYSCTL_FLAGS(node->sysctl_flags), 1261 SYSCTL_TYPE(node->sysctl_flags), 1262 node->sysctl_size); 1263 1264 node = rnode; 1265 rc = _sysctl_create(SYSCTLFN_CALL(rnode)); 1266 1267 printf("sysctl_create("); 1268 for (ni = 0; ni < nl - 1; ni++) 1269 printf(" %d", oname[ni]); 1270 printf(" %d ) returned %d\n", k, rc); 1271 1272 return (rc); 1273 } 1274 #endif /* SYSCTL_DEBUG_CREATE */ 1275 1276 /* 1277 * sysctl_destroy -- Removes a node (as described by newp) from the 1278 * given tree, returning (if successful) a copy of the dead node in 1279 * oldp. Since we're removing stuff, there's not much to check. 1280 */ 1281 int 1282 sysctl_destroy(SYSCTLFN_ARGS) 1283 { 1284 struct sysctlnode *node, *pnode, onode, nnode; 1285 int ni, error, v; 1286 1287 if (SYSCTL_VERS(rnode->sysctl_flags) != SYSCTL_VERSION) { 1288 printf("sysctl_destroy: rnode %p wrong version\n", rnode); 1289 return (EINVAL); 1290 } 1291 1292 error = 0; 1293 1294 if (namelen != 1 || name[namelen - 1] != CTL_DESTROY) 1295 return (EINVAL); 1296 1297 /* 1298 * processes can only destroy nodes at securelevel 0, must be 1299 * root, and can't remove nodes from a parent that's not 1300 * writeable 1301 */ 1302 if (l != NULL) { 1303 #ifndef SYSCTL_DISALLOW_CREATE 1304 error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_SYSCTL, 1305 KAUTH_REQ_SYSTEM_SYSCTL_DELETE, NULL, NULL, NULL); 1306 if (error) 1307 return (error); 1308 if (!(rnode->sysctl_flags & CTLFLAG_READWRITE)) 1309 #endif /* SYSCTL_DISALLOW_CREATE */ 1310 return (EPERM); 1311 } 1312 1313 /* 1314 * nothing can remove a node if: 1315 * the node is permanent (checked later) or 1316 * the tree itself is not writeable or 1317 * the entire sysctl system is not writeable 1318 * 1319 * note that we ignore whether setup is complete or not, 1320 * because these rules always apply. 1321 */ 1322 if (!(sysctl_rootof(rnode)->sysctl_flags & CTLFLAG_READWRITE) || 1323 !(sysctl_root.sysctl_flags & CTLFLAG_READWRITE)) 1324 return (EPERM); 1325 1326 if (newp == NULL) 1327 return (EINVAL); 1328 error = sysctl_cvt_in(l, &v, newp, newlen, &nnode); 1329 if (error) 1330 return (error); 1331 memset(&onode, 0, sizeof(struct sysctlnode)); 1332 1333 node = rnode->sysctl_child; 1334 for (ni = 0; ni < rnode->sysctl_clen; ni++) { 1335 if (nnode.sysctl_num == node[ni].sysctl_num) { 1336 /* 1337 * if name specified, must match 1338 */ 1339 if (nnode.sysctl_name[0] != '\0' && 1340 strcmp(nnode.sysctl_name, node[ni].sysctl_name)) 1341 continue; 1342 /* 1343 * if version specified, must match 1344 */ 1345 if (nnode.sysctl_ver != 0 && 1346 nnode.sysctl_ver != node[ni].sysctl_ver) 1347 continue; 1348 /* 1349 * this must be the one 1350 */ 1351 break; 1352 } 1353 } 1354 if (ni == rnode->sysctl_clen) 1355 return (ENOENT); 1356 node = &node[ni]; 1357 pnode = node->sysctl_parent; 1358 1359 /* 1360 * if the kernel says permanent, it is, so there. nyah. 1361 */ 1362 if (SYSCTL_FLAGS(node->sysctl_flags) & CTLFLAG_PERMANENT) 1363 return (EPERM); 1364 1365 /* 1366 * can't delete non-empty nodes 1367 */ 1368 if (SYSCTL_TYPE(node->sysctl_flags) == CTLTYPE_NODE && 1369 node->sysctl_clen != 0) 1370 return (ENOTEMPTY); 1371 1372 /* 1373 * if the node "owns" data, release it now 1374 */ 1375 if (node->sysctl_flags & CTLFLAG_OWNDATA) { 1376 if (node->sysctl_data != NULL) 1377 free(node->sysctl_data, M_SYSCTLDATA); 1378 node->sysctl_data = NULL; 1379 } 1380 if (node->sysctl_flags & CTLFLAG_OWNDESC) { 1381 if (node->sysctl_desc != NULL) 1382 /*XXXUNCONST*/ 1383 free(__UNCONST(node->sysctl_desc), M_SYSCTLDATA); 1384 node->sysctl_desc = NULL; 1385 } 1386 1387 /* 1388 * if the node to be removed is not the last one on the list, 1389 * move the remaining nodes up, and reparent any grandchildren 1390 */ 1391 onode = *node; 1392 if (ni < pnode->sysctl_clen - 1) { 1393 int t; 1394 1395 memmove(&pnode->sysctl_child[ni], &pnode->sysctl_child[ni + 1], 1396 (pnode->sysctl_clen - ni - 1) * 1397 sizeof(struct sysctlnode)); 1398 for (; ni < pnode->sysctl_clen - 1; ni++) 1399 if (SYSCTL_TYPE(pnode->sysctl_child[ni].sysctl_flags) == 1400 CTLTYPE_NODE) 1401 for (t = 0; 1402 t < pnode->sysctl_child[ni].sysctl_clen; 1403 t++) 1404 pnode->sysctl_child[ni].sysctl_child[t]. 1405 sysctl_parent = 1406 &pnode->sysctl_child[ni]; 1407 ni = pnode->sysctl_clen - 1; 1408 node = &pnode->sysctl_child[ni]; 1409 } 1410 1411 /* 1412 * reset the space we just vacated 1413 */ 1414 memset(node, 0, sizeof(struct sysctlnode)); 1415 node->sysctl_parent = pnode; 1416 pnode->sysctl_clen--; 1417 1418 /* 1419 * if this parent just lost its last child, nuke the creche 1420 */ 1421 if (pnode->sysctl_clen == 0) { 1422 free(pnode->sysctl_child, M_SYSCTLNODE); 1423 pnode->sysctl_csize = 0; 1424 pnode->sysctl_child = NULL; 1425 } 1426 1427 /* 1428 * update "version" on path to "root" 1429 */ 1430 for (; rnode->sysctl_parent != NULL; rnode = rnode->sysctl_parent) 1431 ; 1432 for (ni = rnode->sysctl_ver + 1; pnode != NULL; 1433 pnode = pnode->sysctl_parent) 1434 pnode->sysctl_ver = ni; 1435 1436 error = sysctl_cvt_out(l, v, &onode, oldp, *oldlenp, oldlenp); 1437 1438 return (error); 1439 } 1440 1441 /* 1442 * sysctl_lookup -- Handles copyin/copyout of new and old values. 1443 * Partial reads are globally allowed. Only root can write to things 1444 * unless the node says otherwise. 1445 */ 1446 int 1447 sysctl_lookup(SYSCTLFN_ARGS) 1448 { 1449 int error, rw; 1450 size_t sz, len; 1451 void *d; 1452 1453 if (SYSCTL_VERS(rnode->sysctl_flags) != SYSCTL_VERSION) { 1454 printf("sysctl_lookup: rnode %p wrong version\n", rnode); 1455 return (EINVAL); 1456 } 1457 1458 error = 0; 1459 1460 /* 1461 * you can't "look up" a node. you can "query" it, but you 1462 * can't "look it up". 1463 */ 1464 if (SYSCTL_TYPE(rnode->sysctl_flags) == CTLTYPE_NODE || namelen != 0) 1465 return (EINVAL); 1466 1467 /* 1468 * some nodes are private, so only root can look into them. 1469 */ 1470 if (l != NULL && (rnode->sysctl_flags & CTLFLAG_PRIVATE) && 1471 (error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_SYSCTL, 1472 KAUTH_REQ_SYSTEM_SYSCTL_PRVT, NULL, NULL, NULL)) != 0) 1473 return (error); 1474 1475 /* 1476 * if a node wants to be writable according to different rules 1477 * other than "only root can write to stuff unless a flag is 1478 * set", then it needs its own function which should have been 1479 * called and not us. 1480 */ 1481 if (l != NULL && newp != NULL && 1482 !(rnode->sysctl_flags & CTLFLAG_ANYWRITE) && 1483 (error = kauth_authorize_generic(l->l_cred, 1484 KAUTH_GENERIC_ISSUSER, &l->l_acflag)) != 0) 1485 return (error); 1486 1487 /* 1488 * is this node supposedly writable? 1489 */ 1490 rw = (rnode->sysctl_flags & CTLFLAG_READWRITE) ? 1 : 0; 1491 1492 /* 1493 * it appears not to be writable at this time, so if someone 1494 * tried to write to it, we must tell them to go away 1495 */ 1496 if (!rw && newp != NULL) 1497 return (EPERM); 1498 1499 /* 1500 * step one, copy out the stuff we have presently 1501 */ 1502 if (rnode->sysctl_flags & CTLFLAG_IMMEDIATE) { 1503 /* 1504 * note that we discard const here because we are 1505 * modifying the contents of the node (which is okay 1506 * because it's ours) 1507 */ 1508 switch (SYSCTL_TYPE(rnode->sysctl_flags)) { 1509 case CTLTYPE_INT: 1510 d = __UNCONST(&rnode->sysctl_idata); 1511 break; 1512 case CTLTYPE_QUAD: 1513 d = __UNCONST(&rnode->sysctl_qdata); 1514 break; 1515 default: 1516 return (EINVAL); 1517 } 1518 } else 1519 d = rnode->sysctl_data; 1520 if (SYSCTL_TYPE(rnode->sysctl_flags) == CTLTYPE_STRING) 1521 sz = strlen(d) + 1; /* XXX@@@ possible fault here */ 1522 else 1523 sz = rnode->sysctl_size; 1524 if (oldp != NULL) 1525 error = sysctl_copyout(l, d, oldp, MIN(sz, *oldlenp)); 1526 if (error) 1527 return (error); 1528 *oldlenp = sz; 1529 1530 /* 1531 * are we done? 1532 */ 1533 if (newp == NULL || newlen == 0) 1534 return (0); 1535 1536 /* 1537 * hmm...not done. must now "copy in" new value. re-adjust 1538 * sz to maximum value (strings are "weird"). 1539 */ 1540 sz = rnode->sysctl_size; 1541 switch (SYSCTL_TYPE(rnode->sysctl_flags)) { 1542 case CTLTYPE_INT: 1543 case CTLTYPE_QUAD: 1544 case CTLTYPE_STRUCT: 1545 /* 1546 * these data must be *exactly* the same size coming 1547 * in. 1548 */ 1549 if (newlen != sz) 1550 return (EINVAL); 1551 error = sysctl_copyin(l, newp, d, sz); 1552 break; 1553 case CTLTYPE_STRING: { 1554 /* 1555 * strings, on the other hand, can be shorter, and we 1556 * let userland be sloppy about the trailing nul. 1557 */ 1558 char *newbuf; 1559 1560 /* 1561 * too much new string? 1562 */ 1563 if (newlen > sz) 1564 return (EINVAL); 1565 1566 /* 1567 * temporary copy of new inbound string 1568 */ 1569 len = MIN(sz, newlen); 1570 newbuf = malloc(len, M_SYSCTLDATA, M_WAITOK|M_CANFAIL); 1571 if (newbuf == NULL) 1572 return (ENOMEM); 1573 error = sysctl_copyin(l, newp, newbuf, len); 1574 if (error) { 1575 free(newbuf, M_SYSCTLDATA); 1576 return (error); 1577 } 1578 1579 /* 1580 * did they null terminate it, or do we have space 1581 * left to do it ourselves? 1582 */ 1583 if (newbuf[len - 1] != '\0' && len == sz) { 1584 free(newbuf, M_SYSCTLDATA); 1585 return (EINVAL); 1586 } 1587 1588 /* 1589 * looks good, so pop it into place and zero the rest. 1590 */ 1591 if (len > 0) 1592 memcpy(d, newbuf, len); 1593 if (sz != len) 1594 memset((char*)d + len, 0, sz - len); 1595 free(newbuf, M_SYSCTLDATA); 1596 break; 1597 } 1598 default: 1599 return (EINVAL); 1600 } 1601 1602 return (error); 1603 } 1604 1605 /* 1606 * sysctl_mmap -- Dispatches sysctl mmap requests to those nodes that 1607 * purport to handle it. This interface isn't fully fleshed out yet, 1608 * unfortunately. 1609 */ 1610 static int 1611 sysctl_mmap(SYSCTLFN_ARGS) 1612 { 1613 const struct sysctlnode *node; 1614 struct sysctlnode nnode; 1615 int error; 1616 1617 if (SYSCTL_VERS(rnode->sysctl_flags) != SYSCTL_VERSION) { 1618 printf("sysctl_mmap: rnode %p wrong version\n", rnode); 1619 return (EINVAL); 1620 } 1621 1622 /* 1623 * let's just pretend that didn't happen, m'kay? 1624 */ 1625 if (l == NULL) 1626 return (EPERM); 1627 1628 /* 1629 * is this a sysctlnode description of an mmap request? 1630 */ 1631 if (newp == NULL || newlen != sizeof(struct sysctlnode)) 1632 return (EINVAL); 1633 error = sysctl_copyin(l, newp, &nnode, sizeof(nnode)); 1634 if (error) 1635 return (error); 1636 1637 /* 1638 * does the node they asked for exist? 1639 */ 1640 if (namelen != 1) 1641 return (EOPNOTSUPP); 1642 node = rnode; 1643 error = sysctl_locate(l, &nnode.sysctl_num, 1, &node, NULL); 1644 if (error) 1645 return (error); 1646 1647 /* 1648 * does this node that we have found purport to handle mmap? 1649 */ 1650 if (node->sysctl_func == NULL || 1651 !(node->sysctl_flags & CTLFLAG_MMAP)) 1652 return (EOPNOTSUPP); 1653 1654 /* 1655 * well...okay, they asked for it. 1656 */ 1657 return ((*node->sysctl_func)(SYSCTLFN_CALL(node))); 1658 } 1659 1660 int 1661 sysctl_describe(SYSCTLFN_ARGS) 1662 { 1663 struct sysctldesc *d; 1664 void *bf; 1665 size_t sz, left, tot; 1666 int i, error, v = -1; 1667 struct sysctlnode *node; 1668 struct sysctlnode dnode; 1669 1670 if (SYSCTL_VERS(rnode->sysctl_flags) != SYSCTL_VERSION) { 1671 printf("sysctl_query: rnode %p wrong version\n", rnode); 1672 return (EINVAL); 1673 } 1674 1675 if (SYSCTL_TYPE(rnode->sysctl_flags) != CTLTYPE_NODE) 1676 return (ENOTDIR); 1677 if (namelen != 1 || name[0] != CTL_DESCRIBE) 1678 return (EINVAL); 1679 1680 /* 1681 * get ready... 1682 */ 1683 error = 0; 1684 d = bf = malloc(MAXDESCLEN, M_TEMP, M_WAITOK|M_CANFAIL); 1685 if (bf == NULL) 1686 return ENOMEM; 1687 tot = 0; 1688 node = rnode->sysctl_child; 1689 left = *oldlenp; 1690 1691 /* 1692 * no request -> all descriptions at this level 1693 * request with desc unset -> just this node 1694 * request with desc set -> set descr for this node 1695 */ 1696 if (newp != NULL) { 1697 error = sysctl_cvt_in(l, &v, newp, newlen, &dnode); 1698 if (error) 1699 goto out; 1700 if (dnode.sysctl_desc != NULL) { 1701 /* 1702 * processes cannot set descriptions above 1703 * securelevel 0. and must be root. blah 1704 * blah blah. a couple more checks are made 1705 * once we find the node we want. 1706 */ 1707 if (l != NULL) { 1708 #ifndef SYSCTL_DISALLOW_CREATE 1709 error = kauth_authorize_system(l->l_cred, 1710 KAUTH_SYSTEM_SYSCTL, 1711 KAUTH_REQ_SYSTEM_SYSCTL_DESC, NULL, 1712 NULL, NULL); 1713 if (error) 1714 goto out; 1715 #else /* SYSCTL_DISALLOW_CREATE */ 1716 error = EPERM; 1717 goto out; 1718 #endif /* SYSCTL_DISALLOW_CREATE */ 1719 } 1720 1721 /* 1722 * find node and try to set the description on it 1723 */ 1724 for (i = 0; i < rnode->sysctl_clen; i++) 1725 if (node[i].sysctl_num == dnode.sysctl_num) 1726 break; 1727 if (i == rnode->sysctl_clen) { 1728 error = ENOENT; 1729 goto out; 1730 } 1731 node = &node[i]; 1732 1733 /* 1734 * did the caller specify a node version? 1735 */ 1736 if (dnode.sysctl_ver != 0 && 1737 dnode.sysctl_ver != node->sysctl_ver) { 1738 error = EINVAL; 1739 goto out; 1740 } 1741 1742 /* 1743 * okay...some rules: 1744 * (1) if setup is done and the tree is 1745 * read-only or the whole system is 1746 * read-only 1747 * (2) no one can set a description on a 1748 * permanent node (it must be set when 1749 * using createv) 1750 * (3) processes cannot *change* a description 1751 * (4) processes *can*, however, set a 1752 * description on a read-only node so that 1753 * one can be created and then described 1754 * in two steps 1755 * anything else come to mind? 1756 */ 1757 if ((sysctl_root.sysctl_flags & CTLFLAG_PERMANENT) && 1758 (!(sysctl_rootof(node)->sysctl_flags & 1759 CTLFLAG_READWRITE) || 1760 !(sysctl_root.sysctl_flags & CTLFLAG_READWRITE))) { 1761 error = EPERM; 1762 goto out; 1763 } 1764 if (node->sysctl_flags & CTLFLAG_PERMANENT) { 1765 error = EPERM; 1766 goto out; 1767 } 1768 if (l != NULL && node->sysctl_desc != NULL) { 1769 error = EPERM; 1770 goto out; 1771 } 1772 1773 /* 1774 * right, let's go ahead. the first step is 1775 * making the description into something the 1776 * node can "own", if need be. 1777 */ 1778 if (l != NULL || 1779 dnode.sysctl_flags & CTLFLAG_OWNDESC) { 1780 char *nd, *k; 1781 1782 k = malloc(MAXDESCLEN, M_TEMP, 1783 M_WAITOK|M_CANFAIL); 1784 if (k == NULL) { 1785 error = ENOMEM; 1786 goto out; 1787 } 1788 error = sysctl_copyinstr(l, dnode.sysctl_desc, 1789 k, MAXDESCLEN, &sz); 1790 if (error) { 1791 free(k, M_TEMP); 1792 goto out; 1793 } 1794 nd = malloc(sz, M_SYSCTLDATA, 1795 M_WAITOK|M_CANFAIL); 1796 if (nd == NULL) { 1797 free(k, M_TEMP); 1798 error = ENOMEM; 1799 goto out; 1800 } 1801 memcpy(nd, k, sz); 1802 dnode.sysctl_flags |= CTLFLAG_OWNDESC; 1803 dnode.sysctl_desc = nd; 1804 free(k, M_TEMP); 1805 } 1806 1807 /* 1808 * now "release" the old description and 1809 * attach the new one. ta-da. 1810 */ 1811 if ((node->sysctl_flags & CTLFLAG_OWNDESC) && 1812 node->sysctl_desc != NULL) 1813 /*XXXUNCONST*/ 1814 free(__UNCONST(node->sysctl_desc), M_SYSCTLDATA); 1815 node->sysctl_desc = dnode.sysctl_desc; 1816 node->sysctl_flags |= 1817 (dnode.sysctl_flags & CTLFLAG_OWNDESC); 1818 1819 /* 1820 * now we "fall out" and into the loop which 1821 * will copy the new description back out for 1822 * those interested parties 1823 */ 1824 } 1825 } 1826 1827 /* 1828 * scan for one description or just retrieve all descriptions 1829 */ 1830 for (i = 0; i < rnode->sysctl_clen; i++) { 1831 /* 1832 * did they ask for the description of only one node? 1833 */ 1834 if (v != -1 && node[i].sysctl_num != dnode.sysctl_num) 1835 continue; 1836 1837 /* 1838 * don't describe "private" nodes to non-suser users 1839 */ 1840 if ((node[i].sysctl_flags & CTLFLAG_PRIVATE) && (l != NULL) && 1841 !(kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_SYSCTL, 1842 KAUTH_REQ_SYSTEM_SYSCTL_PRVT, NULL, NULL, NULL))) 1843 continue; 1844 1845 /* 1846 * is this description "valid"? 1847 */ 1848 memset(bf, 0, MAXDESCLEN); 1849 if (node[i].sysctl_desc == NULL) 1850 sz = 1; 1851 else if (copystr(node[i].sysctl_desc, &d->descr_str[0], 1852 MAXDESCLEN - sizeof(*d), &sz) != 0) { 1853 /* 1854 * erase possible partial description 1855 */ 1856 memset(bf, 0, MAXDESCLEN); 1857 sz = 1; 1858 } 1859 1860 /* 1861 * we've got it, stuff it into the caller's buffer 1862 */ 1863 d->descr_num = node[i].sysctl_num; 1864 d->descr_ver = node[i].sysctl_ver; 1865 d->descr_len = sz; /* includes trailing nul */ 1866 sz = (caddr_t)NEXT_DESCR(d) - (caddr_t)d; 1867 if (oldp != NULL && left >= sz) { 1868 error = sysctl_copyout(l, d, oldp, sz); 1869 if (error) 1870 goto out; 1871 left -= sz; 1872 oldp = (void *)__sysc_desc_adv(oldp, d->descr_len); 1873 } 1874 tot += sz; 1875 1876 /* 1877 * if we get this far with v not "unset", they asked 1878 * for a specific node and we found it 1879 */ 1880 if (v != -1) 1881 break; 1882 } 1883 1884 /* 1885 * did we find it after all? 1886 */ 1887 if (v != -1 && tot == 0) 1888 error = ENOENT; 1889 else 1890 *oldlenp = tot; 1891 1892 out: 1893 free(bf, M_TEMP); 1894 return (error); 1895 } 1896 1897 /* 1898 * ******************************************************************** 1899 * Section 3: Create and destroy from inside the kernel 1900 * ******************************************************************** 1901 * sysctl_createv() and sysctl_destroyv() are simpler-to-use 1902 * interfaces for the kernel to fling new entries into the mib and rip 1903 * them out later. In the case of sysctl_createv(), the returned copy 1904 * of the node (see sysctl_create()) will be translated back into a 1905 * pointer to the actual node. 1906 * 1907 * Note that sysctl_createv() will return 0 if the create request 1908 * matches an existing node (ala mkdir -p), and that sysctl_destroyv() 1909 * will return 0 if the node to be destroyed already does not exist 1910 * (aka rm -f) or if it is a parent of other nodes. 1911 * 1912 * This allows two (or more) different subsystems to assert sub-tree 1913 * existence before populating their own nodes, and to remove their 1914 * own nodes without orphaning the others when they are done. 1915 * ******************************************************************** 1916 */ 1917 int 1918 sysctl_createv(struct sysctllog **log, int cflags, 1919 const struct sysctlnode **rnode, const struct sysctlnode **cnode, 1920 int flags, int type, const char *namep, const char *descr, 1921 sysctlfn func, u_quad_t qv, void *newp, size_t newlen, 1922 ...) 1923 { 1924 va_list ap; 1925 int error, ni, namelen, name[CTL_MAXNAME]; 1926 const struct sysctlnode *root, *pnode; 1927 struct sysctlnode nnode, onode, *dnode; 1928 size_t sz; 1929 1930 /* 1931 * where are we putting this? 1932 */ 1933 if (rnode != NULL && *rnode == NULL) { 1934 printf("sysctl_createv: rnode NULL\n"); 1935 return (EINVAL); 1936 } 1937 root = rnode ? *rnode : NULL; 1938 if (cnode != NULL) 1939 *cnode = NULL; 1940 if (cflags != 0) 1941 return (EINVAL); 1942 1943 /* 1944 * what is it? 1945 */ 1946 flags = SYSCTL_VERSION|SYSCTL_TYPE(type)|SYSCTL_FLAGS(flags); 1947 if (log != NULL) 1948 flags &= ~CTLFLAG_PERMANENT; 1949 1950 /* 1951 * where do we put it? 1952 */ 1953 va_start(ap, newlen); 1954 namelen = 0; 1955 ni = -1; 1956 do { 1957 if (++ni == CTL_MAXNAME) 1958 return (ENAMETOOLONG); 1959 name[ni] = va_arg(ap, int); 1960 /* 1961 * sorry, this is not supported from here 1962 */ 1963 if (name[ni] == CTL_CREATESYM) 1964 return (EINVAL); 1965 } while (name[ni] != CTL_EOL && name[ni] != CTL_CREATE); 1966 namelen = ni + (name[ni] == CTL_CREATE ? 1 : 0); 1967 va_end(ap); 1968 1969 /* 1970 * what's it called 1971 */ 1972 if (strlcpy(nnode.sysctl_name, namep, sizeof(nnode.sysctl_name)) >= 1973 sizeof(nnode.sysctl_name)) 1974 return (ENAMETOOLONG); 1975 1976 /* 1977 * cons up the description of the new node 1978 */ 1979 nnode.sysctl_num = name[namelen - 1]; 1980 name[namelen - 1] = CTL_CREATE; 1981 nnode.sysctl_size = newlen; 1982 nnode.sysctl_flags = flags; 1983 if (type == CTLTYPE_NODE) { 1984 nnode.sysctl_csize = 0; 1985 nnode.sysctl_clen = 0; 1986 nnode.sysctl_child = NULL; 1987 if (flags & CTLFLAG_ALIAS) 1988 nnode.sysctl_alias = qv; 1989 } else if (flags & CTLFLAG_IMMEDIATE) { 1990 switch (type) { 1991 case CTLTYPE_INT: 1992 nnode.sysctl_idata = qv; 1993 break; 1994 case CTLTYPE_QUAD: 1995 nnode.sysctl_qdata = qv; 1996 break; 1997 default: 1998 return (EINVAL); 1999 } 2000 } else { 2001 nnode.sysctl_data = newp; 2002 } 2003 nnode.sysctl_func = func; 2004 nnode.sysctl_parent = NULL; 2005 nnode.sysctl_ver = 0; 2006 2007 /* 2008 * initialize lock state -- we need locks if the main tree has 2009 * been marked as complete, but since we could be called from 2010 * either there, or from a device driver (say, at device 2011 * insertion), or from an lkm (at lkm load time, say), we 2012 * don't really want to "wait"... 2013 */ 2014 error = sysctl_lock(NULL, NULL, 0); 2015 if (error) 2016 return (error); 2017 2018 /* 2019 * locate the prospective parent of the new node, and if we 2020 * find it, add the new node. 2021 */ 2022 sz = sizeof(onode); 2023 pnode = root; 2024 error = sysctl_locate(NULL, &name[0], namelen - 1, &pnode, &ni); 2025 if (error) { 2026 printf("sysctl_createv: sysctl_locate(%s) returned %d\n", 2027 nnode.sysctl_name, error); 2028 sysctl_unlock(NULL); 2029 return (error); 2030 } 2031 error = sysctl_create(&name[ni], namelen - ni, &onode, &sz, 2032 &nnode, sizeof(nnode), &name[0], NULL, 2033 pnode); 2034 2035 /* 2036 * unfortunately the node we wanted to create is already 2037 * there. if the node that's already there is a reasonable 2038 * facsimile of the node we wanted to create, just pretend 2039 * (for the caller's benefit) that we managed to create the 2040 * node they wanted. 2041 */ 2042 if (error == EEXIST) { 2043 /* name is the same as requested... */ 2044 if (strcmp(nnode.sysctl_name, onode.sysctl_name) == 0 && 2045 /* they want the same function... */ 2046 nnode.sysctl_func == onode.sysctl_func && 2047 /* number is the same as requested, or... */ 2048 (nnode.sysctl_num == onode.sysctl_num || 2049 /* they didn't pick a number... */ 2050 nnode.sysctl_num == CTL_CREATE)) { 2051 /* 2052 * collision here from trying to create 2053 * something that already existed; let's give 2054 * our customers a hand and tell them they got 2055 * what they wanted. 2056 */ 2057 #ifdef SYSCTL_DEBUG_CREATE 2058 printf("cleared\n"); 2059 #endif /* SYSCTL_DEBUG_CREATE */ 2060 error = 0; 2061 } 2062 } 2063 2064 if (error == 0 && 2065 (cnode != NULL || log != NULL || descr != NULL)) { 2066 /* 2067 * sysctl_create() gave us back a copy of the node, 2068 * but we need to know where it actually is... 2069 */ 2070 pnode = root; 2071 error = sysctl_locate(NULL, &name[0], namelen - 1, &pnode, &ni); 2072 2073 /* 2074 * manual scan of last layer so that aliased nodes 2075 * aren't followed. 2076 */ 2077 if (error == 0) { 2078 for (ni = 0; ni < pnode->sysctl_clen; ni++) 2079 if (pnode->sysctl_child[ni].sysctl_num == 2080 onode.sysctl_num) 2081 break; 2082 if (ni < pnode->sysctl_clen) 2083 pnode = &pnode->sysctl_child[ni]; 2084 else 2085 error = ENOENT; 2086 } 2087 2088 /* 2089 * not expecting an error here, but... 2090 */ 2091 if (error == 0) { 2092 if (log != NULL) 2093 sysctl_log_add(log, pnode); 2094 if (cnode != NULL) 2095 *cnode = pnode; 2096 if (descr != NULL) { 2097 /* 2098 * allow first caller to *set* a 2099 * description actually to set it 2100 * 2101 * discard const here so we can attach 2102 * the description 2103 */ 2104 dnode = __UNCONST(pnode); 2105 if (pnode->sysctl_desc != NULL) 2106 /* skip it...we've got one */; 2107 else if (flags & CTLFLAG_OWNDESC) { 2108 size_t l = strlen(descr) + 1; 2109 char *d = malloc(l, M_SYSCTLDATA, 2110 M_WAITOK|M_CANFAIL); 2111 if (d != NULL) { 2112 memcpy(d, descr, l); 2113 dnode->sysctl_desc = d; 2114 dnode->sysctl_flags |= 2115 CTLFLAG_OWNDESC; 2116 } 2117 } else 2118 dnode->sysctl_desc = descr; 2119 } 2120 } else { 2121 printf("sysctl_create succeeded but node not found?!\n"); 2122 /* 2123 * confusing, but the create said it 2124 * succeeded, so... 2125 */ 2126 error = 0; 2127 } 2128 } 2129 2130 /* 2131 * now it should be safe to release the lock state. note that 2132 * the pointer to the newly created node being passed back may 2133 * not be "good" for very long. 2134 */ 2135 sysctl_unlock(NULL); 2136 2137 if (error != 0) { 2138 printf("sysctl_createv: sysctl_create(%s) returned %d\n", 2139 nnode.sysctl_name, error); 2140 #if 0 2141 if (error != ENOENT) 2142 sysctl_dump(&onode); 2143 #endif 2144 } 2145 2146 return (error); 2147 } 2148 2149 int 2150 sysctl_destroyv(struct sysctlnode *rnode, ...) 2151 { 2152 va_list ap; 2153 int error, name[CTL_MAXNAME], namelen, ni; 2154 const struct sysctlnode *pnode, *node; 2155 struct sysctlnode dnode, *onode; 2156 size_t sz; 2157 2158 va_start(ap, rnode); 2159 namelen = 0; 2160 ni = 0; 2161 do { 2162 if (ni == CTL_MAXNAME) 2163 return (ENAMETOOLONG); 2164 name[ni] = va_arg(ap, int); 2165 } while (name[ni++] != CTL_EOL); 2166 namelen = ni - 1; 2167 va_end(ap); 2168 2169 /* 2170 * i can't imagine why we'd be destroying a node when the tree 2171 * wasn't complete, but who knows? 2172 */ 2173 error = sysctl_lock(NULL, NULL, 0); 2174 if (error) 2175 return (error); 2176 2177 /* 2178 * where is it? 2179 */ 2180 node = rnode; 2181 error = sysctl_locate(NULL, &name[0], namelen - 1, &node, &ni); 2182 if (error) { 2183 /* they want it gone and it's not there, so... */ 2184 sysctl_unlock(NULL); 2185 return (error == ENOENT ? 0 : error); 2186 } 2187 2188 /* 2189 * set up the deletion 2190 */ 2191 pnode = node; 2192 node = &dnode; 2193 memset(&dnode, 0, sizeof(dnode)); 2194 dnode.sysctl_flags = SYSCTL_VERSION; 2195 dnode.sysctl_num = name[namelen - 1]; 2196 2197 /* 2198 * we found it, now let's nuke it 2199 */ 2200 name[namelen - 1] = CTL_DESTROY; 2201 sz = 0; 2202 error = sysctl_destroy(&name[namelen - 1], 1, NULL, &sz, 2203 node, sizeof(*node), &name[0], NULL, 2204 pnode); 2205 if (error == ENOTEMPTY) { 2206 /* 2207 * think of trying to delete "foo" when "foo.bar" 2208 * (which someone else put there) is still in 2209 * existence 2210 */ 2211 error = 0; 2212 2213 /* 2214 * dunno who put the description there, but if this 2215 * node can ever be removed, we need to make sure the 2216 * string doesn't go out of context. that means we 2217 * need to find the node that's still there (don't use 2218 * sysctl_locate() because that follows aliasing). 2219 */ 2220 node = pnode->sysctl_child; 2221 for (ni = 0; ni < pnode->sysctl_clen; ni++) 2222 if (node[ni].sysctl_num == dnode.sysctl_num) 2223 break; 2224 node = (ni < pnode->sysctl_clen) ? &node[ni] : NULL; 2225 2226 /* 2227 * if we found it, and this node has a description, 2228 * and this node can be released, and it doesn't 2229 * already own its own description...sigh. :) 2230 */ 2231 if (node != NULL && node->sysctl_desc != NULL && 2232 !(node->sysctl_flags & CTLFLAG_PERMANENT) && 2233 !(node->sysctl_flags & CTLFLAG_OWNDESC)) { 2234 char *d; 2235 2236 sz = strlen(node->sysctl_desc) + 1; 2237 d = malloc(sz, M_SYSCTLDATA, M_WAITOK|M_CANFAIL); 2238 if (d != NULL) { 2239 /* 2240 * discard const so that we can 2241 * re-attach the description 2242 */ 2243 memcpy(d, node->sysctl_desc, sz); 2244 onode = __UNCONST(node); 2245 onode->sysctl_desc = d; 2246 onode->sysctl_flags |= CTLFLAG_OWNDESC; 2247 } else { 2248 /* 2249 * XXX drop the description? be 2250 * afraid? don't care? 2251 */ 2252 } 2253 } 2254 } 2255 2256 sysctl_unlock(NULL); 2257 2258 return (error); 2259 } 2260 2261 #if 0 2262 /* 2263 * ******************************************************************** 2264 * the dump routine. i haven't yet decided how (if at all) i'll call 2265 * this from userland when it's in the kernel. 2266 * ******************************************************************** 2267 */ 2268 static const char * 2269 sf(int f) 2270 { 2271 static char s[256]; 2272 char *c; 2273 2274 s[0] = '\0'; 2275 c = ""; 2276 2277 #define print_flag(_f, _s, _c, _q, _x) \ 2278 if (((_f) & (__CONCAT(CTLFLAG_,_x))) == (__CONCAT(CTLFLAG_,_q))) { \ 2279 strlcat((_s), (_c), sizeof(_s)); \ 2280 strlcat((_s), __STRING(_q), sizeof(_s)); \ 2281 (_c) = ","; \ 2282 (_f) &= ~__CONCAT(CTLFLAG_,_x); \ 2283 } 2284 2285 print_flag(f, s, c, READONLY, READWRITE); 2286 print_flag(f, s, c, READWRITE, READWRITE); 2287 print_flag(f, s, c, ANYWRITE, ANYWRITE); 2288 print_flag(f, s, c, PRIVATE, PRIVATE); 2289 print_flag(f, s, c, PERMANENT, PERMANENT); 2290 print_flag(f, s, c, OWNDATA, OWNDATA); 2291 print_flag(f, s, c, IMMEDIATE, IMMEDIATE); 2292 print_flag(f, s, c, HEX, HEX); 2293 print_flag(f, s, c, ROOT, ROOT); 2294 print_flag(f, s, c, ANYNUMBER, ANYNUMBER); 2295 print_flag(f, s, c, HIDDEN, HIDDEN); 2296 print_flag(f, s, c, ALIAS, ALIAS); 2297 #undef print_flag 2298 2299 if (f) { 2300 char foo[9]; 2301 snprintf(foo, sizeof(foo), "%x", f); 2302 strlcat(s, c, sizeof(s)); 2303 strlcat(s, foo, sizeof(s)); 2304 } 2305 2306 return (s); 2307 } 2308 2309 static const char * 2310 st(int t) 2311 { 2312 2313 switch (t) { 2314 case CTLTYPE_NODE: 2315 return "NODE"; 2316 case CTLTYPE_INT: 2317 return "INT"; 2318 case CTLTYPE_STRING: 2319 return "STRING"; 2320 case CTLTYPE_QUAD: 2321 return "QUAD"; 2322 case CTLTYPE_STRUCT: 2323 return "STRUCT"; 2324 } 2325 2326 return "???"; 2327 } 2328 2329 void 2330 sysctl_dump(const struct sysctlnode *d) 2331 { 2332 static char nmib[64], smib[256]; 2333 static int indent; 2334 struct sysctlnode *n; 2335 char *np, *sp, tmp[20]; 2336 int i; 2337 2338 if (d == NULL) 2339 return; 2340 2341 np = &nmib[strlen(nmib)]; 2342 sp = &smib[strlen(smib)]; 2343 2344 if (!(d->sysctl_flags & CTLFLAG_ROOT)) { 2345 snprintf(tmp, sizeof(tmp), "%d", d->sysctl_num); 2346 strcat(nmib, "."); 2347 strcat(smib, "."); 2348 strcat(nmib, tmp); 2349 strcat(smib, d->sysctl_name); 2350 printf("%s -> %s (%d)\n", &nmib[1], &smib[1], 2351 SYSCTL_TYPE(d->sysctl_flags)); 2352 } 2353 2354 if (1) { 2355 printf("%*s%p:\tsysctl_name [%s]\n", indent, "", 2356 d, d->sysctl_name); 2357 printf("%*s\t\tsysctl_num %d\n", indent, "", 2358 d->sysctl_num); 2359 printf("%*s\t\tsysctl_flags %x (flags=%x<%s> type=%d<%s> " 2360 "size=%zu)\n", 2361 indent, "", d->sysctl_flags, 2362 SYSCTL_FLAGS(d->sysctl_flags), 2363 sf(SYSCTL_FLAGS(d->sysctl_flags)), 2364 SYSCTL_TYPE(d->sysctl_flags), 2365 st(SYSCTL_TYPE(d->sysctl_flags)), 2366 d->sysctl_size); 2367 if (SYSCTL_TYPE(d->sysctl_flags) == CTLTYPE_NODE) { 2368 printf("%*s\t\tsysctl_csize %d\n", indent, "", 2369 d->sysctl_csize); 2370 printf("%*s\t\tsysctl_clen %d\n", indent, "", 2371 d->sysctl_clen); 2372 printf("%*s\t\tsysctl_child %p\n", indent, "", 2373 d->sysctl_child); 2374 } else 2375 printf("%*s\t\tsysctl_data %p\n", indent, "", 2376 d->sysctl_data); 2377 printf("%*s\t\tsysctl_func %p\n", indent, "", 2378 d->sysctl_func); 2379 printf("%*s\t\tsysctl_parent %p\n", indent, "", 2380 d->sysctl_parent); 2381 printf("%*s\t\tsysctl_ver %d\n", indent, "", 2382 d->sysctl_ver); 2383 } 2384 2385 if (SYSCTL_TYPE(d->sysctl_flags) == CTLTYPE_NODE) { 2386 indent += 8; 2387 n = d->sysctl_child; 2388 for (i = 0; i < d->sysctl_clen; i++) { 2389 sysctl_dump(&n[i]); 2390 } 2391 indent -= 8; 2392 } 2393 2394 np[0] = '\0'; 2395 sp[0] = '\0'; 2396 } 2397 #endif /* 0 */ 2398 2399 /* 2400 * ******************************************************************** 2401 * Deletes an entire n-ary tree. Not recommended unless you know why 2402 * you're doing it. Personally, I don't know why you'd even think 2403 * about it. 2404 * ******************************************************************** 2405 */ 2406 void 2407 sysctl_free(struct sysctlnode *rnode) 2408 { 2409 struct sysctlnode *node, *pnode; 2410 2411 if (rnode == NULL) 2412 rnode = &sysctl_root; 2413 2414 if (SYSCTL_VERS(rnode->sysctl_flags) != SYSCTL_VERSION) { 2415 printf("sysctl_free: rnode %p wrong version\n", rnode); 2416 return; 2417 } 2418 2419 pnode = rnode; 2420 2421 node = pnode->sysctl_child; 2422 do { 2423 while (node != NULL && pnode->sysctl_csize > 0) { 2424 while (node < 2425 &pnode->sysctl_child[pnode->sysctl_clen] && 2426 (SYSCTL_TYPE(node->sysctl_flags) != 2427 CTLTYPE_NODE || 2428 node->sysctl_csize == 0)) { 2429 if (SYSCTL_FLAGS(node->sysctl_flags) & 2430 CTLFLAG_OWNDATA) { 2431 if (node->sysctl_data != NULL) { 2432 free(node->sysctl_data, 2433 M_SYSCTLDATA); 2434 node->sysctl_data = NULL; 2435 } 2436 } 2437 if (SYSCTL_FLAGS(node->sysctl_flags) & 2438 CTLFLAG_OWNDESC) { 2439 if (node->sysctl_desc != NULL) { 2440 /*XXXUNCONST*/ 2441 free(__UNCONST(node->sysctl_desc), 2442 M_SYSCTLDATA); 2443 node->sysctl_desc = NULL; 2444 } 2445 } 2446 node++; 2447 } 2448 if (node < &pnode->sysctl_child[pnode->sysctl_clen]) { 2449 pnode = node; 2450 node = node->sysctl_child; 2451 } else 2452 break; 2453 } 2454 if (pnode->sysctl_child != NULL) 2455 free(pnode->sysctl_child, M_SYSCTLNODE); 2456 pnode->sysctl_clen = 0; 2457 pnode->sysctl_csize = 0; 2458 pnode->sysctl_child = NULL; 2459 node = pnode; 2460 pnode = node->sysctl_parent; 2461 } while (pnode != NULL && node != rnode); 2462 } 2463 2464 int 2465 sysctl_log_add(struct sysctllog **logp, const struct sysctlnode *node) 2466 { 2467 int name[CTL_MAXNAME], namelen, i; 2468 const struct sysctlnode *pnode; 2469 struct sysctllog *log; 2470 2471 if (node->sysctl_flags & CTLFLAG_PERMANENT) 2472 return (0); 2473 2474 if (logp == NULL) 2475 return (0); 2476 2477 if (*logp == NULL) { 2478 log = malloc(sizeof(struct sysctllog), 2479 M_SYSCTLDATA, M_WAITOK|M_CANFAIL); 2480 if (log == NULL) { 2481 /* XXX print error message? */ 2482 return (-1); 2483 } 2484 log->log_num = malloc(16 * sizeof(int), 2485 M_SYSCTLDATA, M_WAITOK|M_CANFAIL); 2486 if (log->log_num == NULL) { 2487 /* XXX print error message? */ 2488 free(log, M_SYSCTLDATA); 2489 return (-1); 2490 } 2491 memset(log->log_num, 0, 16 * sizeof(int)); 2492 log->log_root = NULL; 2493 log->log_size = 16; 2494 log->log_left = 16; 2495 *logp = log; 2496 } else 2497 log = *logp; 2498 2499 /* 2500 * check that the root is proper. it's okay to record the 2501 * address of the root of a tree. it's the only thing that's 2502 * guaranteed not to shift around as nodes come and go. 2503 */ 2504 if (log->log_root == NULL) 2505 log->log_root = sysctl_rootof(node); 2506 else if (log->log_root != sysctl_rootof(node)) { 2507 printf("sysctl: log %p root mismatch (%p)\n", 2508 log->log_root, sysctl_rootof(node)); 2509 return (-1); 2510 } 2511 2512 /* 2513 * we will copy out name in reverse order 2514 */ 2515 for (pnode = node, namelen = 0; 2516 pnode != NULL && !(pnode->sysctl_flags & CTLFLAG_ROOT); 2517 pnode = pnode->sysctl_parent) 2518 name[namelen++] = pnode->sysctl_num; 2519 2520 /* 2521 * do we have space? 2522 */ 2523 if (log->log_left < (namelen + 3)) 2524 sysctl_log_realloc(log); 2525 if (log->log_left < (namelen + 3)) 2526 return (-1); 2527 2528 /* 2529 * stuff name in, then namelen, then node type, and finally, 2530 * the version for non-node nodes. 2531 */ 2532 for (i = 0; i < namelen; i++) 2533 log->log_num[--log->log_left] = name[i]; 2534 log->log_num[--log->log_left] = namelen; 2535 log->log_num[--log->log_left] = SYSCTL_TYPE(node->sysctl_flags); 2536 if (log->log_num[log->log_left] != CTLTYPE_NODE) 2537 log->log_num[--log->log_left] = node->sysctl_ver; 2538 else 2539 log->log_num[--log->log_left] = 0; 2540 2541 return (0); 2542 } 2543 2544 void 2545 sysctl_teardown(struct sysctllog **logp) 2546 { 2547 const struct sysctlnode *rnode; 2548 struct sysctlnode node; 2549 struct sysctllog *log; 2550 uint namelen; 2551 int *name, t, v, error, ni; 2552 size_t sz; 2553 2554 if (logp == NULL || *logp == NULL) 2555 return; 2556 log = *logp; 2557 2558 error = sysctl_lock(NULL, NULL, 0); 2559 if (error) 2560 return; 2561 2562 memset(&node, 0, sizeof(node)); 2563 2564 while (log->log_left < log->log_size) { 2565 KASSERT((log->log_left + 3 < log->log_size) && 2566 (log->log_left + log->log_num[log->log_left + 2] <= 2567 log->log_size)); 2568 v = log->log_num[log->log_left++]; 2569 t = log->log_num[log->log_left++]; 2570 namelen = log->log_num[log->log_left++]; 2571 name = &log->log_num[log->log_left]; 2572 2573 node.sysctl_num = name[namelen - 1]; 2574 node.sysctl_flags = SYSCTL_VERSION|t; 2575 node.sysctl_ver = v; 2576 2577 rnode = log->log_root; 2578 error = sysctl_locate(NULL, &name[0], namelen, &rnode, &ni); 2579 if (error == 0) { 2580 name[namelen - 1] = CTL_DESTROY; 2581 rnode = rnode->sysctl_parent; 2582 sz = 0; 2583 (void)sysctl_destroy(&name[namelen - 1], 1, NULL, 2584 &sz, &node, sizeof(node), 2585 &name[0], NULL, rnode); 2586 } 2587 2588 log->log_left += namelen; 2589 } 2590 2591 KASSERT(log->log_size == log->log_left); 2592 free(log->log_num, M_SYSCTLDATA); 2593 free(log, M_SYSCTLDATA); 2594 *logp = NULL; 2595 2596 sysctl_unlock(NULL); 2597 } 2598 2599 /* 2600 * ******************************************************************** 2601 * old_sysctl -- A routine to bridge old-style internal calls to the 2602 * new infrastructure. 2603 * ******************************************************************** 2604 */ 2605 int 2606 old_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, 2607 void *newp, size_t newlen, struct lwp *l) 2608 { 2609 int error; 2610 size_t oldlen = 0; 2611 size_t savelen; 2612 2613 if (oldlenp) { 2614 oldlen = *oldlenp; 2615 } 2616 savelen = oldlen; 2617 2618 error = sysctl_lock(l, oldp, savelen); 2619 if (error) 2620 return (error); 2621 error = sysctl_dispatch(name, namelen, oldp, &oldlen, 2622 newp, newlen, name, l, NULL); 2623 sysctl_unlock(l); 2624 if (error == 0 && oldp != NULL && savelen < oldlen) 2625 error = ENOMEM; 2626 2627 if (oldlenp) { 2628 *oldlenp = oldlen; 2629 } 2630 2631 return (error); 2632 } 2633 2634 /* 2635 * ******************************************************************** 2636 * Section 4: Generic helper routines 2637 * ******************************************************************** 2638 * "helper" routines that can do more finely grained access control, 2639 * construct structures from disparate information, create the 2640 * appearance of more nodes and sub-trees, etc. for example, if 2641 * CTL_PROC wanted a helper function, it could respond to a CTL_QUERY 2642 * with a dynamically created list of nodes that represented the 2643 * currently running processes at that instant. 2644 * ******************************************************************** 2645 */ 2646 2647 /* 2648 * first, a few generic helpers that provide: 2649 * 2650 * sysctl_needfunc() a readonly interface that emits a warning 2651 * sysctl_notavail() returns EOPNOTSUPP (generic error) 2652 * sysctl_null() an empty return buffer with no error 2653 */ 2654 int 2655 sysctl_needfunc(SYSCTLFN_ARGS) 2656 { 2657 int error; 2658 2659 printf("!!SYSCTL_NEEDFUNC!!\n"); 2660 2661 if (newp != NULL || namelen != 0) 2662 return (EOPNOTSUPP); 2663 2664 error = 0; 2665 if (oldp != NULL) 2666 error = sysctl_copyout(l, rnode->sysctl_data, oldp, 2667 MIN(rnode->sysctl_size, *oldlenp)); 2668 *oldlenp = rnode->sysctl_size; 2669 2670 return (error); 2671 } 2672 2673 int 2674 sysctl_notavail(SYSCTLFN_ARGS) 2675 { 2676 2677 if (namelen == 1 && name[0] == CTL_QUERY) 2678 return (sysctl_query(SYSCTLFN_CALL(rnode))); 2679 2680 return (EOPNOTSUPP); 2681 } 2682 2683 int 2684 sysctl_null(SYSCTLFN_ARGS) 2685 { 2686 2687 *oldlenp = 0; 2688 2689 return (0); 2690 } 2691 2692 /* 2693 * ******************************************************************** 2694 * Section 5: The machinery that makes it all go 2695 * ******************************************************************** 2696 * Memory "manglement" routines. Not much to this, eh? 2697 * ******************************************************************** 2698 */ 2699 static int 2700 sysctl_alloc(struct sysctlnode *p, int x) 2701 { 2702 int i; 2703 struct sysctlnode *n; 2704 2705 assert(p->sysctl_child == NULL); 2706 2707 if (x == 1) 2708 n = malloc(sizeof(struct sysctlnode), 2709 M_SYSCTLNODE, M_WAITOK|M_CANFAIL); 2710 else 2711 n = malloc(SYSCTL_DEFSIZE * sizeof(struct sysctlnode), 2712 M_SYSCTLNODE, M_WAITOK|M_CANFAIL); 2713 if (n == NULL) 2714 return (ENOMEM); 2715 2716 if (x == 1) { 2717 memset(n, 0, sizeof(struct sysctlnode)); 2718 p->sysctl_csize = 1; 2719 } else { 2720 memset(n, 0, SYSCTL_DEFSIZE * sizeof(struct sysctlnode)); 2721 p->sysctl_csize = SYSCTL_DEFSIZE; 2722 } 2723 p->sysctl_clen = 0; 2724 2725 for (i = 0; i < p->sysctl_csize; i++) 2726 n[i].sysctl_parent = p; 2727 2728 p->sysctl_child = n; 2729 return (0); 2730 } 2731 2732 static int 2733 sysctl_realloc(struct sysctlnode *p) 2734 { 2735 int i, j; 2736 struct sysctlnode *n; 2737 2738 assert(p->sysctl_csize == p->sysctl_clen); 2739 2740 /* 2741 * how many do we have...how many should we make? 2742 */ 2743 i = p->sysctl_clen; 2744 n = malloc(2 * i * sizeof(struct sysctlnode), M_SYSCTLNODE, 2745 M_WAITOK|M_CANFAIL); 2746 if (n == NULL) 2747 return (ENOMEM); 2748 2749 /* 2750 * move old children over...initialize new children 2751 */ 2752 memcpy(n, p->sysctl_child, i * sizeof(struct sysctlnode)); 2753 memset(&n[i], 0, i * sizeof(struct sysctlnode)); 2754 p->sysctl_csize = 2 * i; 2755 2756 /* 2757 * reattach moved (and new) children to parent; if a moved 2758 * child node has children, reattach the parent pointers of 2759 * grandchildren 2760 */ 2761 for (i = 0; i < p->sysctl_csize; i++) { 2762 n[i].sysctl_parent = p; 2763 if (n[i].sysctl_child != NULL) { 2764 for (j = 0; j < n[i].sysctl_csize; j++) 2765 n[i].sysctl_child[j].sysctl_parent = &n[i]; 2766 } 2767 } 2768 2769 /* 2770 * get out with the old and in with the new 2771 */ 2772 free(p->sysctl_child, M_SYSCTLNODE); 2773 p->sysctl_child = n; 2774 2775 return (0); 2776 } 2777 2778 static int 2779 sysctl_log_realloc(struct sysctllog *log) 2780 { 2781 int *n, s, d; 2782 2783 s = log->log_size * 2; 2784 d = log->log_size; 2785 2786 n = malloc(s * sizeof(int), M_SYSCTLDATA, M_WAITOK|M_CANFAIL); 2787 if (n == NULL) 2788 return (-1); 2789 2790 memset(n, 0, s * sizeof(int)); 2791 memcpy(&n[d], log->log_num, d * sizeof(int)); 2792 free(log->log_num, M_SYSCTLDATA); 2793 log->log_num = n; 2794 if (d) 2795 log->log_left += d; 2796 else 2797 log->log_left = s; 2798 log->log_size = s; 2799 2800 return (0); 2801 } 2802 2803 /* 2804 * ******************************************************************** 2805 * Section 6: Conversion between API versions wrt the sysctlnode 2806 * ******************************************************************** 2807 */ 2808 static int 2809 sysctl_cvt_in(struct lwp *l, int *vp, const void *i, size_t sz, 2810 struct sysctlnode *node) 2811 { 2812 int error, flags; 2813 2814 if (i == NULL || sz < sizeof(flags)) 2815 return (EINVAL); 2816 2817 error = sysctl_copyin(l, i, &flags, sizeof(flags)); 2818 if (error) 2819 return (error); 2820 2821 #if (SYSCTL_VERSION != SYSCTL_VERS_1) 2822 #error sysctl_cvt_in: no support for SYSCTL_VERSION 2823 #endif /* (SYSCTL_VERSION != SYSCTL_VERS_1) */ 2824 2825 if (sz == sizeof(*node) && 2826 SYSCTL_VERS(flags) == SYSCTL_VERSION) { 2827 error = sysctl_copyin(l, i, node, sizeof(*node)); 2828 if (error) 2829 return (error); 2830 *vp = SYSCTL_VERSION; 2831 return (0); 2832 } 2833 2834 return (EINVAL); 2835 } 2836 2837 static int 2838 sysctl_cvt_out(struct lwp *l, int v, const struct sysctlnode *i, 2839 void *ovp, size_t left, size_t *szp) 2840 { 2841 size_t sz = sizeof(*i); 2842 const void *src = i; 2843 int error; 2844 2845 switch (v) { 2846 case SYSCTL_VERS_0: 2847 return (EINVAL); 2848 2849 #if (SYSCTL_VERSION != SYSCTL_VERS_1) 2850 #error sysctl_cvt_out: no support for SYSCTL_VERSION 2851 #endif /* (SYSCTL_VERSION != SYSCTL_VERS_1) */ 2852 2853 case SYSCTL_VERSION: 2854 /* nothing more to do here */ 2855 break; 2856 } 2857 2858 if (ovp != NULL && left >= sz) { 2859 error = sysctl_copyout(l, src, ovp, sz); 2860 if (error) 2861 return (error); 2862 } 2863 2864 if (szp != NULL) 2865 *szp = sz; 2866 2867 return (0); 2868 } 2869