![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kern_newsysctl.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / kern|
Return to kern_newsysctl.c CVS log | Up to [Apple XNU] / XNU / bsd / kern |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /*- ! 23: * Copyright (c) 1982, 1986, 1989, 1993 ! 24: * The Regents of the University of California. All rights reserved. ! 25: * ! 26: * This code is derived from software contributed to Berkeley by ! 27: * Mike Karels at Berkeley Software Design, Inc. ! 28: * ! 29: * Quite extensively rewritten by Poul-Henning Kamp of the FreeBSD ! 30: * project, to make these variables more userfriendly. ! 31: * ! 32: * Redistribution and use in source and binary forms, with or without ! 33: * modification, are permitted provided that the following conditions ! 34: * are met: ! 35: * 1. Redistributions of source code must retain the above copyright ! 36: * notice, this list of conditions and the following disclaimer. ! 37: * 2. Redistributions in binary form must reproduce the above copyright ! 38: * notice, this list of conditions and the following disclaimer in the ! 39: * documentation and/or other materials provided with the distribution. ! 40: * 3. All advertising materials mentioning features or use of this software ! 41: * must display the following acknowledgement: ! 42: * This product includes software developed by the University of ! 43: * California, Berkeley and its contributors. ! 44: * 4. Neither the name of the University nor the names of its contributors ! 45: * may be used to endorse or promote products derived from this software ! 46: * without specific prior written permission. ! 47: * ! 48: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 49: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 50: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 51: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 52: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 53: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 54: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 55: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 56: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 57: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 58: * SUCH DAMAGE. ! 59: * ! 60: * @(#)kern_sysctl.c 8.4 (Berkeley) 4/14/94 ! 61: */ ! 62: ! 63: ! 64: #include <sys/param.h> ! 65: #include <sys/buf.h> ! 66: #include <sys/kernel.h> ! 67: #include <sys/sysctl.h> ! 68: #include <sys/malloc.h> ! 69: #include <sys/proc.h> ! 70: #include <sys/systm.h> ! 71: ! 72: /* ! 73: struct sysctl_oid_list sysctl__debug_children; ! 74: struct sysctl_oid_list sysctl__kern_children; ! 75: struct sysctl_oid_list sysctl__net_children; ! 76: struct sysctl_oid_list sysctl__sysctl_children; ! 77: */ ! 78: ! 79: extern struct sysctl_oid *newsysctl_list[]; ! 80: ! 81: ! 82: static void ! 83: sysctl_sysctl_debug_dump_node(struct sysctl_oid_list *l, int i); ! 84: ! 85: ! 86: ! 87: /* ! 88: * Locking and stats ! 89: */ ! 90: static struct sysctl_lock { ! 91: int sl_lock; ! 92: int sl_want; ! 93: int sl_locked; ! 94: } memlock; ! 95: ! 96: static int sysctl_root SYSCTL_HANDLER_ARGS; ! 97: ! 98: struct sysctl_oid_list sysctl__children; /* root list */ ! 99: ! 100: /* ! 101: * Initialization of the MIB tree. ! 102: * ! 103: * Order by number in each list. ! 104: */ ! 105: ! 106: void sysctl_register_oid(struct sysctl_oid *oidp) ! 107: { ! 108: struct sysctl_oid_list *parent = oidp->oid_parent; ! 109: struct sysctl_oid *p; ! 110: struct sysctl_oid *q; ! 111: int n; ! 112: ! 113: /* ! 114: * If this oid has a number OID_AUTO, give it a number which ! 115: * is greater than any current oid. Make sure it is at least ! 116: * 100 to leave space for pre-assigned oid numbers. ! 117: */ ! 118: /* sysctl_sysctl_debug_dump_node(parent, 3); */ ! 119: if (oidp->oid_number == OID_AUTO) { ! 120: /* First, find the highest oid in the parent list >99 */ ! 121: n = 99; ! 122: SLIST_FOREACH(p, parent, oid_link) { ! 123: if (p->oid_number > n) ! 124: n = p->oid_number; ! 125: } ! 126: oidp->oid_number = n + 1; ! 127: } ! 128: ! 129: /* ! 130: * Insert the oid into the parent's list in order. ! 131: */ ! 132: q = NULL; ! 133: SLIST_FOREACH(p, parent, oid_link) { ! 134: if (oidp->oid_number < p->oid_number) ! 135: break; ! 136: q = p; ! 137: } ! 138: if (q) ! 139: SLIST_INSERT_AFTER(q, oidp, oid_link); ! 140: else ! 141: SLIST_INSERT_HEAD(parent, oidp, oid_link); ! 142: } ! 143: ! 144: void sysctl_unregister_oid(struct sysctl_oid *oidp) ! 145: { ! 146: SLIST_REMOVE(oidp->oid_parent, oidp, sysctl_oid, oid_link); ! 147: } ! 148: ! 149: /* ! 150: * Bulk-register all the oids in a linker_set. ! 151: */ ! 152: void sysctl_register_set(struct linker_set *lsp) ! 153: { ! 154: int count = lsp->ls_length; ! 155: int i; ! 156: for (i = 0; i < count; i++) ! 157: sysctl_register_oid((struct sysctl_oid *) lsp->ls_items[i]); ! 158: } ! 159: ! 160: void sysctl_unregister_set(struct linker_set *lsp) ! 161: { ! 162: int count = lsp->ls_length; ! 163: int i; ! 164: for (i = 0; i < count; i++) ! 165: sysctl_unregister_oid((struct sysctl_oid *) lsp->ls_items[i]); ! 166: } ! 167: ! 168: ! 169: /* ! 170: * Register OID's from fixed list ! 171: */ ! 172: ! 173: void sysctl_register_fixed() ! 174: { ! 175: int i = 0; ! 176: ! 177: ! 178: while (newsysctl_list[i]) { ! 179: /* printf("Registering %d\n", i); */ ! 180: sysctl_register_oid(newsysctl_list[i++]); ! 181: } ! 182: } ! 183: ! 184: /* ! 185: * Register the kernel's oids on startup. ! 186: */ ! 187: struct linker_set sysctl_set; ! 188: ! 189: void sysctl_register_all(void *arg) ! 190: { ! 191: sysctl_register_set(&sysctl_set); ! 192: } ! 193: ! 194: SYSINIT(sysctl, SI_SUB_KMEM, SI_ORDER_ANY, sysctl_register_all, 0); ! 195: ! 196: /* ! 197: * "Staff-functions" ! 198: * ! 199: * These functions implement a presently undocumented interface ! 200: * used by the sysctl program to walk the tree, and get the type ! 201: * so it can print the value. ! 202: * This interface is under work and consideration, and should probably ! 203: * be killed with a big axe by the first person who can find the time. ! 204: * (be aware though, that the proper interface isn't as obvious as it ! 205: * may seem, there are various conflicting requirements. ! 206: * ! 207: * {0,0} printf the entire MIB-tree. ! 208: * {0,1,...} return the name of the "..." OID. ! 209: * {0,2,...} return the next OID. ! 210: * {0,3} return the OID of the name in "new" ! 211: * {0,4,...} return the kind & format info for the "..." OID. ! 212: */ ! 213: ! 214: static void ! 215: sysctl_sysctl_debug_dump_node(struct sysctl_oid_list *l, int i) ! 216: { ! 217: int k; ! 218: struct sysctl_oid *oidp; ! 219: ! 220: SLIST_FOREACH(oidp, l, oid_link) { ! 221: ! 222: for (k=0; k<i; k++) ! 223: printf(" "); ! 224: ! 225: printf("%d %s ", oidp->oid_number, oidp->oid_name); ! 226: ! 227: printf("%c%c", ! 228: oidp->oid_kind & CTLFLAG_RD ? 'R':' ', ! 229: oidp->oid_kind & CTLFLAG_WR ? 'W':' '); ! 230: ! 231: if (oidp->oid_handler) ! 232: printf(" *Handler"); ! 233: ! 234: switch (oidp->oid_kind & CTLTYPE) { ! 235: case CTLTYPE_NODE: ! 236: printf(" Node\n"); ! 237: if (!oidp->oid_handler) { ! 238: sysctl_sysctl_debug_dump_node( ! 239: oidp->oid_arg1, i+2); ! 240: } ! 241: break; ! 242: case CTLTYPE_INT: printf(" Int\n"); break; ! 243: case CTLTYPE_STRING: printf(" String\n"); break; ! 244: case CTLTYPE_QUAD: printf(" Quad\n"); break; ! 245: case CTLTYPE_OPAQUE: printf(" Opaque/struct\n"); break; ! 246: default: printf("\n"); ! 247: } ! 248: ! 249: } ! 250: } ! 251: ! 252: static int ! 253: sysctl_sysctl_debug SYSCTL_HANDLER_ARGS ! 254: { ! 255: sysctl_sysctl_debug_dump_node(&sysctl__children, 0); ! 256: return ENOENT; ! 257: } ! 258: ! 259: SYSCTL_PROC(_sysctl, 0, debug, CTLTYPE_STRING|CTLFLAG_RD, ! 260: 0, 0, sysctl_sysctl_debug, "-", ""); ! 261: ! 262: static int ! 263: sysctl_sysctl_name SYSCTL_HANDLER_ARGS ! 264: { ! 265: int *name = (int *) arg1; ! 266: u_int namelen = arg2; ! 267: int error = 0; ! 268: struct sysctl_oid *oid; ! 269: struct sysctl_oid_list *lsp = &sysctl__children, *lsp2; ! 270: char buf[10]; ! 271: ! 272: while (namelen) { ! 273: if (!lsp) { ! 274: snprintf(buf,sizeof(buf),"%d",*name); ! 275: if (req->oldidx) ! 276: error = SYSCTL_OUT(req, ".", 1); ! 277: if (!error) ! 278: error = SYSCTL_OUT(req, buf, strlen(buf)); ! 279: if (error) ! 280: return (error); ! 281: namelen--; ! 282: name++; ! 283: continue; ! 284: } ! 285: lsp2 = 0; ! 286: SLIST_FOREACH(oid, lsp, oid_link) { ! 287: if (oid->oid_number != *name) ! 288: continue; ! 289: ! 290: if (req->oldidx) ! 291: error = SYSCTL_OUT(req, ".", 1); ! 292: if (!error) ! 293: error = SYSCTL_OUT(req, oid->oid_name, ! 294: strlen(oid->oid_name)); ! 295: if (error) ! 296: return (error); ! 297: ! 298: namelen--; ! 299: name++; ! 300: ! 301: if ((oid->oid_kind & CTLTYPE) != CTLTYPE_NODE) ! 302: break; ! 303: ! 304: if (oid->oid_handler) ! 305: break; ! 306: ! 307: lsp2 = (struct sysctl_oid_list *)oid->oid_arg1; ! 308: break; ! 309: } ! 310: lsp = lsp2; ! 311: } ! 312: return (SYSCTL_OUT(req, "", 1)); ! 313: } ! 314: ! 315: SYSCTL_NODE(_sysctl, 1, name, CTLFLAG_RD, sysctl_sysctl_name, ""); ! 316: ! 317: static int ! 318: sysctl_sysctl_next_ls (struct sysctl_oid_list *lsp, int *name, u_int namelen, ! 319: int *next, int *len, int level, struct sysctl_oid **oidpp) ! 320: { ! 321: struct sysctl_oid *oidp; ! 322: ! 323: *len = level; ! 324: SLIST_FOREACH(oidp, lsp, oid_link) { ! 325: *next = oidp->oid_number; ! 326: *oidpp = oidp; ! 327: ! 328: if (!namelen) { ! 329: if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE) ! 330: return 0; ! 331: if (oidp->oid_handler) ! 332: /* We really should call the handler here...*/ ! 333: return 0; ! 334: lsp = (struct sysctl_oid_list *)oidp->oid_arg1; ! 335: if (!sysctl_sysctl_next_ls (lsp, 0, 0, next+1, ! 336: len, level+1, oidpp)) ! 337: return 0; ! 338: goto next; ! 339: } ! 340: ! 341: if (oidp->oid_number < *name) ! 342: continue; ! 343: ! 344: if (oidp->oid_number > *name) { ! 345: if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE) ! 346: return 0; ! 347: if (oidp->oid_handler) ! 348: return 0; ! 349: lsp = (struct sysctl_oid_list *)oidp->oid_arg1; ! 350: if (!sysctl_sysctl_next_ls (lsp, name+1, namelen-1, ! 351: next+1, len, level+1, oidpp)) ! 352: return (0); ! 353: goto next; ! 354: } ! 355: if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE) ! 356: continue; ! 357: ! 358: if (oidp->oid_handler) ! 359: continue; ! 360: ! 361: lsp = (struct sysctl_oid_list *)oidp->oid_arg1; ! 362: if (!sysctl_sysctl_next_ls (lsp, name+1, namelen-1, next+1, ! 363: len, level+1, oidpp)) ! 364: return (0); ! 365: next: ! 366: namelen = 1; ! 367: *len = level; ! 368: } ! 369: return 1; ! 370: } ! 371: ! 372: static int ! 373: sysctl_sysctl_next SYSCTL_HANDLER_ARGS ! 374: { ! 375: int *name = (int *) arg1; ! 376: u_int namelen = arg2; ! 377: int i, j, error; ! 378: struct sysctl_oid *oid; ! 379: struct sysctl_oid_list *lsp = &sysctl__children; ! 380: int newoid[CTL_MAXNAME]; ! 381: ! 382: i = sysctl_sysctl_next_ls (lsp, name, namelen, newoid, &j, 1, &oid); ! 383: if (i) ! 384: return ENOENT; ! 385: error = SYSCTL_OUT(req, newoid, j * sizeof (int)); ! 386: return (error); ! 387: } ! 388: ! 389: SYSCTL_NODE(_sysctl, 2, next, CTLFLAG_RD, sysctl_sysctl_next, ""); ! 390: ! 391: static int ! 392: name2oid (char *name, int *oid, int *len, struct sysctl_oid **oidpp) ! 393: { ! 394: int i; ! 395: struct sysctl_oid *oidp; ! 396: struct sysctl_oid_list *lsp = &sysctl__children; ! 397: char *p; ! 398: ! 399: if (!*name) ! 400: return ENOENT; ! 401: ! 402: p = name + strlen(name) - 1 ; ! 403: if (*p == '.') ! 404: *p = '\0'; ! 405: ! 406: *len = 0; ! 407: ! 408: for (p = name; *p && *p != '.'; p++) ! 409: ; ! 410: i = *p; ! 411: if (i == '.') ! 412: *p = '\0'; ! 413: ! 414: oidp = SLIST_FIRST(lsp); ! 415: ! 416: while (oidp && *len < CTL_MAXNAME) { ! 417: if (strcmp(name, oidp->oid_name)) { ! 418: oidp = SLIST_NEXT(oidp, oid_link); ! 419: continue; ! 420: } ! 421: *oid++ = oidp->oid_number; ! 422: (*len)++; ! 423: ! 424: if (!i) { ! 425: if (oidpp) ! 426: *oidpp = oidp; ! 427: return (0); ! 428: } ! 429: ! 430: if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE) ! 431: break; ! 432: ! 433: if (oidp->oid_handler) ! 434: break; ! 435: ! 436: lsp = (struct sysctl_oid_list *)oidp->oid_arg1; ! 437: oidp = SLIST_FIRST(lsp); ! 438: name = p+1; ! 439: for (p = name; *p && *p != '.'; p++) ! 440: ; ! 441: i = *p; ! 442: if (i == '.') ! 443: *p = '\0'; ! 444: } ! 445: return ENOENT; ! 446: } ! 447: ! 448: static int ! 449: sysctl_sysctl_name2oid SYSCTL_HANDLER_ARGS ! 450: { ! 451: char *p; ! 452: int error, oid[CTL_MAXNAME], len; ! 453: struct sysctl_oid *op = 0; ! 454: ! 455: if (!req->newlen) ! 456: return ENOENT; ! 457: if (req->newlen >= MAXPATHLEN) /* XXX arbitrary, undocumented */ ! 458: return (ENAMETOOLONG); ! 459: ! 460: p = _MALLOC(req->newlen+1, M_TEMP, M_WAITOK); ! 461: ! 462: if (!p) ! 463: return ENOMEM; ! 464: ! 465: error = SYSCTL_IN(req, p, req->newlen); ! 466: if (error) { ! 467: FREE(p, M_TEMP); ! 468: return (error); ! 469: } ! 470: ! 471: p [req->newlen] = '\0'; ! 472: ! 473: error = name2oid(p, oid, &len, &op); ! 474: ! 475: FREE(p, M_TEMP); ! 476: ! 477: if (error) ! 478: return (error); ! 479: ! 480: error = SYSCTL_OUT(req, oid, len * sizeof *oid); ! 481: return (error); ! 482: } ! 483: ! 484: SYSCTL_PROC(_sysctl, 3, name2oid, CTLFLAG_RW|CTLFLAG_ANYBODY, 0, 0, ! 485: sysctl_sysctl_name2oid, "I", ""); ! 486: ! 487: static int ! 488: sysctl_sysctl_oidfmt SYSCTL_HANDLER_ARGS ! 489: { ! 490: int *name = (int *) arg1, error; ! 491: u_int namelen = arg2; ! 492: int indx; ! 493: struct sysctl_oid *oid; ! 494: struct sysctl_oid_list *lsp = &sysctl__children; ! 495: ! 496: oid = SLIST_FIRST(lsp); ! 497: ! 498: indx = 0; ! 499: while (oid && indx < CTL_MAXNAME) { ! 500: if (oid->oid_number == name[indx]) { ! 501: indx++; ! 502: if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) { ! 503: if (oid->oid_handler) ! 504: goto found; ! 505: if (indx == namelen) ! 506: goto found; ! 507: lsp = (struct sysctl_oid_list *)oid->oid_arg1; ! 508: oid = SLIST_FIRST(lsp); ! 509: } else { ! 510: if (indx != namelen) ! 511: return EISDIR; ! 512: goto found; ! 513: } ! 514: } else { ! 515: oid = SLIST_NEXT(oid, oid_link); ! 516: } ! 517: } ! 518: return ENOENT; ! 519: found: ! 520: if (!oid->oid_fmt) ! 521: return ENOENT; ! 522: error = SYSCTL_OUT(req, ! 523: &oid->oid_kind, sizeof(oid->oid_kind)); ! 524: if (!error) ! 525: error = SYSCTL_OUT(req, oid->oid_fmt, ! 526: strlen(oid->oid_fmt)+1); ! 527: return (error); ! 528: } ! 529: ! 530: ! 531: SYSCTL_NODE(_sysctl, 4, oidfmt, CTLFLAG_RD, sysctl_sysctl_oidfmt, ""); ! 532: ! 533: /* ! 534: * Default "handler" functions. ! 535: */ ! 536: ! 537: /* ! 538: * Handle an int, signed or unsigned. ! 539: * Two cases: ! 540: * a variable: point arg1 at it. ! 541: * a constant: pass it in arg2. ! 542: */ ! 543: ! 544: int ! 545: sysctl_handle_int SYSCTL_HANDLER_ARGS ! 546: { ! 547: int error = 0; ! 548: ! 549: if (arg1) ! 550: error = SYSCTL_OUT(req, arg1, sizeof(int)); ! 551: else ! 552: error = SYSCTL_OUT(req, &arg2, sizeof(int)); ! 553: ! 554: if (error || !req->newptr) ! 555: return (error); ! 556: ! 557: if (!arg1) ! 558: error = EPERM; ! 559: else ! 560: error = SYSCTL_IN(req, arg1, sizeof(int)); ! 561: return (error); ! 562: } ! 563: ! 564: /* ! 565: * Handle a long, signed or unsigned. arg1 points to it. ! 566: */ ! 567: ! 568: int ! 569: sysctl_handle_long SYSCTL_HANDLER_ARGS ! 570: { ! 571: int error = 0; ! 572: ! 573: if (!arg1) ! 574: return (EINVAL); ! 575: error = SYSCTL_OUT(req, arg1, sizeof(long)); ! 576: ! 577: if (error || !req->newptr) ! 578: return (error); ! 579: ! 580: error = SYSCTL_IN(req, arg1, sizeof(long)); ! 581: return (error); ! 582: } ! 583: ! 584: /* ! 585: * Handle our generic '\0' terminated 'C' string. ! 586: * Two cases: ! 587: * a variable string: point arg1 at it, arg2 is max length. ! 588: * a constant string: point arg1 at it, arg2 is zero. ! 589: */ ! 590: ! 591: int ! 592: sysctl_handle_string SYSCTL_HANDLER_ARGS ! 593: { ! 594: int error=0; ! 595: ! 596: error = SYSCTL_OUT(req, arg1, strlen((char *)arg1)+1); ! 597: ! 598: if (error || !req->newptr) ! 599: return (error); ! 600: ! 601: if ((req->newlen - req->newidx) >= arg2) { ! 602: error = EINVAL; ! 603: } else { ! 604: arg2 = (req->newlen - req->newidx); ! 605: error = SYSCTL_IN(req, arg1, arg2); ! 606: ((char *)arg1)[arg2] = '\0'; ! 607: } ! 608: ! 609: return (error); ! 610: } ! 611: ! 612: /* ! 613: * Handle any kind of opaque data. ! 614: * arg1 points to it, arg2 is the size. ! 615: */ ! 616: ! 617: int ! 618: sysctl_handle_opaque SYSCTL_HANDLER_ARGS ! 619: { ! 620: int error; ! 621: ! 622: error = SYSCTL_OUT(req, arg1, arg2); ! 623: ! 624: if (error || !req->newptr) ! 625: return (error); ! 626: ! 627: error = SYSCTL_IN(req, arg1, arg2); ! 628: ! 629: return (error); ! 630: } ! 631: ! 632: /* ! 633: * Transfer functions to/from kernel space. ! 634: * XXX: rather untested at this point ! 635: */ ! 636: static int ! 637: sysctl_old_kernel(struct sysctl_req *req, const void *p, size_t l) ! 638: { ! 639: size_t i = 0; ! 640: int error = 0; ! 641: ! 642: if (req->oldptr) { ! 643: i = l; ! 644: if (i > req->oldlen - req->oldidx) ! 645: i = req->oldlen - req->oldidx; ! 646: if (i > 0) { ! 647: error = copyout(p, (char *)req->oldptr + req->oldidx, i); ! 648: if (error) ! 649: return error; ! 650: } ! 651: } ! 652: req->oldidx += l; ! 653: if (req->oldptr && i != l) ! 654: return (ENOMEM); ! 655: return (0); ! 656: } ! 657: ! 658: static int ! 659: sysctl_new_kernel(struct sysctl_req *req, void *p, size_t l) ! 660: { ! 661: if (!req->newptr) ! 662: return 0; ! 663: if (req->newlen - req->newidx < l) ! 664: return (EINVAL); ! 665: copyin((char *)req->newptr + req->newidx, p, l); ! 666: req->newidx += l; ! 667: return (0); ! 668: } ! 669: ! 670: int ! 671: kernel_sysctl(struct proc *p, int *name, u_int namelen, void *old, size_t *oldlenp, void *new, size_t newlen, size_t *retval) ! 672: { ! 673: int error = 0; ! 674: struct sysctl_req req; ! 675: ! 676: bzero(&req, sizeof req); ! 677: ! 678: req.p = p; ! 679: ! 680: if (oldlenp) { ! 681: req.oldlen = *oldlenp; ! 682: } ! 683: ! 684: if (old) { ! 685: req.oldptr= old; ! 686: } ! 687: ! 688: if (newlen) { ! 689: req.newlen = newlen; ! 690: req.newptr = new; ! 691: } ! 692: ! 693: req.oldfunc = sysctl_old_kernel; ! 694: req.newfunc = sysctl_new_kernel; ! 695: req.lock = 1; ! 696: ! 697: /* XXX this should probably be done in a general way */ ! 698: while (memlock.sl_lock) { ! 699: memlock.sl_want = 1; ! 700: (void) tsleep((caddr_t)&memlock, PRIBIO+1, "sysctl", 0); ! 701: memlock.sl_locked++; ! 702: } ! 703: memlock.sl_lock = 1; ! 704: ! 705: error = sysctl_root(0, name, namelen, &req); ! 706: ! 707: if (req.lock == 2) ! 708: vsunlock(req.oldptr, req.oldlen, B_WRITE); ! 709: ! 710: memlock.sl_lock = 0; ! 711: ! 712: if (memlock.sl_want) { ! 713: memlock.sl_want = 0; ! 714: wakeup((caddr_t)&memlock); ! 715: } ! 716: ! 717: if (error && error != ENOMEM) ! 718: return (error); ! 719: ! 720: if (retval) { ! 721: if (req.oldptr && req.oldidx > req.oldlen) ! 722: *retval = req.oldlen; ! 723: else ! 724: *retval = req.oldidx; ! 725: } ! 726: return (error); ! 727: } ! 728: ! 729: /* ! 730: * Transfer function to/from user space. ! 731: */ ! 732: static int ! 733: sysctl_old_user(struct sysctl_req *req, const void *p, size_t l) ! 734: { ! 735: int error = 0; ! 736: size_t i = 0; ! 737: ! 738: if (req->oldptr) { ! 739: i = l; ! 740: if (i > req->oldlen - req->oldidx) ! 741: i = req->oldlen - req->oldidx; ! 742: if (i > 0) ! 743: error = copyout(p, (char *)req->oldptr + req->oldidx, ! 744: i); ! 745: } ! 746: req->oldidx += l; ! 747: if (error) ! 748: return (error); ! 749: if (req->oldptr && i < l) ! 750: return (ENOMEM); ! 751: return (0); ! 752: } ! 753: ! 754: static int ! 755: sysctl_new_user(struct sysctl_req *req, void *p, size_t l) ! 756: { ! 757: int error; ! 758: ! 759: if (!req->newptr) ! 760: return 0; ! 761: if (req->newlen - req->newidx < l) ! 762: return (EINVAL); ! 763: error = copyin((char *)req->newptr + req->newidx, p, l); ! 764: req->newidx += l; ! 765: return (error); ! 766: } ! 767: ! 768: /* ! 769: * Traverse our tree, and find the right node, execute whatever it points ! 770: * at, and return the resulting error code. ! 771: */ ! 772: ! 773: int ! 774: sysctl_root SYSCTL_HANDLER_ARGS ! 775: { ! 776: int *name = (int *) arg1; ! 777: u_int namelen = arg2; ! 778: int indx, i; ! 779: struct sysctl_oid *oid; ! 780: struct sysctl_oid_list *lsp = &sysctl__children; ! 781: ! 782: oid = SLIST_FIRST(lsp); ! 783: ! 784: indx = 0; ! 785: while (oid && indx < CTL_MAXNAME) { ! 786: if (oid->oid_number == name[indx]) { ! 787: indx++; ! 788: if (oid->oid_kind & CTLFLAG_NOLOCK) ! 789: req->lock = 0; ! 790: if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) { ! 791: if (oid->oid_handler) ! 792: goto found; ! 793: if (indx == namelen) ! 794: return ENOENT; ! 795: lsp = (struct sysctl_oid_list *)oid->oid_arg1; ! 796: oid = SLIST_FIRST(lsp); ! 797: } else { ! 798: if (indx != namelen) ! 799: return EISDIR; ! 800: goto found; ! 801: } ! 802: } else { ! 803: oid = SLIST_NEXT(oid, oid_link); ! 804: } ! 805: } ! 806: return ENOENT; ! 807: found: ! 808: /* If writing isn't allowed */ ! 809: if (req->newptr && (!(oid->oid_kind & CTLFLAG_WR) || ! 810: ((oid->oid_kind & CTLFLAG_SECURE) && securelevel > 0))) { ! 811: return (EPERM); ! 812: } ! 813: ! 814: ! 815: if (!oid->oid_handler) { ! 816: return EINVAL; ! 817: } ! 818: ! 819: if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) { ! 820: i = (oid->oid_handler) (oid, ! 821: name + indx, namelen - indx, ! 822: req); ! 823: } else { ! 824: i = (oid->oid_handler) (oid, ! 825: oid->oid_arg1, oid->oid_arg2, ! 826: req); ! 827: } ! 828: return (i); ! 829: } ! 830: ! 831: #ifndef _SYS_SYSPROTO_H_ ! 832: struct sysctl_args { ! 833: int *name; ! 834: u_int namelen; ! 835: void *old; ! 836: size_t *oldlenp; ! 837: void *new; ! 838: size_t newlen; ! 839: }; ! 840: #endif ! 841: ! 842: int ! 843: /* __sysctl(struct proc *p, struct sysctl_args *uap) */ ! 844: new_sysctl(struct proc *p, struct sysctl_args *uap) ! 845: { ! 846: int error, i, name[CTL_MAXNAME]; ! 847: size_t j; ! 848: ! 849: if (uap->namelen > CTL_MAXNAME || uap->namelen < 2) ! 850: return (EINVAL); ! 851: ! 852: error = copyin(uap->name, &name, uap->namelen * sizeof(int)); ! 853: if (error) ! 854: return (error); ! 855: ! 856: error = userland_sysctl(p, name, uap->namelen, ! 857: uap->old, uap->oldlenp, 0, ! 858: uap->new, uap->newlen, &j); ! 859: if (error && error != ENOMEM) ! 860: return (error); ! 861: if (uap->oldlenp) { ! 862: i = copyout(&j, uap->oldlenp, sizeof(j)); ! 863: if (i) ! 864: return (i); ! 865: } ! 866: return (error); ! 867: } ! 868: ! 869: /* ! 870: * This is used from various compatibility syscalls too. That's why name ! 871: * must be in kernel space. ! 872: */ ! 873: int ! 874: userland_sysctl(struct proc *p, int *name, u_int namelen, void *old, size_t *oldlenp, int inkernel, void *new, size_t newlen, size_t *retval) ! 875: { ! 876: int error = 0; ! 877: struct sysctl_req req, req2; ! 878: ! 879: bzero(&req, sizeof req); ! 880: ! 881: req.p = p; ! 882: ! 883: if (oldlenp) { ! 884: if (inkernel) { ! 885: req.oldlen = *oldlenp; ! 886: } else { ! 887: error = copyin(oldlenp, &req.oldlen, sizeof(*oldlenp)); ! 888: if (error) ! 889: return (error); ! 890: } ! 891: } ! 892: ! 893: if (old) { ! 894: req.oldptr= old; ! 895: } ! 896: ! 897: if (newlen) { ! 898: req.newlen = newlen; ! 899: req.newptr = new; ! 900: } ! 901: ! 902: req.oldfunc = sysctl_old_user; ! 903: req.newfunc = sysctl_new_user; ! 904: req.lock = 1; ! 905: ! 906: do { ! 907: req2 = req; ! 908: error = sysctl_root(0, name, namelen, &req2); ! 909: } while (error == EAGAIN); ! 910: ! 911: req = req2; ! 912: ! 913: if (error && error != ENOMEM) ! 914: return (error); ! 915: ! 916: if (retval) { ! 917: if (req.oldptr && req.oldidx > req.oldlen) ! 918: *retval = req.oldlen; ! 919: else ! 920: *retval = req.oldidx; ! 921: } ! 922: return (error); ! 923: } ! 924: #if 0 ! 925: ! 926: #if COMPAT_43 ! 927: #include <sys/socket.h> ! 928: #include <vm/vm_param.h> ! 929: ! 930: #define KINFO_PROC (0<<8) ! 931: #define KINFO_RT (1<<8) ! 932: #define KINFO_VNODE (2<<8) ! 933: #define KINFO_FILE (3<<8) ! 934: #define KINFO_METER (4<<8) ! 935: #define KINFO_LOADAVG (5<<8) ! 936: #define KINFO_CLOCKRATE (6<<8) ! 937: ! 938: /* Non-standard BSDI extension - only present on their 4.3 net-2 releases */ ! 939: #define KINFO_BSDI_SYSINFO (101<<8) ! 940: ! 941: /* ! 942: * XXX this is bloat, but I hope it's better here than on the potentially ! 943: * limited kernel stack... -Peter ! 944: */ ! 945: ! 946: static struct { ! 947: int bsdi_machine; /* "i386" on BSD/386 */ ! 948: /* ^^^ this is an offset to the string, relative to the struct start */ ! 949: char *pad0; ! 950: long pad1; ! 951: long pad2; ! 952: long pad3; ! 953: u_long pad4; ! 954: u_long pad5; ! 955: u_long pad6; ! 956: ! 957: int bsdi_ostype; /* "BSD/386" on BSD/386 */ ! 958: int bsdi_osrelease; /* "1.1" on BSD/386 */ ! 959: long pad7; ! 960: long pad8; ! 961: char *pad9; ! 962: ! 963: long pad10; ! 964: long pad11; ! 965: int pad12; ! 966: long pad13; ! 967: quad_t pad14; ! 968: long pad15; ! 969: ! 970: struct timeval pad16; ! 971: /* we dont set this, because BSDI's uname used gethostname() instead */ ! 972: int bsdi_hostname; /* hostname on BSD/386 */ ! 973: ! 974: /* the actual string data is appended here */ ! 975: ! 976: } bsdi_si; ! 977: /* ! 978: * this data is appended to the end of the bsdi_si structure during copyout. ! 979: * The "char *" offsets are relative to the base of the bsdi_si struct. ! 980: * This contains "FreeBSD\02.0-BUILT-nnnnnn\0i386\0", and these strings ! 981: * should not exceed the length of the buffer here... (or else!! :-) ! 982: */ ! 983: static char bsdi_strings[80]; /* It had better be less than this! */ ! 984: ! 985: #ifndef _SYS_SYSPROTO_H_ ! 986: struct getkerninfo_args { ! 987: int op; ! 988: char *where; ! 989: size_t *size; ! 990: int arg; ! 991: }; ! 992: #endif ! 993: ! 994: int ! 995: ogetkerninfo(struct proc *p, struct getkerninfo_args *uap) ! 996: { ! 997: int error, name[6]; ! 998: size_t size; ! 999: ! 1000: switch (uap->op & 0xff00) { ! 1001: ! 1002: case KINFO_RT: ! 1003: name[0] = CTL_NET; ! 1004: name[1] = PF_ROUTE; ! 1005: name[2] = 0; ! 1006: name[3] = (uap->op & 0xff0000) >> 16; ! 1007: name[4] = uap->op & 0xff; ! 1008: name[5] = uap->arg; ! 1009: error = userland_sysctl(p, name, 6, uap->where, uap->size, ! 1010: 0, 0, 0, &size); ! 1011: break; ! 1012: ! 1013: case KINFO_VNODE: ! 1014: name[0] = CTL_KERN; ! 1015: name[1] = KERN_VNODE; ! 1016: error = userland_sysctl(p, name, 2, uap->where, uap->size, ! 1017: 0, 0, 0, &size); ! 1018: break; ! 1019: ! 1020: case KINFO_PROC: ! 1021: name[0] = CTL_KERN; ! 1022: name[1] = KERN_PROC; ! 1023: name[2] = uap->op & 0xff; ! 1024: name[3] = uap->arg; ! 1025: error = userland_sysctl(p, name, 4, uap->where, uap->size, ! 1026: 0, 0, 0, &size); ! 1027: break; ! 1028: ! 1029: case KINFO_FILE: ! 1030: name[0] = CTL_KERN; ! 1031: name[1] = KERN_FILE; ! 1032: error = userland_sysctl(p, name, 2, uap->where, uap->size, ! 1033: 0, 0, 0, &size); ! 1034: break; ! 1035: ! 1036: case KINFO_METER: ! 1037: name[0] = CTL_VM; ! 1038: name[1] = VM_METER; ! 1039: error = userland_sysctl(p, name, 2, uap->where, uap->size, ! 1040: 0, 0, 0, &size); ! 1041: break; ! 1042: ! 1043: case KINFO_LOADAVG: ! 1044: name[0] = CTL_VM; ! 1045: name[1] = VM_LOADAVG; ! 1046: error = userland_sysctl(p, name, 2, uap->where, uap->size, ! 1047: 0, 0, 0, &size); ! 1048: break; ! 1049: ! 1050: case KINFO_CLOCKRATE: ! 1051: name[0] = CTL_KERN; ! 1052: name[1] = KERN_CLOCKRATE; ! 1053: error = userland_sysctl(p, name, 2, uap->where, uap->size, ! 1054: 0, 0, 0, &size); ! 1055: break; ! 1056: ! 1057: case KINFO_BSDI_SYSINFO: { ! 1058: /* ! 1059: * this is pretty crude, but it's just enough for uname() ! 1060: * from BSDI's 1.x libc to work. ! 1061: * ! 1062: * In particular, it doesn't return the same results when ! 1063: * the supplied buffer is too small. BSDI's version apparently ! 1064: * will return the amount copied, and set the *size to how ! 1065: * much was needed. The emulation framework here isn't capable ! 1066: * of that, so we just set both to the amount copied. ! 1067: * BSDI's 2.x product apparently fails with ENOMEM in this ! 1068: * scenario. ! 1069: */ ! 1070: ! 1071: u_int needed; ! 1072: u_int left; ! 1073: char *s; ! 1074: ! 1075: bzero((char *)&bsdi_si, sizeof(bsdi_si)); ! 1076: bzero(bsdi_strings, sizeof(bsdi_strings)); ! 1077: ! 1078: s = bsdi_strings; ! 1079: ! 1080: bsdi_si.bsdi_ostype = (s - bsdi_strings) + sizeof(bsdi_si); ! 1081: strcpy(s, ostype); ! 1082: s += strlen(s) + 1; ! 1083: ! 1084: bsdi_si.bsdi_osrelease = (s - bsdi_strings) + sizeof(bsdi_si); ! 1085: strcpy(s, osrelease); ! 1086: s += strlen(s) + 1; ! 1087: ! 1088: bsdi_si.bsdi_machine = (s - bsdi_strings) + sizeof(bsdi_si); ! 1089: strcpy(s, machine); ! 1090: s += strlen(s) + 1; ! 1091: ! 1092: needed = sizeof(bsdi_si) + (s - bsdi_strings); ! 1093: ! 1094: if (uap->where == NULL) { ! 1095: /* process is asking how much buffer to supply.. */ ! 1096: size = needed; ! 1097: error = 0; ! 1098: break; ! 1099: } ! 1100: ! 1101: ! 1102: /* if too much buffer supplied, trim it down */ ! 1103: if (size > needed) ! 1104: size = needed; ! 1105: ! 1106: /* how much of the buffer is remaining */ ! 1107: left = size; ! 1108: ! 1109: if ((error = copyout((char *)&bsdi_si, uap->where, left)) != 0) ! 1110: break; ! 1111: ! 1112: /* is there any point in continuing? */ ! 1113: if (left > sizeof(bsdi_si)) { ! 1114: left -= sizeof(bsdi_si); ! 1115: error = copyout(&bsdi_strings, ! 1116: uap->where + sizeof(bsdi_si), left); ! 1117: } ! 1118: break; ! 1119: } ! 1120: ! 1121: default: ! 1122: return (EOPNOTSUPP); ! 1123: } ! 1124: if (error) ! 1125: return (error); ! 1126: p->p_retval[0] = size; ! 1127: if (uap->size) ! 1128: error = copyout((caddr_t)&size, (caddr_t)uap->size, ! 1129: sizeof(size)); ! 1130: return (error); ! 1131: } ! 1132: #endif /* COMPAT_43 */ ! 1133: ! 1134: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.