![[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 Darwin 0.x] / kernel / bsd / kern|
Return to kern_sysctl.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / kern |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
26: /*-
27: * Copyright (c) 1982, 1986, 1989, 1993
28: * The Regents of the University of California. All rights reserved.
29: *
30: * This code is derived from software contributed to Berkeley by
31: * Mike Karels at Berkeley Software Design, Inc.
32: *
33: * Redistribution and use in source and binary forms, with or without
34: * modification, are permitted provided that the following conditions
35: * are met:
36: * 1. Redistributions of source code must retain the above copyright
37: * notice, this list of conditions and the following disclaimer.
38: * 2. Redistributions in binary form must reproduce the above copyright
39: * notice, this list of conditions and the following disclaimer in the
40: * documentation and/or other materials provided with the distribution.
41: * 3. All advertising materials mentioning features or use of this software
42: * must display the following acknowledgement:
43: * This product includes software developed by the University of
44: * California, Berkeley and its contributors.
45: * 4. Neither the name of the University nor the names of its contributors
46: * may be used to endorse or promote products derived from this software
47: * without specific prior written permission.
48: *
49: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59: * SUCH DAMAGE.
60: *
61: * @(#)kern_sysctl.c 8.4 (Berkeley) 4/14/94
62: */
63:
64: /*
65: * sysctl system call.
66: */
67:
68: #include <sys/param.h>
69: #include <sys/systm.h>
70: #include <sys/kernel.h>
71: #include <sys/malloc.h>
72: #include <sys/proc.h>
73: #include <sys/file.h>
74: #include <sys/vnode.h>
75: #include <sys/unistd.h>
76: #include <sys/buf.h>
77: #include <sys/ioctl.h>
78: #include <sys/tty.h>
79: #include <sys/disklabel.h>
80: #include <sys/vm.h>
81: #include <sys/sysctl.h>
82:
83: #include <sys/mount.h>
84: #include <kdebug.h>
85: #if KDEBUG
86: #import <kern/kdebug.h>
87: #endif
88:
89: #ifdef __ppc__
90: #include <machdep/ppc/powermac.h>
91: #endif
92:
93: sysctlfn kern_sysctl;
94: sysctlfn hw_sysctl;
95: #ifdef DEBUG
96: sysctlfn debug_sysctl;
97: #endif
98: extern sysctlfn vm_sysctl;
99: extern sysctlfn vfs_sysctl;
100: extern sysctlfn net_sysctl;
101: extern sysctlfn cpu_sysctl;
102:
103: /*
104: * temporary location for vm_sysctl. This should be machine independant
105: */
106: vm_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
107: int *name;
108: u_int namelen;
109: void *oldp;
110: size_t *oldlenp;
111: void *newp;
112: size_t newlen;
113: struct proc *p;
114: {
115: int error, level, inthostid;
116: extern long avenrun[3], mach_factor[3];
117: struct loadavg loadinfo;
118:
119: //if (namelen != 1 && !(name[0] == VM_LOADAVG))
120: //return (ENOTDIR); /* overloaded */
121:
122: switch (name[0]) {
123: case VM_LOADAVG:
124: loadinfo.ldavg[0] = avenrun[0];
125: loadinfo.ldavg[1] = avenrun[1];
126: loadinfo.ldavg[2] = avenrun[2];
127: loadinfo.fscale = LSCALE;
128: return (sysctl_struct(oldp, oldlenp, newp, newlen, &loadinfo, sizeof(struct loadavg)));
129: case VM_MACHFACTOR:
130: loadinfo.ldavg[0] = mach_factor[0];
131: loadinfo.ldavg[1] = mach_factor[1];
132: loadinfo.ldavg[2] = mach_factor[2];
133: loadinfo.fscale = LSCALE;
134: return (sysctl_struct(oldp, oldlenp, newp, newlen, &loadinfo, sizeof(struct loadavg)));
135: case VM_METER:
136: return (EOPNOTSUPP);
137: case VM_MAXID:
138: return (EOPNOTSUPP);
139: default:
140: return (EOPNOTSUPP);
141: }
142: /* NOTREACHED */
143: return (EOPNOTSUPP);
144: }
145:
146: /*
147: * Locking and stats
148: */
149: static struct sysctl_lock {
150: int sl_lock;
151: int sl_want;
152: int sl_locked;
153: } memlock;
154:
155: struct __sysctl_args {
156: int *name;
157: u_int namelen;
158: void *old;
159: size_t *oldlenp;
160: void *new;
161: size_t newlen;
162: };
163: int
164: __sysctl(p, uap, retval)
165: struct proc *p;
166: register struct __sysctl_args *uap;
167: register_t *retval;
168: {
169: int error, dolock = 1;
170: size_t savelen, oldlen = 0;
171: sysctlfn *fn;
172: int name[CTL_MAXNAME];
173:
174: if (uap->new != NULL &&
175: (error = suser(p->p_ucred, &p->p_acflag)))
176: return (error);
177: /*
178: * all top-level sysctl names are non-terminal
179: */
180: if (uap->namelen > CTL_MAXNAME || uap->namelen < 2)
181: return (EINVAL);
182: if (error =
183: copyin(uap->name, &name, uap->namelen * sizeof(int)))
184: return (error);
185:
186: switch (name[0]) {
187: case CTL_KERN:
188: fn = kern_sysctl;
189: if (name[2] != KERN_VNODE) /* XXX */
190: dolock = 0;
191: break;
192: case CTL_HW:
193: fn = hw_sysctl;
194: break;
195: case CTL_VM:
196: fn = vm_sysctl;
197: break;
198: case CTL_NET:
199: fn = net_sysctl;
200: break;
201: case CTL_VFS:
202: fn = vfs_sysctl;
203: break;
204: case CTL_MACHDEP:
205: fn = cpu_sysctl;
206: break;
207: #ifdef DEBUG
208: case CTL_DEBUG:
209: fn = debug_sysctl;
210: break;
211: #endif
212: default:
213: return (EOPNOTSUPP);
214: }
215:
216: if (uap->oldlenp &&
217: (error = copyin(uap->oldlenp, &oldlen, sizeof(oldlen))))
218: return (error);
219: if (uap->old != NULL) {
220: if (!useracc(uap->old, oldlen, B_WRITE))
221: return (EFAULT);
222: while (memlock.sl_lock) {
223: memlock.sl_want = 1;
224: sleep((caddr_t)&memlock, PRIBIO+1);
225: memlock.sl_locked++;
226: }
227: memlock.sl_lock = 1;
228: if (dolock)
229: vslock(uap->old, oldlen);
230: savelen = oldlen;
231: }
232: error = (*fn)(name + 1, uap->namelen - 1, uap->old,
233: &oldlen, uap->new, uap->newlen, p);
234: if (uap->old != NULL) {
235: if (dolock)
236: vsunlock(uap->old, savelen, B_WRITE);
237: memlock.sl_lock = 0;
238: if (memlock.sl_want) {
239: memlock.sl_want = 0;
240: wakeup((caddr_t)&memlock);
241: }
242: }
243: if (error)
244: return (error);
245: if (uap->oldlenp)
246: error = copyout(&oldlen, uap->oldlenp, sizeof(oldlen));
247: *retval = oldlen;
248: return (0);
249: }
250:
251: /*
252: * Attributes stored in the kernel.
253: */
254: extern char hostname[MAXHOSTNAMELEN]; /* defined in bsd/kern/init_main.c */
255: extern int hostnamelen;
256: extern char domainname[MAXHOSTNAMELEN];
257: extern int domainnamelen;
258: extern long hostid;
259: #ifdef INSECURE
260: int securelevel = -1;
261: #else
262: int securelevel;
263: #endif
264:
265: /*
266: * kernel related system variables.
267: */
268: kern_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
269: int *name;
270: u_int namelen;
271: void *oldp;
272: size_t *oldlenp;
273: void *newp;
274: size_t newlen;
275: struct proc *p;
276: {
277: int error, level, inthostid;
278: unsigned int oldval=0;
279: extern char ostype[], osrelease[], version[];
280:
281: /* all sysctl names at this level are terminal */
282: if (namelen != 1 && !(name[0] == KERN_PROC || name[0] == KERN_PROF
283: #if KDEBUG
284: || name[0] == KERN_KDEBUG
285: #endif
286: ))
287: return (ENOTDIR); /* overloaded */
288:
289: switch (name[0]) {
290: case KERN_OSTYPE:
291: return (sysctl_rdstring(oldp, oldlenp, newp, ostype));
292: case KERN_OSRELEASE:
293: return (sysctl_rdstring(oldp, oldlenp, newp, osrelease));
294: case KERN_OSREV:
295: return (sysctl_rdint(oldp, oldlenp, newp, BSD));
296: case KERN_VERSION:
297: return (sysctl_rdstring(oldp, oldlenp, newp, version));
298: case KERN_MAXVNODES:
299: oldval = desiredvnodes;
300: error = sysctl_int(oldp, oldlenp, newp,
301: newlen, &desiredvnodes);
302: reset_vmobjectcache(oldval, desiredvnodes);
303: return(error);
304: case KERN_MAXPROC:
305: return (sysctl_int(oldp, oldlenp, newp, newlen, &maxproc));
306: case KERN_MAXFILES:
307: return (sysctl_int(oldp, oldlenp, newp, newlen, &maxfiles));
308: case KERN_ARGMAX:
309: return (sysctl_rdint(oldp, oldlenp, newp, ARG_MAX));
310: case KERN_SECURELVL:
311: level = securelevel;
312: if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &level)) ||
313: newp == NULL)
314: return (error);
315: if (level < securelevel && p->p_pid != 1)
316: return (EPERM);
317: securelevel = level;
318: return (0);
319: case KERN_HOSTNAME:
320: error = sysctl_string(oldp, oldlenp, newp, newlen,
321: hostname, sizeof(hostname));
322: if (newp && !error)
323: hostnamelen = newlen;
324: return (error);
325: case KERN_DOMAINNAME:
326: error = sysctl_string(oldp, oldlenp, newp, newlen,
327: domainname, sizeof(domainname));
328: if (newp && !error)
329: domainnamelen = newlen;
330: return (error);
331: case KERN_HOSTID:
332: inthostid = hostid; /* XXX assumes sizeof long <= sizeof int */
333: error = sysctl_int(oldp, oldlenp, newp, newlen, &inthostid);
334: hostid = inthostid;
335: return (error);
336: case KERN_CLOCKRATE:
337: return (sysctl_clockrate(oldp, oldlenp));
338: case KERN_BOOTTIME:
339: return (sysctl_rdstruct(oldp, oldlenp, newp, &boottime,
340: sizeof(struct timeval)));
341: case KERN_VNODE:
342: return (sysctl_vnode(oldp, oldlenp));
343: case KERN_PROC:
344: return (sysctl_doproc(name + 1, namelen - 1, oldp, oldlenp));
345: case KERN_FILE:
346: return (sysctl_file(oldp, oldlenp));
347: #ifdef GPROF
348: case KERN_PROF:
349: return (sysctl_doprof(name + 1, namelen - 1, oldp, oldlenp,
350: newp, newlen));
351: #endif
352: case KERN_POSIX1:
353: return (sysctl_rdint(oldp, oldlenp, newp, _POSIX_VERSION));
354: case KERN_NGROUPS:
355: return (sysctl_rdint(oldp, oldlenp, newp, NGROUPS_MAX));
356: case KERN_JOB_CONTROL:
357: return (sysctl_rdint(oldp, oldlenp, newp, 1));
358: case KERN_SAVED_IDS:
359: #ifdef _POSIX_SAVED_IDS
360: return (sysctl_rdint(oldp, oldlenp, newp, 1));
361: #else
362: return (sysctl_rdint(oldp, oldlenp, newp, 0));
363: #endif
364: case KERN_MAXPARTITIONS:
365: return (sysctl_rdint(oldp, oldlenp, newp, MAXPARTITIONS));
366: #if KDEBUG
367: case KERN_KDEBUG:
368: return (kdebug_ops(name + 1, namelen - 1, oldp, oldlenp));
369: #endif /* KDEBUG */
370: default:
371: return (EOPNOTSUPP);
372: }
373: /* NOTREACHED */
374: }
375:
376: /*
377: * hardware related system variables.
378: */
379: hw_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
380: int *name;
381: u_int namelen;
382: void *oldp;
383: size_t *oldlenp;
384: void *newp;
385: size_t newlen;
386: struct proc *p;
387: {
388: extern char machine[], cpu_model[];
389:
390: /* all sysctl names at this level are terminal */
391: if (namelen != 1)
392: return (ENOTDIR); /* overloaded */
393:
394: switch (name[0]) {
395: case HW_MACHINE:
396: return (sysctl_rdstring(oldp, oldlenp, newp, machine));
397: case HW_MODEL:
398: return (sysctl_rdstring(oldp, oldlenp, newp, cpu_model));
399: case HW_NCPU:
400: return (sysctl_rdint(oldp, oldlenp, newp, 1)); /* XXX */
401: case HW_BYTEORDER:
402: return (sysctl_rdint(oldp, oldlenp, newp, BYTE_ORDER));
403: case HW_PHYSMEM:
404: return (sysctl_rdint(oldp, oldlenp, newp, mem_size));
405: case HW_USERMEM:
406: return (sysctl_rdint(oldp, oldlenp, newp,
407: (mem_size - vm_page_wire_count * PAGE_SIZE)));
408: case HW_PAGESIZE:
409: return (sysctl_rdint(oldp, oldlenp, newp, PAGE_SIZE));
410: #ifdef __ppc__
411: case HW_NEWWORLD:
412: return (sysctl_rdint(oldp, oldlenp, newp, IsYosemite()));
413: #endif
414: default:
415: return (EOPNOTSUPP);
416: }
417: /* NOTREACHED */
418: }
419:
420: #ifdef DEBUG
421: /*
422: * Debugging related system variables.
423: */
424: #if DIAGNOSTIC
425: extern
426: #endif /* DIAGNOSTIC */
427: struct ctldebug debug0, debug1;
428: extern struct ctldebug debug2; /* dev/ppc/drvCuda needs var to debug ADB */
429: struct ctldebug debug3, debug4;
430: struct ctldebug debug5, debug6, debug7, debug8, debug9;
431: struct ctldebug debug10, debug11, debug12, debug13, debug14;
432: struct ctldebug debug15, debug16, debug17, debug18, debug19;
433: static struct ctldebug *debugvars[CTL_DEBUG_MAXID] = {
434: &debug0, &debug1, &debug2, &debug3, &debug4,
435: &debug5, &debug6, &debug7, &debug8, &debug9,
436: &debug10, &debug11, &debug12, &debug13, &debug14,
437: &debug15, &debug16, &debug17, &debug18, &debug19,
438: };
439: int
440: debug_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
441: int *name;
442: u_int namelen;
443: void *oldp;
444: size_t *oldlenp;
445: void *newp;
446: size_t newlen;
447: struct proc *p;
448: {
449: struct ctldebug *cdp;
450:
451: /* all sysctl names at this level are name and field */
452: if (namelen != 2)
453: return (ENOTDIR); /* overloaded */
454: cdp = debugvars[name[0]];
455: if (cdp->debugname == 0)
456: return (EOPNOTSUPP);
457: switch (name[1]) {
458: case CTL_DEBUG_NAME:
459: return (sysctl_rdstring(oldp, oldlenp, newp, cdp->debugname));
460: case CTL_DEBUG_VALUE:
461: return (sysctl_int(oldp, oldlenp, newp, newlen, cdp->debugvar));
462: default:
463: return (EOPNOTSUPP);
464: }
465: /* NOTREACHED */
466: }
467: #endif /* DEBUG */
468:
469: /*
470: * Validate parameters and get old / set new parameters
471: * for an integer-valued sysctl function.
472: */
473: sysctl_int(oldp, oldlenp, newp, newlen, valp)
474: void *oldp;
475: size_t *oldlenp;
476: void *newp;
477: size_t newlen;
478: int *valp;
479: {
480: int error = 0;
481:
482: if (oldp && *oldlenp < sizeof(int))
483: return (ENOMEM);
484: if (newp && newlen != sizeof(int))
485: return (EINVAL);
486: *oldlenp = sizeof(int);
487: if (oldp)
488: error = copyout(valp, oldp, sizeof(int));
489: if (error == 0 && newp)
490: error = copyin(newp, valp, sizeof(int));
491: return (error);
492: }
493:
494: /*
495: * As above, but read-only.
496: */
497: sysctl_rdint(oldp, oldlenp, newp, val)
498: void *oldp;
499: size_t *oldlenp;
500: void *newp;
501: int val;
502: {
503: int error = 0;
504:
505: if (oldp && *oldlenp < sizeof(int))
506: return (ENOMEM);
507: if (newp)
508: return (EPERM);
509: *oldlenp = sizeof(int);
510: if (oldp)
511: error = copyout((caddr_t)&val, oldp, sizeof(int));
512: return (error);
513: }
514:
515: /*
516: * Validate parameters and get old / set new parameters
517: * for a string-valued sysctl function.
518: */
519: sysctl_string(oldp, oldlenp, newp, newlen, str, maxlen)
520: void *oldp;
521: size_t *oldlenp;
522: void *newp;
523: size_t newlen;
524: char *str;
525: int maxlen;
526: {
527: int len, error = 0;
528:
529: len = strlen(str) + 1;
530: if (oldp && *oldlenp < len)
531: return (ENOMEM);
532: if (newp && newlen >= maxlen)
533: return (EINVAL);
534: if (oldp) {
535: *oldlenp = len;
536: error = copyout(str, oldp, len);
537: }
538: if (error == 0 && newp) {
539: error = copyin(newp, str, newlen);
540: str[newlen] = 0;
541: }
542: return (error);
543: }
544:
545: /*
546: * As above, but read-only.
547: */
548: sysctl_rdstring(oldp, oldlenp, newp, str)
549: void *oldp;
550: size_t *oldlenp;
551: void *newp;
552: char *str;
553: {
554: int len, error = 0;
555:
556: len = strlen(str) + 1;
557: if (oldp && *oldlenp < len)
558: return (ENOMEM);
559: if (newp)
560: return (EPERM);
561: *oldlenp = len;
562: if (oldp)
563: error = copyout(str, oldp, len);
564: return (error);
565: }
566:
567: /*
568: * Validate parameters and get old / set new parameters
569: * for a structure oriented sysctl function.
570: */
571: sysctl_struct(oldp, oldlenp, newp, newlen, sp, len)
572: void *oldp;
573: size_t *oldlenp;
574: void *newp;
575: size_t newlen;
576: void *sp;
577: int len;
578: {
579: int error = 0;
580:
581: if (oldp && *oldlenp < len)
582: return (ENOMEM);
583: if (newp && newlen > len)
584: return (EINVAL);
585: if (oldp) {
586: *oldlenp = len;
587: error = copyout(sp, oldp, len);
588: }
589: if (error == 0 && newp)
590: error = copyin(newp, sp, len);
591: return (error);
592: }
593:
594: /*
595: * Validate parameters and get old parameters
596: * for a structure oriented sysctl function.
597: */
598: sysctl_rdstruct(oldp, oldlenp, newp, sp, len)
599: void *oldp;
600: size_t *oldlenp;
601: void *newp, *sp;
602: int len;
603: {
604: int error = 0;
605:
606: if (oldp && *oldlenp < len)
607: return (ENOMEM);
608: if (newp)
609: return (EPERM);
610: *oldlenp = len;
611: if (oldp)
612: error = copyout(sp, oldp, len);
613: return (error);
614: }
615:
616: /*
617: * Get file structures.
618: */
619: sysctl_file(where, sizep)
620: char *where;
621: size_t *sizep;
622: {
623: int buflen, error;
624: struct file *fp;
625: char *start = where;
626:
627: buflen = *sizep;
628: if (where == NULL) {
629: /*
630: * overestimate by 10 files
631: */
632: *sizep = sizeof(filehead) + (nfiles + 10) * sizeof(struct file);
633: return (0);
634: }
635:
636: /*
637: * first copyout filehead
638: */
639: if (buflen < sizeof(filehead)) {
640: *sizep = 0;
641: return (0);
642: }
643: if (error = copyout((caddr_t)&filehead, where, sizeof(filehead)))
644: return (error);
645: buflen -= sizeof(filehead);
646: where += sizeof(filehead);
647:
648: /*
649: * followed by an array of file structures
650: */
651: for (fp = filehead.lh_first; fp != 0; fp = fp->f_list.le_next) {
652: if (buflen < sizeof(struct file)) {
653: *sizep = where - start;
654: return (ENOMEM);
655: }
656: if (error = copyout((caddr_t)fp, where, sizeof (struct file)))
657: return (error);
658: buflen -= sizeof(struct file);
659: where += sizeof(struct file);
660: }
661: *sizep = where - start;
662: return (0);
663: }
664:
665: /*
666: * try over estimating by 5 procs
667: */
668: #define KERN_PROCSLOP (5 * sizeof (struct kinfo_proc))
669:
670: sysctl_doproc(name, namelen, where, sizep)
671: int *name;
672: u_int namelen;
673: char *where;
674: size_t *sizep;
675: {
676: register struct proc *p;
677: register struct kinfo_proc *dp = (struct kinfo_proc *)where;
678: register int needed = 0;
679: int buflen = where != NULL ? *sizep : 0;
680: int doingzomb;
681: struct kinfo_proc kproc;
682: int error = 0;
683:
684: if (namelen != 2 && !(namelen == 1 && name[0] == KERN_PROC_ALL))
685: return (EINVAL);
686: p = allproc.lh_first;
687: doingzomb = 0;
688: again:
689: for (; p != 0; p = p->p_list.le_next) {
690: /*
691: * Skip embryonic processes.
692: */
693: if (p->p_stat == SIDL)
694: continue;
695: /*
696: * TODO - make more efficient (see notes below).
697: * do by session.
698: */
699: switch (name[0]) {
700:
701: case KERN_PROC_PID:
702: /* could do this with just a lookup */
703: if (p->p_pid != (pid_t)name[1])
704: continue;
705: break;
706:
707: case KERN_PROC_PGRP:
708: /* could do this by traversing pgrp */
709: if (p->p_pgrp->pg_id != (pid_t)name[1])
710: continue;
711: break;
712:
713: case KERN_PROC_TTY:
714: if ((p->p_flag & P_CONTROLT) == 0 ||
715: p->p_session->s_ttyp == NULL ||
716: p->p_session->s_ttyp->t_dev != (dev_t)name[1])
717: continue;
718: break;
719:
720: case KERN_PROC_UID:
721: if (p->p_ucred->cr_uid != (uid_t)name[1])
722: continue;
723: break;
724:
725: case KERN_PROC_RUID:
726: if (p->p_cred->p_ruid != (uid_t)name[1])
727: continue;
728: break;
729: }
730: if (buflen >= sizeof(struct kinfo_proc)) {
731: fill_proc(p, &kproc);
732: if (error = copyout((caddr_t)&kproc, &dp->kp_proc,
733: sizeof(struct kinfo_proc)))
734: return (error);
735: dp++;
736: buflen -= sizeof(struct kinfo_proc);
737: }
738: needed += sizeof(struct kinfo_proc);
739: }
740: if (doingzomb == 0) {
741: p = zombproc.lh_first;
742: doingzomb++;
743: goto again;
744: }
745: if (where != NULL) {
746: *sizep = (caddr_t)dp - where;
747: if (needed > *sizep)
748: return (ENOMEM);
749: } else {
750: needed += KERN_PROCSLOP;
751: *sizep = needed;
752: }
753: return (0);
754: }
755:
756: void
757: fill_proc(p,kp)
758: register struct proc *p;
759: register struct kinfo_proc *kp;
760: {
761: fill_externproc(p, &kp->kp_proc);
762: fill_eproc(p, &kp->kp_eproc);
763: }
764: /*
765: * Fill in an eproc structure for the specified process.
766: */
767: void
768: fill_eproc(p, ep)
769: register struct proc *p;
770: register struct eproc *ep;
771: {
772: register struct tty *tp;
773:
774: ep->e_paddr = p;
775: ep->e_sess = p->p_pgrp->pg_session;
776: ep->e_pcred = *p->p_cred;
777: ep->e_ucred = *p->p_ucred;
778: if (p->p_stat == SIDL || p->p_stat == SZOMB) {
779: ep->e_vm.vm_rssize = 0;
780: ep->e_vm.vm_tsize = 0;
781: ep->e_vm.vm_dsize = 0;
782: ep->e_vm.vm_ssize = 0;
783: /* ep->e_vm.vm_pmap = XXX; */
784: } else {
785: register vm_map_t vm = ((task_t)p->task)->map;
786:
787: ep->e_vm.vm_rssize = pmap_resident_count(vm->pmap); /*XXX*/
788: // ep->e_vm.vm_tsize = vm->vm_tsize;
789: // ep->e_vm.vm_dsize = vm->vm_dsize;
790: // ep->e_vm.vm_ssize = vm->vm_ssize;
791: }
792: if (p->p_pptr)
793: ep->e_ppid = p->p_pptr->p_pid;
794: else
795: ep->e_ppid = 0;
796: ep->e_pgid = p->p_pgrp->pg_id;
797: ep->e_jobc = p->p_pgrp->pg_jobc;
798: if ((p->p_flag & P_CONTROLT) &&
799: (tp = ep->e_sess->s_ttyp)) {
800: ep->e_tdev = tp->t_dev;
801: ep->e_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
802: ep->e_tsess = tp->t_session;
803: } else
804: ep->e_tdev = NODEV;
805: ep->e_flag = ep->e_sess->s_ttyvp ? EPROC_CTTY : 0;
806: if (SESS_LEADER(p))
807: ep->e_flag |= EPROC_SLEADER;
808: if (p->p_wmesg)
809: strncpy(ep->e_wmesg, p->p_wmesg, WMESGLEN);
810: ep->e_xsize = ep->e_xrssize = 0;
811: ep->e_xccount = ep->e_xswrss = 0;
812: }
813: /*
814: * Fill in an eproc structure for the specified process.
815: */
816: void
817: fill_externproc(p, exp)
818: register struct proc *p;
819: register struct extern_proc *exp;
820: {
821: exp->p_forw = exp->p_back = NULL;
822: exp->p_vmspace = NULL;
823: exp->p_sigacts = p->p_sigacts;
824: exp->p_flag = p->p_flag;
825: exp->p_stat = p->p_stat ;
826: exp->p_pid = p->p_pid ;
827: exp->p_oppid = p->p_oppid ;
828: exp->p_dupfd = p->p_dupfd ;
829: /* Mach related */
830: exp->user_stack = p->user_stack ;
831: exp->exit_thread = p->exit_thread ;
832: exp->p_debugger = p->p_debugger ;
833: exp->sigwait = p->sigwait ;
834: /* scheduling */
835: exp->p_estcpu = p->p_estcpu ;
836: exp->p_cpticks = p->p_cpticks ;
837: exp->p_pctcpu = p->p_pctcpu ;
838: exp->p_wchan = p->p_wchan ;
839: exp->p_wmesg = p->p_wmesg ;
840: exp->p_swtime = p->p_swtime ;
841: exp->p_slptime = p->p_slptime ;
842: bcopy(&p->p_realtimer, &exp->p_realtimer,sizeof(struct itimerval));
843: bcopy(&p->p_rtime, &exp->p_rtime,sizeof(struct timeval));
844: exp->p_uticks = p->p_uticks ;
845: exp->p_sticks = p->p_sticks ;
846: exp->p_iticks = p->p_iticks ;
847: exp->p_traceflag = p->p_traceflag ;
848: exp->p_tracep = p->p_tracep ;
849: exp->p_siglist = p->p_siglist ;
850: exp->p_textvp = p->p_textvp ;
851: exp->p_holdcnt = 0 ;
852: exp->p_sigmask = p->p_sigmask ;
853: exp->p_sigignore = p->p_sigignore ;
854: exp->p_sigcatch = p->p_sigcatch ;
855: exp->p_priority = p->p_priority ;
856: exp->p_usrpri = p->p_usrpri ;
857: exp->p_nice = p->p_nice ;
858: bcopy(&p->p_comm, &exp->p_comm,MAXCOMLEN);
859: exp->p_comm[MAXCOMLEN] = '\0';
860: exp->p_pgrp = p->p_pgrp ;
861: exp->p_addr = NULL;
862: exp->p_xstat = p->p_xstat ;
863: exp->p_acflag = p->p_acflag ;
864: exp->p_ru = p->p_ru ;
865: }
866:
867: #if KDEBUG
868: kdebug_ops(name, namelen, where, sizep)
869: int *name;
870: u_int namelen;
871: char *where;
872: size_t *sizep;
873: {
874: int size=*sizep;
875: int ret=0;
876: extern int kdbg_control(int *name, u_int namelen, char * where,size_t * sizep);
877:
878: switch(name[0]) {
879: case KERN_KDEFLAGS:
880: case KERN_KDDFLAGS:
881: case KERN_KDENABLE:
882: case KERN_KDSETBUF:
883: case KERN_KDGETBUF:
884: case KERN_KDSETUP:
885: case KERN_KDREMOVE:
886: case KERN_KDSETREG:
887: case KERN_KDGETREG:
888: case KERN_KDREADTR:
889: ret = kdbg_control(name, namelen, where, sizep);
890: break;
891: default:
892: ret= EOPNOTSUPP;
893: break;
894: }
895: return(ret);
896: }
897: #endif /* KDEBUG */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.