![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kern_sysctl.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_sysctl.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: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */ ! 23: /*- ! 24: * Copyright (c) 1982, 1986, 1989, 1993 ! 25: * The Regents of the University of California. All rights reserved. ! 26: * ! 27: * This code is derived from software contributed to Berkeley by ! 28: * Mike Karels at Berkeley Software Design, Inc. ! 29: * ! 30: * Redistribution and use in source and binary forms, with or without ! 31: * modification, are permitted provided that the following conditions ! 32: * are met: ! 33: * 1. Redistributions of source code must retain the above copyright ! 34: * notice, this list of conditions and the following disclaimer. ! 35: * 2. Redistributions in binary form must reproduce the above copyright ! 36: * notice, this list of conditions and the following disclaimer in the ! 37: * documentation and/or other materials provided with the distribution. ! 38: * 3. All advertising materials mentioning features or use of this software ! 39: * must display the following acknowledgement: ! 40: * This product includes software developed by the University of ! 41: * California, Berkeley and its contributors. ! 42: * 4. Neither the name of the University nor the names of its contributors ! 43: * may be used to endorse or promote products derived from this software ! 44: * without specific prior written permission. ! 45: * ! 46: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 47: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 48: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 49: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 50: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 51: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 52: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 53: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 54: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 55: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 56: * SUCH DAMAGE. ! 57: * ! 58: * @(#)kern_sysctl.c 8.4 (Berkeley) 4/14/94 ! 59: */ ! 60: ! 61: /* ! 62: * sysctl system call. ! 63: */ ! 64: ! 65: #include <sys/param.h> ! 66: #include <sys/systm.h> ! 67: #include <sys/kernel.h> ! 68: #include <sys/malloc.h> ! 69: #include <sys/proc.h> ! 70: #include <sys/file.h> ! 71: #include <sys/vnode.h> ! 72: #include <sys/unistd.h> ! 73: #include <sys/buf.h> ! 74: #include <sys/ioctl.h> ! 75: #include <sys/tty.h> ! 76: #include <sys/disklabel.h> ! 77: #include <sys/vm.h> ! 78: #include <sys/sysctl.h> ! 79: #include <mach/mach_types.h> ! 80: #include <mach/vm_param.h> ! 81: #include <kern/task.h> ! 82: #include <vm/vm_kern.h> ! 83: ! 84: extern vm_map_t bsd_pageable_map; ! 85: ! 86: #include <sys/mount.h> ! 87: #import <sys/kdebug.h> ! 88: ! 89: #include <IOKit/IOPlatformExpert.h> ! 90: ! 91: sysctlfn kern_sysctl; ! 92: sysctlfn hw_sysctl; ! 93: #ifdef DEBUG ! 94: sysctlfn debug_sysctl; ! 95: #endif ! 96: extern sysctlfn vm_sysctl; ! 97: extern sysctlfn vfs_sysctl; ! 98: extern sysctlfn net_sysctl; ! 99: extern sysctlfn cpu_sysctl; ! 100: ! 101: ! 102: int ! 103: userland_sysctl(struct proc *p, int *name, u_int namelen, void *old, size_t ! 104: *oldlenp, int inkernel, void *new, size_t newlen, size_t *retval); ! 105: ! 106: ! 107: /* ! 108: * temporary location for vm_sysctl. This should be machine independant ! 109: */ ! 110: vm_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p) ! 111: int *name; ! 112: u_int namelen; ! 113: void *oldp; ! 114: size_t *oldlenp; ! 115: void *newp; ! 116: size_t newlen; ! 117: struct proc *p; ! 118: { ! 119: int error, level, inthostid; ! 120: extern long avenrun[3], mach_factor[3]; ! 121: struct loadavg loadinfo; ! 122: ! 123: //if (namelen != 1 && !(name[0] == VM_LOADAVG)) ! 124: //return (ENOTDIR); /* overloaded */ ! 125: ! 126: switch (name[0]) { ! 127: case VM_LOADAVG: ! 128: loadinfo.ldavg[0] = avenrun[0]; ! 129: loadinfo.ldavg[1] = avenrun[1]; ! 130: loadinfo.ldavg[2] = avenrun[2]; ! 131: loadinfo.fscale = LSCALE; ! 132: return (sysctl_struct(oldp, oldlenp, newp, newlen, &loadinfo, sizeof(struct loadavg))); ! 133: case VM_MACHFACTOR: ! 134: loadinfo.ldavg[0] = mach_factor[0]; ! 135: loadinfo.ldavg[1] = mach_factor[1]; ! 136: loadinfo.ldavg[2] = mach_factor[2]; ! 137: loadinfo.fscale = LSCALE; ! 138: return (sysctl_struct(oldp, oldlenp, newp, newlen, &loadinfo, sizeof(struct loadavg))); ! 139: case VM_METER: ! 140: return (EOPNOTSUPP); ! 141: case VM_MAXID: ! 142: return (EOPNOTSUPP); ! 143: default: ! 144: return (EOPNOTSUPP); ! 145: } ! 146: /* NOTREACHED */ ! 147: return (EOPNOTSUPP); ! 148: } ! 149: ! 150: /* ! 151: * Locking and stats ! 152: */ ! 153: static struct sysctl_lock { ! 154: int sl_lock; ! 155: int sl_want; ! 156: int sl_locked; ! 157: } memlock; ! 158: ! 159: struct __sysctl_args { ! 160: int *name; ! 161: u_int namelen; ! 162: void *old; ! 163: size_t *oldlenp; ! 164: void *new; ! 165: size_t newlen; ! 166: }; ! 167: int ! 168: __sysctl(p, uap, retval) ! 169: struct proc *p; ! 170: register struct __sysctl_args *uap; ! 171: register_t *retval; ! 172: { ! 173: int error, dolock = 1; ! 174: size_t savelen, oldlen = 0; ! 175: sysctlfn *fn; ! 176: int name[CTL_MAXNAME]; ! 177: int i; ! 178: ! 179: if (uap->new != NULL && ! 180: (error = suser(p->p_ucred, &p->p_acflag))) ! 181: return (error); ! 182: /* ! 183: * all top-level sysctl names are non-terminal ! 184: */ ! 185: if (uap->namelen > CTL_MAXNAME || uap->namelen < 2) ! 186: return (EINVAL); ! 187: if (error = ! 188: copyin(uap->name, &name, uap->namelen * sizeof(int))) ! 189: return (error); ! 190: ! 191: switch (name[0]) { ! 192: case CTL_KERN: ! 193: fn = kern_sysctl; ! 194: if (name[2] != KERN_VNODE) /* XXX */ ! 195: dolock = 0; ! 196: break; ! 197: case CTL_HW: ! 198: fn = hw_sysctl; ! 199: break; ! 200: case CTL_VM: ! 201: fn = vm_sysctl; ! 202: break; ! 203: case CTL_NET: ! 204: fn = net_sysctl; ! 205: break; ! 206: case CTL_VFS: ! 207: fn = vfs_sysctl; ! 208: break; ! 209: #if FIXME /* [ */ ! 210: case CTL_MACHDEP: ! 211: fn = cpu_sysctl; ! 212: break; ! 213: #endif /* FIXME ] */ ! 214: #ifdef DEBUG ! 215: case CTL_DEBUG: ! 216: fn = debug_sysctl; ! 217: break; ! 218: #endif ! 219: default: ! 220: fn = 0; ! 221: } ! 222: ! 223: if (uap->oldlenp && ! 224: (error = copyin(uap->oldlenp, &oldlen, sizeof(oldlen)))) ! 225: return (error); ! 226: ! 227: if (uap->old != NULL) { ! 228: if (!useracc(uap->old, oldlen, B_WRITE)) ! 229: return (EFAULT); ! 230: while (memlock.sl_lock) { ! 231: memlock.sl_want = 1; ! 232: sleep((caddr_t)&memlock, PRIBIO+1); ! 233: memlock.sl_locked++; ! 234: } ! 235: memlock.sl_lock = 1; ! 236: if (dolock) ! 237: vslock(uap->old, oldlen); ! 238: savelen = oldlen; ! 239: } ! 240: ! 241: if (fn) ! 242: error = (*fn)(name + 1, uap->namelen - 1, uap->old, ! 243: &oldlen, uap->new, uap->newlen, p); ! 244: else ! 245: error = 1; ! 246: ! 247: if (error) ! 248: error = userland_sysctl(p, name, uap->namelen, ! 249: uap->old, uap->oldlenp, 0, ! 250: uap->new, uap->newlen, &oldlen); ! 251: ! 252: if (uap->old != NULL) { ! 253: if (dolock) ! 254: vsunlock(uap->old, savelen, B_WRITE); ! 255: memlock.sl_lock = 0; ! 256: if (memlock.sl_want) { ! 257: memlock.sl_want = 0; ! 258: wakeup((caddr_t)&memlock); ! 259: } ! 260: } ! 261: if ((error) && (error != ENOMEM)) ! 262: return (error); ! 263: ! 264: if (uap->oldlenp) { ! 265: i = copyout(&oldlen, uap->oldlenp, sizeof(oldlen)); ! 266: if (i) ! 267: return i; ! 268: } ! 269: ! 270: return (error); ! 271: } ! 272: ! 273: /* ! 274: * Attributes stored in the kernel. ! 275: */ ! 276: extern char hostname[MAXHOSTNAMELEN]; /* defined in bsd/kern/init_main.c */ ! 277: extern int hostnamelen; ! 278: extern char domainname[MAXHOSTNAMELEN]; ! 279: extern int domainnamelen; ! 280: extern long hostid; ! 281: #ifdef INSECURE ! 282: int securelevel = -1; ! 283: #else ! 284: int securelevel; ! 285: #endif ! 286: ! 287: int get_kernel_symfile( struct proc *p, char **symfile ); ! 288: ! 289: /* ! 290: * kernel related system variables. ! 291: */ ! 292: kern_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p) ! 293: int *name; ! 294: u_int namelen; ! 295: void *oldp; ! 296: size_t *oldlenp; ! 297: void *newp; ! 298: size_t newlen; ! 299: struct proc *p; ! 300: { ! 301: int error, level, inthostid; ! 302: unsigned int oldval=0; ! 303: extern char ostype[], osrelease[], version[]; ! 304: ! 305: /* all sysctl names at this level are terminal */ ! 306: if (namelen != 1 && !(name[0] == KERN_PROC || name[0] == KERN_PROF ! 307: || name[0] == KERN_KDEBUG ! 308: || name[0] == KERN_PROCARGS ! 309: || name[0] == KERN_PCSAMPLES ! 310: )) ! 311: return (ENOTDIR); /* overloaded */ ! 312: ! 313: switch (name[0]) { ! 314: case KERN_OSTYPE: ! 315: return (sysctl_rdstring(oldp, oldlenp, newp, ostype)); ! 316: case KERN_OSRELEASE: ! 317: return (sysctl_rdstring(oldp, oldlenp, newp, osrelease)); ! 318: case KERN_OSREV: ! 319: return (sysctl_rdint(oldp, oldlenp, newp, BSD)); ! 320: case KERN_VERSION: ! 321: return (sysctl_rdstring(oldp, oldlenp, newp, version)); ! 322: case KERN_MAXVNODES: ! 323: oldval = desiredvnodes; ! 324: error = sysctl_int(oldp, oldlenp, newp, ! 325: newlen, &desiredvnodes); ! 326: reset_vmobjectcache(oldval, desiredvnodes); ! 327: return(error); ! 328: case KERN_MAXPROC: ! 329: return (sysctl_int(oldp, oldlenp, newp, newlen, &maxproc)); ! 330: case KERN_MAXFILES: ! 331: return (sysctl_int(oldp, oldlenp, newp, newlen, &maxfiles)); ! 332: case KERN_ARGMAX: ! 333: return (sysctl_rdint(oldp, oldlenp, newp, ARG_MAX)); ! 334: case KERN_SECURELVL: ! 335: level = securelevel; ! 336: if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &level)) || ! 337: newp == NULL) ! 338: return (error); ! 339: if (level < securelevel && p->p_pid != 1) ! 340: return (EPERM); ! 341: securelevel = level; ! 342: return (0); ! 343: case KERN_HOSTNAME: ! 344: error = sysctl_string(oldp, oldlenp, newp, newlen, ! 345: hostname, sizeof(hostname)); ! 346: if (newp && !error) ! 347: hostnamelen = newlen; ! 348: return (error); ! 349: case KERN_DOMAINNAME: ! 350: error = sysctl_string(oldp, oldlenp, newp, newlen, ! 351: domainname, sizeof(domainname)); ! 352: if (newp && !error) ! 353: domainnamelen = newlen; ! 354: return (error); ! 355: case KERN_HOSTID: ! 356: inthostid = hostid; /* XXX assumes sizeof long <= sizeof int */ ! 357: error = sysctl_int(oldp, oldlenp, newp, newlen, &inthostid); ! 358: hostid = inthostid; ! 359: return (error); ! 360: case KERN_CLOCKRATE: ! 361: return (sysctl_clockrate(oldp, oldlenp)); ! 362: #if FIXME /* [ */ ! 363: case KERN_BOOTTIME: ! 364: return (sysctl_rdstruct(oldp, oldlenp, newp, &boottime, ! 365: sizeof(struct timeval))); ! 366: #endif /* FIXME ] */ ! 367: case KERN_VNODE: ! 368: return (sysctl_vnode(oldp, oldlenp)); ! 369: case KERN_PROC: ! 370: return (sysctl_doproc(name + 1, namelen - 1, oldp, oldlenp)); ! 371: case KERN_FILE: ! 372: return (sysctl_file(oldp, oldlenp)); ! 373: #ifdef GPROF ! 374: case KERN_PROF: ! 375: return (sysctl_doprof(name + 1, namelen - 1, oldp, oldlenp, ! 376: newp, newlen)); ! 377: #endif ! 378: case KERN_POSIX1: ! 379: return (sysctl_rdint(oldp, oldlenp, newp, _POSIX_VERSION)); ! 380: case KERN_NGROUPS: ! 381: return (sysctl_rdint(oldp, oldlenp, newp, NGROUPS_MAX)); ! 382: case KERN_JOB_CONTROL: ! 383: return (sysctl_rdint(oldp, oldlenp, newp, 1)); ! 384: case KERN_SAVED_IDS: ! 385: #ifdef _POSIX_SAVED_IDS ! 386: return (sysctl_rdint(oldp, oldlenp, newp, 1)); ! 387: #else ! 388: return (sysctl_rdint(oldp, oldlenp, newp, 0)); ! 389: #endif ! 390: #if FIXME /* [ */ ! 391: case KERN_MAXPARTITIONS: ! 392: return (sysctl_rdint(oldp, oldlenp, newp, MAXPARTITIONS)); ! 393: #endif /* FIXME ] */ ! 394: case KERN_KDEBUG: ! 395: return (kdebug_ops(name + 1, namelen - 1, oldp, oldlenp, p)); ! 396: case KERN_PCSAMPLES: ! 397: return (pcsamples_control(name+1, namelen-1, oldp, oldlenp)); ! 398: case KERN_PROCARGS: ! 399: /* new one as it does not use kinfo_proc */ ! 400: return (sysctl_procargs(name + 1, namelen - 1, oldp, oldlenp)); ! 401: case KERN_SYMFILE: ! 402: { ! 403: char *str; ! 404: error = get_kernel_symfile( p, &str ); ! 405: if ( error ) return error; ! 406: return (sysctl_rdstring(oldp, oldlenp, newp, str)); ! 407: } ! 408: default: ! 409: return (EOPNOTSUPP); ! 410: } ! 411: /* NOTREACHED */ ! 412: } ! 413: ! 414: /* ! 415: * hardware related system variables. ! 416: */ ! 417: hw_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p) ! 418: int *name; ! 419: u_int namelen; ! 420: void *oldp; ! 421: size_t *oldlenp; ! 422: void *newp; ! 423: size_t newlen; ! 424: struct proc *p; ! 425: { ! 426: char dummy[65]; ! 427: int epochTemp; ! 428: extern int vm_page_wire_count; ! 429: ! 430: ! 431: /* all sysctl names at this level are terminal */ ! 432: if (namelen != 1) ! 433: return (ENOTDIR); /* overloaded */ ! 434: ! 435: switch (name[0]) { ! 436: case HW_MACHINE: ! 437: if(!PEGetMachineName(dummy,64)) ! 438: return(EINVAL); ! 439: return (sysctl_rdstring(oldp, oldlenp, newp, dummy)); ! 440: case HW_MODEL: ! 441: if(!PEGetModelName(dummy,64)) ! 442: return(EINVAL); ! 443: return (sysctl_rdstring(oldp, oldlenp, newp, dummy)); ! 444: case HW_NCPU: ! 445: return (sysctl_rdint(oldp, oldlenp, newp, 1)); /* XXX */ ! 446: case HW_BYTEORDER: ! 447: return (sysctl_rdint(oldp, oldlenp, newp, BYTE_ORDER)); ! 448: case HW_PHYSMEM: ! 449: return (sysctl_rdint(oldp, oldlenp, newp, mem_size)); ! 450: case HW_USERMEM: ! 451: return (sysctl_rdint(oldp, oldlenp, newp, ! 452: (mem_size - vm_page_wire_count * page_size))); ! 453: case HW_PAGESIZE: ! 454: return (sysctl_rdint(oldp, oldlenp, newp, page_size)); ! 455: case HW_EPOCH: ! 456: epochTemp = PEGetPlatformEpoch(); ! 457: if (epochTemp == -1) return(EINVAL); ! 458: return (sysctl_rdint(oldp, oldlenp, newp, epochTemp)); ! 459: default: ! 460: return (EOPNOTSUPP); ! 461: } ! 462: } ! 463: ! 464: #ifdef DEBUG ! 465: /* ! 466: * Debugging related system variables. ! 467: */ ! 468: #if DIAGNOSTIC ! 469: extern ! 470: #endif /* DIAGNOSTIC */ ! 471: struct ctldebug debug0, debug1; ! 472: struct ctldebug debug2, debug3, debug4; ! 473: struct ctldebug debug5, debug6, debug7, debug8, debug9; ! 474: struct ctldebug debug10, debug11, debug12, debug13, debug14; ! 475: struct ctldebug debug15, debug16, debug17, debug18, debug19; ! 476: static struct ctldebug *debugvars[CTL_DEBUG_MAXID] = { ! 477: &debug0, &debug1, &debug2, &debug3, &debug4, ! 478: &debug5, &debug6, &debug7, &debug8, &debug9, ! 479: &debug10, &debug11, &debug12, &debug13, &debug14, ! 480: &debug15, &debug16, &debug17, &debug18, &debug19, ! 481: }; ! 482: int ! 483: debug_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p) ! 484: int *name; ! 485: u_int namelen; ! 486: void *oldp; ! 487: size_t *oldlenp; ! 488: void *newp; ! 489: size_t newlen; ! 490: struct proc *p; ! 491: { ! 492: struct ctldebug *cdp; ! 493: ! 494: /* all sysctl names at this level are name and field */ ! 495: if (namelen != 2) ! 496: return (ENOTDIR); /* overloaded */ ! 497: cdp = debugvars[name[0]]; ! 498: if (cdp->debugname == 0) ! 499: return (EOPNOTSUPP); ! 500: switch (name[1]) { ! 501: case CTL_DEBUG_NAME: ! 502: return (sysctl_rdstring(oldp, oldlenp, newp, cdp->debugname)); ! 503: case CTL_DEBUG_VALUE: ! 504: return (sysctl_int(oldp, oldlenp, newp, newlen, cdp->debugvar)); ! 505: default: ! 506: return (EOPNOTSUPP); ! 507: } ! 508: /* NOTREACHED */ ! 509: } ! 510: #endif /* DEBUG */ ! 511: ! 512: /* ! 513: * Validate parameters and get old / set new parameters ! 514: * for an integer-valued sysctl function. ! 515: */ ! 516: sysctl_int(oldp, oldlenp, newp, newlen, valp) ! 517: void *oldp; ! 518: size_t *oldlenp; ! 519: void *newp; ! 520: size_t newlen; ! 521: int *valp; ! 522: { ! 523: int error = 0; ! 524: ! 525: if (oldp && *oldlenp < sizeof(int)) ! 526: return (ENOMEM); ! 527: if (newp && newlen != sizeof(int)) ! 528: return (EINVAL); ! 529: *oldlenp = sizeof(int); ! 530: if (oldp) ! 531: error = copyout(valp, oldp, sizeof(int)); ! 532: if (error == 0 && newp) ! 533: error = copyin(newp, valp, sizeof(int)); ! 534: return (error); ! 535: } ! 536: ! 537: /* ! 538: * As above, but read-only. ! 539: */ ! 540: sysctl_rdint(oldp, oldlenp, newp, val) ! 541: void *oldp; ! 542: size_t *oldlenp; ! 543: void *newp; ! 544: int val; ! 545: { ! 546: int error = 0; ! 547: ! 548: if (oldp && *oldlenp < sizeof(int)) ! 549: return (ENOMEM); ! 550: if (newp) ! 551: return (EPERM); ! 552: *oldlenp = sizeof(int); ! 553: if (oldp) ! 554: error = copyout((caddr_t)&val, oldp, sizeof(int)); ! 555: return (error); ! 556: } ! 557: ! 558: /* ! 559: * Validate parameters and get old / set new parameters ! 560: * for a string-valued sysctl function. ! 561: */ ! 562: sysctl_string(oldp, oldlenp, newp, newlen, str, maxlen) ! 563: void *oldp; ! 564: size_t *oldlenp; ! 565: void *newp; ! 566: size_t newlen; ! 567: char *str; ! 568: int maxlen; ! 569: { ! 570: int len, error = 0; ! 571: ! 572: len = strlen(str) + 1; ! 573: if (oldp && *oldlenp < len) ! 574: return (ENOMEM); ! 575: if (newp && newlen >= maxlen) ! 576: return (EINVAL); ! 577: if (oldp) { ! 578: *oldlenp = len; ! 579: error = copyout(str, oldp, len); ! 580: } ! 581: if (error == 0 && newp) { ! 582: error = copyin(newp, str, newlen); ! 583: str[newlen] = 0; ! 584: } ! 585: return (error); ! 586: } ! 587: ! 588: /* ! 589: * As above, but read-only. ! 590: */ ! 591: sysctl_rdstring(oldp, oldlenp, newp, str) ! 592: void *oldp; ! 593: size_t *oldlenp; ! 594: void *newp; ! 595: char *str; ! 596: { ! 597: int len, error = 0; ! 598: ! 599: len = strlen(str) + 1; ! 600: if (oldp && *oldlenp < len) ! 601: return (ENOMEM); ! 602: if (newp) ! 603: return (EPERM); ! 604: *oldlenp = len; ! 605: if (oldp) ! 606: error = copyout(str, oldp, len); ! 607: return (error); ! 608: } ! 609: ! 610: /* ! 611: * Validate parameters and get old / set new parameters ! 612: * for a structure oriented sysctl function. ! 613: */ ! 614: sysctl_struct(oldp, oldlenp, newp, newlen, sp, len) ! 615: void *oldp; ! 616: size_t *oldlenp; ! 617: void *newp; ! 618: size_t newlen; ! 619: void *sp; ! 620: int len; ! 621: { ! 622: int error = 0; ! 623: ! 624: if (oldp && *oldlenp < len) ! 625: return (ENOMEM); ! 626: if (newp && newlen > len) ! 627: return (EINVAL); ! 628: if (oldp) { ! 629: *oldlenp = len; ! 630: error = copyout(sp, oldp, len); ! 631: } ! 632: if (error == 0 && newp) ! 633: error = copyin(newp, sp, len); ! 634: return (error); ! 635: } ! 636: ! 637: /* ! 638: * Validate parameters and get old parameters ! 639: * for a structure oriented sysctl function. ! 640: */ ! 641: sysctl_rdstruct(oldp, oldlenp, newp, sp, len) ! 642: void *oldp; ! 643: size_t *oldlenp; ! 644: void *newp, *sp; ! 645: int len; ! 646: { ! 647: int error = 0; ! 648: ! 649: if (oldp && *oldlenp < len) ! 650: return (ENOMEM); ! 651: if (newp) ! 652: return (EPERM); ! 653: *oldlenp = len; ! 654: if (oldp) ! 655: error = copyout(sp, oldp, len); ! 656: return (error); ! 657: } ! 658: ! 659: /* ! 660: * Get file structures. ! 661: */ ! 662: sysctl_file(where, sizep) ! 663: char *where; ! 664: size_t *sizep; ! 665: { ! 666: int buflen, error; ! 667: struct file *fp; ! 668: char *start = where; ! 669: ! 670: buflen = *sizep; ! 671: if (where == NULL) { ! 672: /* ! 673: * overestimate by 10 files ! 674: */ ! 675: *sizep = sizeof(filehead) + (nfiles + 10) * sizeof(struct file); ! 676: return (0); ! 677: } ! 678: ! 679: /* ! 680: * first copyout filehead ! 681: */ ! 682: if (buflen < sizeof(filehead)) { ! 683: *sizep = 0; ! 684: return (0); ! 685: } ! 686: if (error = copyout((caddr_t)&filehead, where, sizeof(filehead))) ! 687: return (error); ! 688: buflen -= sizeof(filehead); ! 689: where += sizeof(filehead); ! 690: ! 691: /* ! 692: * followed by an array of file structures ! 693: */ ! 694: for (fp = filehead.lh_first; fp != 0; fp = fp->f_list.le_next) { ! 695: if (buflen < sizeof(struct file)) { ! 696: *sizep = where - start; ! 697: return (ENOMEM); ! 698: } ! 699: if (error = copyout((caddr_t)fp, where, sizeof (struct file))) ! 700: return (error); ! 701: buflen -= sizeof(struct file); ! 702: where += sizeof(struct file); ! 703: } ! 704: *sizep = where - start; ! 705: return (0); ! 706: } ! 707: ! 708: /* ! 709: * try over estimating by 5 procs ! 710: */ ! 711: #define KERN_PROCSLOP (5 * sizeof (struct kinfo_proc)) ! 712: ! 713: sysctl_doproc(name, namelen, where, sizep) ! 714: int *name; ! 715: u_int namelen; ! 716: char *where; ! 717: size_t *sizep; ! 718: { ! 719: register struct proc *p; ! 720: register struct kinfo_proc *dp = (struct kinfo_proc *)where; ! 721: register int needed = 0; ! 722: int buflen = where != NULL ? *sizep : 0; ! 723: int doingzomb; ! 724: struct kinfo_proc kproc; ! 725: int error = 0; ! 726: ! 727: if (namelen != 2 && !(namelen == 1 && name[0] == KERN_PROC_ALL)) ! 728: return (EINVAL); ! 729: p = allproc.lh_first; ! 730: doingzomb = 0; ! 731: again: ! 732: for (; p != 0; p = p->p_list.le_next) { ! 733: /* ! 734: * Skip embryonic processes. ! 735: */ ! 736: if (p->p_stat == SIDL) ! 737: continue; ! 738: /* ! 739: * TODO - make more efficient (see notes below). ! 740: * do by session. ! 741: */ ! 742: switch (name[0]) { ! 743: ! 744: case KERN_PROC_PID: ! 745: /* could do this with just a lookup */ ! 746: if (p->p_pid != (pid_t)name[1]) ! 747: continue; ! 748: break; ! 749: ! 750: case KERN_PROC_PGRP: ! 751: /* could do this by traversing pgrp */ ! 752: if (p->p_pgrp->pg_id != (pid_t)name[1]) ! 753: continue; ! 754: break; ! 755: ! 756: case KERN_PROC_TTY: ! 757: if ((p->p_flag & P_CONTROLT) == 0 || ! 758: p->p_session->s_ttyp == NULL || ! 759: p->p_session->s_ttyp->t_dev != (dev_t)name[1]) ! 760: continue; ! 761: break; ! 762: ! 763: case KERN_PROC_UID: ! 764: if (p->p_ucred->cr_uid != (uid_t)name[1]) ! 765: continue; ! 766: break; ! 767: ! 768: case KERN_PROC_RUID: ! 769: if (p->p_cred->p_ruid != (uid_t)name[1]) ! 770: continue; ! 771: break; ! 772: } ! 773: if (buflen >= sizeof(struct kinfo_proc)) { ! 774: fill_proc(p, &kproc); ! 775: if (error = copyout((caddr_t)&kproc, &dp->kp_proc, ! 776: sizeof(struct kinfo_proc))) ! 777: return (error); ! 778: dp++; ! 779: buflen -= sizeof(struct kinfo_proc); ! 780: } ! 781: needed += sizeof(struct kinfo_proc); ! 782: } ! 783: if (doingzomb == 0) { ! 784: p = zombproc.lh_first; ! 785: doingzomb++; ! 786: goto again; ! 787: } ! 788: if (where != NULL) { ! 789: *sizep = (caddr_t)dp - where; ! 790: if (needed > *sizep) ! 791: return (ENOMEM); ! 792: } else { ! 793: needed += KERN_PROCSLOP; ! 794: *sizep = needed; ! 795: } ! 796: return (0); ! 797: } ! 798: ! 799: void ! 800: fill_proc(p,kp) ! 801: register struct proc *p; ! 802: register struct kinfo_proc *kp; ! 803: { ! 804: fill_externproc(p, &kp->kp_proc); ! 805: fill_eproc(p, &kp->kp_eproc); ! 806: } ! 807: /* ! 808: * Fill in an eproc structure for the specified process. ! 809: */ ! 810: void ! 811: fill_eproc(p, ep) ! 812: register struct proc *p; ! 813: register struct eproc *ep; ! 814: { ! 815: register struct tty *tp; ! 816: ! 817: ep->e_paddr = p; ! 818: ep->e_sess = p->p_pgrp->pg_session; ! 819: ep->e_pcred = *p->p_cred; ! 820: ep->e_ucred = *p->p_ucred; ! 821: if (p->p_stat == SIDL || p->p_stat == SZOMB) { ! 822: ep->e_vm.vm_rssize = 0; ! 823: ep->e_vm.vm_tsize = 0; ! 824: ep->e_vm.vm_dsize = 0; ! 825: ep->e_vm.vm_ssize = 0; ! 826: /* ep->e_vm.vm_pmap = XXX; */ ! 827: } else { ! 828: #if FIXME /* [ */ ! 829: register vm_map_t vm = ((task_t)p->task)->map; ! 830: ! 831: ep->e_vm.vm_rssize = pmap_resident_count(vm->pmap); /*XXX*/ ! 832: // ep->e_vm.vm_tsize = vm->vm_tsize; ! 833: // ep->e_vm.vm_dsize = vm->vm_dsize; ! 834: // ep->e_vm.vm_ssize = vm->vm_ssize; ! 835: #else /* FIXME ][ */ ! 836: ep->e_vm.vm_rssize = 0; /*XXX*/ ! 837: #endif /* FIXME ] */ ! 838: } ! 839: if (p->p_pptr) ! 840: ep->e_ppid = p->p_pptr->p_pid; ! 841: else ! 842: ep->e_ppid = 0; ! 843: ep->e_pgid = p->p_pgrp->pg_id; ! 844: ep->e_jobc = p->p_pgrp->pg_jobc; ! 845: if ((p->p_flag & P_CONTROLT) && ! 846: (tp = ep->e_sess->s_ttyp)) { ! 847: ep->e_tdev = tp->t_dev; ! 848: ep->e_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID; ! 849: ep->e_tsess = tp->t_session; ! 850: } else ! 851: ep->e_tdev = NODEV; ! 852: ep->e_flag = ep->e_sess->s_ttyvp ? EPROC_CTTY : 0; ! 853: if (SESS_LEADER(p)) ! 854: ep->e_flag |= EPROC_SLEADER; ! 855: if (p->p_wmesg) ! 856: strncpy(ep->e_wmesg, p->p_wmesg, WMESGLEN); ! 857: ep->e_xsize = ep->e_xrssize = 0; ! 858: ep->e_xccount = ep->e_xswrss = 0; ! 859: } ! 860: /* ! 861: * Fill in an eproc structure for the specified process. ! 862: */ ! 863: void ! 864: fill_externproc(p, exp) ! 865: register struct proc *p; ! 866: register struct extern_proc *exp; ! 867: { ! 868: exp->p_forw = exp->p_back = NULL; ! 869: exp->p_vmspace = NULL; ! 870: exp->p_sigacts = p->p_sigacts; ! 871: exp->p_flag = p->p_flag; ! 872: exp->p_stat = p->p_stat ; ! 873: exp->p_pid = p->p_pid ; ! 874: exp->p_oppid = p->p_oppid ; ! 875: exp->p_dupfd = p->p_dupfd ; ! 876: /* Mach related */ ! 877: exp->user_stack = p->user_stack ; ! 878: exp->exit_thread = p->exit_thread ; ! 879: exp->p_debugger = p->p_debugger ; ! 880: exp->sigwait = p->sigwait ; ! 881: /* scheduling */ ! 882: exp->p_estcpu = p->p_estcpu ; ! 883: exp->p_cpticks = p->p_cpticks ; ! 884: exp->p_pctcpu = p->p_pctcpu ; ! 885: exp->p_wchan = p->p_wchan ; ! 886: exp->p_wmesg = p->p_wmesg ; ! 887: exp->p_swtime = p->p_swtime ; ! 888: exp->p_slptime = p->p_slptime ; ! 889: bcopy(&p->p_realtimer, &exp->p_realtimer,sizeof(struct itimerval)); ! 890: bcopy(&p->p_rtime, &exp->p_rtime,sizeof(struct timeval)); ! 891: exp->p_uticks = p->p_uticks ; ! 892: exp->p_sticks = p->p_sticks ; ! 893: exp->p_iticks = p->p_iticks ; ! 894: exp->p_traceflag = p->p_traceflag ; ! 895: exp->p_tracep = p->p_tracep ; ! 896: exp->p_siglist = p->p_siglist ; ! 897: exp->p_textvp = p->p_textvp ; ! 898: exp->p_holdcnt = 0 ; ! 899: exp->p_sigmask = p->p_sigmask ; ! 900: exp->p_sigignore = p->p_sigignore ; ! 901: exp->p_sigcatch = p->p_sigcatch ; ! 902: exp->p_priority = p->p_priority ; ! 903: exp->p_usrpri = p->p_usrpri ; ! 904: exp->p_nice = p->p_nice ; ! 905: bcopy(&p->p_comm, &exp->p_comm,MAXCOMLEN); ! 906: exp->p_comm[MAXCOMLEN] = '\0'; ! 907: exp->p_pgrp = p->p_pgrp ; ! 908: exp->p_addr = NULL; ! 909: exp->p_xstat = p->p_xstat ; ! 910: exp->p_acflag = p->p_acflag ; ! 911: exp->p_ru = p->p_ru ; ! 912: } ! 913: ! 914: kdebug_ops(name, namelen, where, sizep, p) ! 915: int *name; ! 916: u_int namelen; ! 917: char *where; ! 918: size_t *sizep; ! 919: struct proc *p; ! 920: { ! 921: int size=*sizep; ! 922: int ret=0; ! 923: extern int kdbg_control(int *name, u_int namelen, char * where,size_t * sizep); ! 924: ! 925: switch(name[0]) { ! 926: case KERN_KDEFLAGS: ! 927: case KERN_KDDFLAGS: ! 928: case KERN_KDENABLE: ! 929: case KERN_KDGETBUF: ! 930: case KERN_KDSETUP: ! 931: case KERN_KDREMOVE: ! 932: case KERN_KDSETREG: ! 933: case KERN_KDGETREG: ! 934: case KERN_KDREADTR: ! 935: case KERN_KDPIDTR: ! 936: case KERN_KDTHRMAP: ! 937: case KERN_KDPIDEX: ! 938: ret = kdbg_control(name, namelen, where, sizep); ! 939: break; ! 940: case KERN_KDSETRTCDEC: ! 941: case KERN_KDSETBUF: ! 942: if (ret = suser(p->p_ucred, &p->p_acflag)) ! 943: return(ret); ! 944: else ! 945: ret = kdbg_control(name, namelen, where, sizep); ! 946: break; ! 947: default: ! 948: ret= EOPNOTSUPP; ! 949: break; ! 950: } ! 951: return(ret); ! 952: } ! 953: ! 954: /* ! 955: * try over estimating by 5 procs ! 956: */ ! 957: #define KERN_PROCSLOP (5 * sizeof (struct kinfo_proc)) ! 958: ! 959: sysctl_procargs(name, namelen, where, sizep) ! 960: int *name; ! 961: u_int namelen; ! 962: char *where; ! 963: size_t *sizep; ! 964: { ! 965: register struct proc *p; ! 966: register int needed = 0; ! 967: int buflen = where != NULL ? *sizep : 0; ! 968: int error = 0; ! 969: struct vm_map *proc_map; ! 970: struct task * task; ! 971: vm_map_copy_t tmp; ! 972: vm_offset_t arg_addr; ! 973: vm_size_t arg_size; ! 974: caddr_t data; ! 975: unsigned size; ! 976: vm_offset_t copy_start, copy_end; ! 977: vm_offset_t dealloc_start; /* area to remove from kernel map */ ! 978: vm_offset_t dealloc_end; ! 979: int *ip; ! 980: kern_return_t ret; ! 981: int pid; ! 982: ! 983: ! 984: pid = name[0]; ! 985: ! 986: p = pfind(pid); ! 987: if (p == NULL) { ! 988: return(EINVAL); ! 989: } ! 990: ! 991: if (p->task == NULL) ! 992: return(EINVAL); ! 993: ! 994: arg_size = buflen; ! 995: /* ! 996: * Returns the top N bytes of the user stack, with ! 997: * everything below the first argument character ! 998: * zeroed for security reasons. ! 999: * Odd data structure is for compatibility. ! 1000: */ ! 1001: /* ! 1002: * Lookup process by pid ! 1003: */ ! 1004: /* ! 1005: * Get map for process ! 1006: */ ! 1007: proc_map = get_task_map((task_t)p->task); ! 1008: ! 1009: /* ! 1010: * Copy the top N bytes of the stack. ! 1011: * On all machines we have so far, the stack grows ! 1012: * downwards. ! 1013: * ! 1014: * If the user expects no more than N bytes of ! 1015: * argument list, use that as a guess for the ! 1016: * size. ! 1017: */ ! 1018: ! 1019: if (buflen == 0) { ! 1020: return(EINVAL); ! 1021: } ! 1022: ! 1023: if (!p->user_stack) ! 1024: return(EINVAL); ! 1025: ! 1026: #if STACK_GROWTH_UP ! 1027: arg_addr = p->user_stack; ! 1028: #else STACK_GROWTH_UP ! 1029: arg_addr = p->user_stack - arg_size; ! 1030: #endif /* STACK_GROWTH_UP */ ! 1031: ! 1032: /* ! 1033: * Before we can block (any VM code), make another ! 1034: * reference to the map to keep it alive. ! 1035: */ ! 1036: ! 1037: ret = kmem_alloc_pageable(bsd_pageable_map, ©_start, ! 1038: round_page(arg_size)); ! 1039: if (ret != KERN_SUCCESS) ! 1040: return(ENOMEM); ! 1041: ! 1042: copy_end = round_page(copy_start + arg_size); ! 1043: ! 1044: /* vm_map_reference(proc_map); */ ! 1045: ! 1046: if( vm_map_copyin(proc_map, trunc_page(arg_addr), round_page(arg_size), ! 1047: FALSE, &tmp) != KERN_SUCCESS) { ! 1048: kmem_free(bsd_pageable_map, copy_start, ! 1049: round_page(arg_size)); ! 1050: /* vm_map_deallocate(proc_map); */ ! 1051: return (EIO); ! 1052: } ! 1053: if( vm_map_copy_overwrite(bsd_pageable_map, copy_start, ! 1054: tmp, FALSE) != KERN_SUCCESS) { ! 1055: kmem_free(bsd_pageable_map, copy_start, ! 1056: round_page(arg_size)); ! 1057: /* vm_map_deallocate(proc_map); */ ! 1058: return (EIO); ! 1059: } ! 1060: ! 1061: /* ! 1062: * Now that we've done the copy, we can release ! 1063: * the process' map. ! 1064: */ ! 1065: /* vm_map_deallocate(proc_map); */ ! 1066: ! 1067: #if STACK_GROWTH_UP ! 1068: data = (caddr_t)copy_start; ! 1069: ip = (int *) ((*(int *)copy_start) - arg_addr + data); ! 1070: /* ! 1071: * sanity check ip since it comes from user-accessible ! 1072: * stack area ! 1073: */ ! 1074: if (((vm_offset_t)ip > copy_end) || ! 1075: ((vm_offset_t)ip < copy_start)) ! 1076: ip = (int *)copy_end; ! 1077: /* ! 1078: * relocate so that end of string area is at end ! 1079: * of buffer. ! 1080: */ ! 1081: size = (unsigned) ((int)ip - (int)copy_start); ! 1082: data = (caddr_t)(copy_end - size); ! 1083: bcopy(copy_start, data, size); ! 1084: /* ! 1085: * now find beginning of string area so we can ! 1086: * clear out data user should not see ! 1087: */ ! 1088: ip = (int *)copy_end; // start at new end ! 1089: ip -= 2; /*skip trailing 0 word and assume at least one ! 1090: argument. The last word of argN may be just ! 1091: the trailing 0, in which case we'd stop ! 1092: there */ ! 1093: while (*--ip) ! 1094: if (ip == (int *)data) ! 1095: break; ! 1096: bzero(copy_start, ! 1097: (unsigned) ((int)ip - (int)copy_start)); ! 1098: /* ! 1099: * now prepare data/size for the copy's out of the ! 1100: * switch. We copy the last arg_size bytes from ! 1101: * our data. ! 1102: */ ! 1103: size = arg_size; ! 1104: data = (caddr_t)(copy_end - size); ! 1105: #else STACK_GROWTH_UP ! 1106: data = (caddr_t) (copy_end - arg_size); ! 1107: ip = (int *) copy_end; ! 1108: size = arg_size; ! 1109: ! 1110: /* ! 1111: * Now look down the stack for the bottom of the ! 1112: * argument list. Since this call is otherwise ! 1113: * unprotected, we can't let the nosy user see ! 1114: * anything else on the stack. ! 1115: * ! 1116: * The arguments are pushed on the stack by ! 1117: * execve() as: ! 1118: * ! 1119: * .long 0 ! 1120: * arg 0 (null-terminated) ! 1121: * arg 1 ! 1122: * ... ! 1123: * arg N ! 1124: * .long 0 ! 1125: * ! 1126: */ ! 1127: ! 1128: ip -= 2; /*skip trailing 0 word and assume at least one ! 1129: argument. The last word of argN may be just ! 1130: the trailing 0, in which case we'd stop ! 1131: there */ ! 1132: while (*--ip) ! 1133: if (ip == (int *)data) ! 1134: break; ! 1135: bzero(data, (unsigned) ((int)ip - (int)data)); ! 1136: #endif /* STACK_GROWTH_UP */ ! 1137: ! 1138: dealloc_start = copy_start; ! 1139: dealloc_end = copy_end; ! 1140: ! 1141: ! 1142: size = MIN(size, buflen); ! 1143: error = copyout(data, where, size); ! 1144: ! 1145: if (dealloc_start != (vm_offset_t) 0) { ! 1146: kmem_free(bsd_pageable_map, dealloc_start, ! 1147: dealloc_end - dealloc_start); ! 1148: } ! 1149: if (error) { ! 1150: return(error); ! 1151: } ! 1152: ! 1153: if (where != NULL) ! 1154: *sizep = size; ! 1155: return (0); ! 1156: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.