]> git.saurik.com Git - apple/xnu.git/blob - bsd/kern/kern_sysctl.c
projects / apple / xnu.git / blob
? search:


82f89c2deddc8035ce1a74c0585c0ab23170a49f
[apple/xnu.git] / bsd / kern / kern_sysctl.c
1 /*
2 * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
29 /*-
30 * Copyright (c) 1982, 1986, 1989, 1993
31 * The Regents of the University of California. All rights reserved.
32 *
33 * This code is derived from software contributed to Berkeley by
34 * Mike Karels at Berkeley Software Design, Inc.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
38 * are met:
39 * 1. Redistributions of source code must retain the above copyright
40 * notice, this list of conditions and the following disclaimer.
41 * 2. Redistributions in binary form must reproduce the above copyright
42 * notice, this list of conditions and the following disclaimer in the
43 * documentation and/or other materials provided with the distribution.
44 * 3. All advertising materials mentioning features or use of this software
45 * must display the following acknowledgement:
46 * This product includes software developed by the University of
47 * California, Berkeley and its contributors.
48 * 4. Neither the name of the University nor the names of its contributors
49 * may be used to endorse or promote products derived from this software
50 * without specific prior written permission.
51 *
52 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
53 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
54 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
55 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
56 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
57 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
58 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
59 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
60 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
61 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
62 * SUCH DAMAGE.
63 *
64 * @(#)kern_sysctl.c 8.4 (Berkeley) 4/14/94
65 */
66 /*
67 * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
68 * support for mandatory and extensible security protections. This notice
69 * is included in support of clause 2.2 (b) of the Apple Public License,
70 * Version 2.0.
71 */
72
73 /*
74 * DEPRECATED sysctl system call code
75 *
76 * Everything in this file is deprecated. Sysctls should be handled
77 * by the code in kern_newsysctl.c.
78 * The remaining "case" sections are supposed to be converted into
79 * SYSCTL_*-style definitions, and as soon as all of them are gone,
80 * this source file is supposed to die.
81 *
82 * DO NOT ADD ANY MORE "case" SECTIONS TO THIS FILE, instead define
83 * your sysctl with SYSCTL_INT, SYSCTL_PROC etc. in your source file.
84 */
85
86 #include <sys/param.h>
87 #include <sys/systm.h>
88 #include <sys/kernel.h>
89 #include <sys/malloc.h>
90 #include <sys/proc_internal.h>
91 #include <sys/kauth.h>
92 #include <sys/file_internal.h>
93 #include <sys/vnode_internal.h>
94 #include <sys/unistd.h>
95 #include <sys/buf.h>
96 #include <sys/ioctl.h>
97 #include <sys/namei.h>
98 #include <sys/tty.h>
99 #include <sys/disklabel.h>
100 #include <sys/vm.h>
101 #include <sys/sysctl.h>
102 #include <sys/user.h>
103 #include <sys/aio_kern.h>
104 #include <sys/reboot.h>
105
106 #include <bsm/audit_kernel.h>
107
108 #include <mach/machine.h>
109 #include <mach/mach_types.h>
110 #include <mach/vm_param.h>
111 #include <kern/task.h>
112 #include <kern/lock.h>
113 #include <vm/vm_kern.h>
114 #include <vm/vm_map.h>
115 #include <mach/host_info.h>
116
117 #include <sys/mount_internal.h>
118 #include <sys/kdebug.h>
119 #include <sys/sysproto.h>
120
121 #include <IOKit/IOPlatformExpert.h>
122 #include <pexpert/pexpert.h>
123
124 #include <machine/machine_routines.h>
125 #include <machine/exec.h>
126
127 #include <vm/vm_protos.h>
128
129 #ifdef __i386__
130 #include <i386/cpuid.h>
131 #endif
132
133 sysctlfn kern_sysctl;
134 #ifdef DEBUG
135 sysctlfn debug_sysctl;
136 #endif
137 extern sysctlfn net_sysctl;
138 extern sysctlfn cpu_sysctl;
139 extern int aio_max_requests;
140 extern int aio_max_requests_per_process;
141 extern int aio_worker_threads;
142 extern int lowpri_IO_window_msecs;
143 extern int lowpri_IO_delay_msecs;
144 extern int nx_enabled;
145 extern int speculative_reads_disabled;
146
147 static void
148 fill_eproc(proc_t p, struct eproc *ep);
149 static void
150 fill_externproc(proc_t p, struct extern_proc *exp);
151 static void
152 fill_user_eproc(proc_t p, struct user_eproc *ep);
153 static void
154 fill_user_proc(proc_t p, struct user_kinfo_proc *kp);
155 static void
156 fill_user_externproc(proc_t p, struct user_extern_proc *exp);
157 extern int
158 kdbg_control(int *name, u_int namelen, user_addr_t where, size_t * sizep);
159 int
160 kdebug_ops(int *name, u_int namelen, user_addr_t where, size_t *sizep, proc_t p);
161 #if NFSCLIENT
162 extern int
163 netboot_root(void);
164 #endif
165 int
166 pcsamples_ops(int *name, u_int namelen, user_addr_t where, size_t *sizep,
167 proc_t p);
168 __private_extern__ kern_return_t
169 reset_vmobjectcache(unsigned int val1, unsigned int val2);
170 int
171 sysctl_doproc(int *name, u_int namelen, user_addr_t where, size_t *sizep);
172 int
173 sysctl_doprof(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp,
174 user_addr_t newp, size_t newlen);
175 static void
176 fill_proc(proc_t p, struct kinfo_proc *kp);
177 int
178 sysctl_procargs(int *name, u_int namelen, user_addr_t where,
179 size_t *sizep, proc_t cur_proc);
180 static int
181 sysctl_procargs2(int *name, u_int namelen, user_addr_t where, size_t *sizep,
182 proc_t cur_proc);
183 static int
184 sysctl_procargsx(int *name, u_int namelen, user_addr_t where, size_t *sizep,
185 proc_t cur_proc, int argc_yes);
186 int
187 sysctl_struct(user_addr_t oldp, size_t *oldlenp, user_addr_t newp,
188 size_t newlen, void *sp, int len);
189
190 static int sysdoproc_filt_KERN_PROC_PID(proc_t p, void * arg);
191 static int sysdoproc_filt_KERN_PROC_PGRP(proc_t p, void * arg);
192 static int sysdoproc_filt_KERN_PROC_TTY(proc_t p, void * arg);
193 static int sysdoproc_filt_KERN_PROC_UID(proc_t p, void * arg);
194 static int sysdoproc_filt_KERN_PROC_RUID(proc_t p, void * arg);
195 static int sysdoproc_filt_KERN_PROC_LCID(proc_t p, void * arg);
196 int sysdoproc_callback(proc_t p, void *arg);
197
198 static int __sysctl_funneled(proc_t p, struct __sysctl_args *uap, register_t *retval);
199
200 extern void IORegistrySetOSBuildVersion(char * build_version);
201
202 static void
203 loadavg32to64(struct loadavg *la32, struct user_loadavg *la64)
204 {
205 la64->ldavg[0] = la32->ldavg[0];
206 la64->ldavg[1] = la32->ldavg[1];
207 la64->ldavg[2] = la32->ldavg[2];
208 la64->fscale = (user_long_t)la32->fscale;
209 }
210
211 /*
212 * Locking and stats
213 */
214 static struct sysctl_lock memlock;
215
216 /* sysctl() syscall */
217 int
218 __sysctl(proc_t p, struct __sysctl_args *uap, register_t *retval)
219 {
220 boolean_t funnel_state;
221 int error;
222
223 funnel_state = thread_funnel_set(kernel_flock, TRUE);
224 error = __sysctl_funneled(p, uap, retval);
225 thread_funnel_set(kernel_flock, funnel_state);
226 return(error);
227 }
228
229 static int
230 __sysctl_funneled(proc_t p, struct __sysctl_args *uap, __unused register_t *retval)
231 {
232 int error, dolock = 1;
233 size_t savelen = 0, oldlen = 0, newlen;
234 sysctlfn *fnp = NULL;
235 int name[CTL_MAXNAME];
236 int error1;
237 boolean_t memlock_taken = FALSE;
238 boolean_t vslock_taken = FALSE;
239 #if CONFIG_MACF
240 kauth_cred_t my_cred;
241 #endif
242
243 /*
244 * all top-level sysctl names are non-terminal
245 */
246 if (uap->namelen > CTL_MAXNAME || uap->namelen < 2)
247 return (EINVAL);
248 error = copyin(uap->name, &name[0], uap->namelen * sizeof(int));
249 if (error)
250 return (error);
251
252 AUDIT_ARG(ctlname, name, uap->namelen);
253
254 if (proc_is64bit(p)) {
255 /* uap->newlen is a size_t value which grows to 64 bits
256 * when coming from a 64-bit process. since it's doubtful we'll
257 * have a sysctl newp buffer greater than 4GB we shrink it to size_t
258 */
259 newlen = CAST_DOWN(size_t, uap->newlen);
260 }
261 else {
262 newlen = uap->newlen;
263 }
264
265 /* CTL_UNSPEC is used to get oid to AUTO_OID */
266 if (uap->new != USER_ADDR_NULL
267 && ((name[0] == CTL_KERN
268 && !(name[1] == KERN_IPC || name[1] == KERN_PANICINFO || name[1] == KERN_PROCDELAYTERM ||
269 name[1] == KERN_PROC_LOW_PRI_IO || name[1] == KERN_PROCNAME || name[1] == KERN_RAGEVNODE || name[1] == KERN_CHECKOPENEVT))
270 || (name[0] == CTL_HW)
271 || (name[0] == CTL_VM))
272 && (error = suser(kauth_cred_get(), &p->p_acflag)))
273 return (error);
274
275 /* XXX: KERN, VFS and DEBUG are handled by their respective functions,
276 * but there is a fallback for all sysctls other than VFS to
277 * userland_sysctl() - KILL THIS! */
278 switch (name[0]) {
279 case CTL_KERN:
280 fnp = kern_sysctl;
281 if ((name[1] != KERN_VNODE) && (name[1] != KERN_FILE)
282 && (name[1] != KERN_PROC))
283 dolock = 0;
284 break;
285 case CTL_VFS:
286 fnp = vfs_sysctl;
287 break;
288 #ifdef DEBUG
289 case CTL_DEBUG:
290 fnp = debug_sysctl;
291 break;
292 #endif
293 default:
294 fnp = NULL;
295 }
296
297 if (uap->oldlenp != USER_ADDR_NULL) {
298 uint64_t oldlen64 = fuulong(uap->oldlenp);
299
300 oldlen = CAST_DOWN(size_t, oldlen64);
301 /*
302 * If more than 4G, clamp to 4G - useracc() below will catch
303 * with an EFAULT, if it's actually necessary.
304 */
305 if (oldlen64 > 0x00000000ffffffffULL)
306 oldlen = 0xffffffffUL;
307 }
308
309 if (uap->old != USER_ADDR_NULL) {
310 if (!useracc(uap->old, (user_size_t)oldlen, B_WRITE))
311 return (EFAULT);
312 /*
313 * The kernel debug mechanism does not need to take this lock, and
314 * we don't grab the memlock around calls to KERN_PROC because it is reentrant.
315 * Grabbing the lock for a KERN_PROC sysctl makes a deadlock possible 5024049.
316 */
317 if (!((name[1] == KERN_KDEBUG) && (name[2] == KERN_KDGETENTROPY)) &&
318 !(name[1] == KERN_PROC)) {
319 MEMLOCK_LOCK();
320 memlock_taken = TRUE;
321 }
322
323 if (dolock && oldlen) {
324 if ((error = vslock(uap->old, (user_size_t)oldlen))) {
325 if (memlock_taken == TRUE)
326 MEMLOCK_UNLOCK();
327 return(error);
328 }
329 savelen = oldlen;
330 vslock_taken = TRUE;
331 }
332 }
333
334 #if CONFIG_MACF
335 my_cred = kauth_cred_proc_ref(p);
336 error = mac_system_check_sysctl(
337 my_cred,
338 (int *) name,
339 uap->namelen,
340 uap->old,
341 uap->oldlenp,
342 fnp == kern_sysctl ? 1 : 0,
343 uap->new,
344 newlen
345 );
346 kauth_cred_unref(&my_cred);
347 if (!error) {
348 #endif
349 if (fnp) {
350 error = (*fnp)(name + 1, uap->namelen - 1, uap->old,
351 &oldlen, uap->new, newlen, p);
352 }
353 else
354 error = ENOTSUP;
355 #if CONFIG_MACF
356 }
357 #endif
358
359 if (vslock_taken == TRUE) {
360 error1 = vsunlock(uap->old, (user_size_t)savelen, B_WRITE);
361 if (!error)
362 error = error1;
363 }
364 if (memlock_taken == TRUE)
365 MEMLOCK_UNLOCK();
366
367 if ( (name[0] != CTL_VFS) && (error == ENOTSUP)) {
368 size_t tmp = oldlen;
369 boolean_t funnel_state;
370
371 /*
372 * Drop the funnel when calling new sysctl code, which will conditionally
373 * grab the funnel if it really needs to.
374 */
375 funnel_state = thread_funnel_set(kernel_flock, FALSE);
376
377 error = userland_sysctl(p, name, uap->namelen, uap->old, &tmp,
378 1, uap->new, newlen, &oldlen);
379
380 thread_funnel_set(kernel_flock, funnel_state);
381 }
382
383 if ((error) && (error != ENOMEM))
384 return (error);
385
386 if (uap->oldlenp != USER_ADDR_NULL)
387 error = suulong(uap->oldlenp, oldlen);
388
389 return (error);
390 }
391
392 /*
393 * Attributes stored in the kernel.
394 */
395 __private_extern__ char corefilename[MAXPATHLEN+1];
396 __private_extern__ int do_coredump;
397 __private_extern__ int sugid_coredump;
398
399 #if COUNT_SYSCALLS
400 __private_extern__ int do_count_syscalls;
401 #endif
402
403 #ifdef INSECURE
404 int securelevel = -1;
405 #else
406 int securelevel;
407 #endif
408
409 static int
410 sysctl_affinity(
411 int *name,
412 u_int namelen,
413 user_addr_t oldBuf,
414 size_t *oldSize,
415 user_addr_t newBuf,
416 __unused size_t newSize,
417 proc_t cur_proc)
418 {
419 if (namelen < 1)
420 return (ENOTSUP);
421
422 if (name[0] == 0 && 1 == namelen) {
423 return sysctl_rdint(oldBuf, oldSize, newBuf,
424 (cur_proc->p_flag & P_AFFINITY) ? 1 : 0);
425 } else if (name[0] == 1 && 2 == namelen) {
426 if (name[1] == 0) {
427 OSBitAndAtomic(~((uint32_t)P_AFFINITY), (UInt32 *)&cur_proc->p_flag);
428 } else {
429 OSBitOrAtomic(P_AFFINITY, (UInt32 *)&cur_proc->p_flag);
430 }
431 return 0;
432 }
433 return (ENOTSUP);
434 }
435
436 static int
437 sysctl_translate(
438 int *name,
439 u_int namelen,
440 user_addr_t oldBuf,
441 size_t *oldSize,
442 user_addr_t newBuf,
443 __unused size_t newSize,
444 proc_t cur_proc)
445 {
446 proc_t p;
447 int istranslated = 0;
448 kauth_cred_t my_cred;
449 uid_t uid;
450
451 if (namelen != 1)
452 return (ENOTSUP);
453
454 p = proc_find(name[0]);
455 if (p == NULL)
456 return (EINVAL);
457
458 my_cred = kauth_cred_proc_ref(p);
459 uid = kauth_cred_getuid(my_cred);
460 kauth_cred_unref(&my_cred);
461 if ((uid != kauth_cred_getuid(kauth_cred_get()))
462 && suser(kauth_cred_get(), &cur_proc->p_acflag)) {
463 proc_rele(p);
464 return (EPERM);
465 }
466
467 istranslated = (p->p_flag & P_TRANSLATED);
468 proc_rele(p);
469 return sysctl_rdint(oldBuf, oldSize, newBuf,
470 (istranslated != 0) ? 1 : 0);
471 }
472
473 int
474 set_archhandler(__unused proc_t p, int arch)
475 {
476 int error;
477 struct nameidata nd;
478 struct vnode_attr va;
479 vfs_context_t ctx = vfs_context_current();
480 struct exec_archhandler *archhandler;
481
482 switch(arch) {
483 case CPU_TYPE_POWERPC:
484 archhandler = &exec_archhandler_ppc;
485 break;
486 default:
487 return (EBADARCH);
488 }
489
490 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE32,
491 CAST_USER_ADDR_T(archhandler->path), ctx);
492 error = namei(&nd);
493 if (error)
494 return (error);
495 nameidone(&nd);
496
497 /* Check mount point */
498 if ((nd.ni_vp->v_mount->mnt_flag & MNT_NOEXEC) ||
499 (nd.ni_vp->v_type != VREG)) {
500 vnode_put(nd.ni_vp);
501 return (EACCES);
502 }
503
504 VATTR_INIT(&va);
505 VATTR_WANTED(&va, va_fsid);
506 VATTR_WANTED(&va, va_fileid);
507 error = vnode_getattr(nd.ni_vp, &va, ctx);
508 if (error) {
509 vnode_put(nd.ni_vp);
510 return (error);
511 }
512 vnode_put(nd.ni_vp);
513
514 archhandler->fsid = va.va_fsid;
515 archhandler->fileid = (u_long)va.va_fileid;
516 return 0;
517 }
518
519 /* XXX remove once Rosetta is rev'ed */
520 /*****************************************************************************/
521 static int
522 sysctl_exec_archhandler_ppc(
523 __unused int *name,
524 __unused u_int namelen,
525 user_addr_t oldBuf,
526 size_t *oldSize,
527 user_addr_t newBuf,
528 size_t newSize,
529 proc_t p)
530 {
531 int error;
532 size_t len;
533 char handler[sizeof(exec_archhandler_ppc.path)];
534 vfs_context_t ctx = vfs_context_current();
535
536 if (oldSize) {
537 len = strlen(exec_archhandler_ppc.path) + 1;
538 if (oldBuf) {
539 if (*oldSize < len)
540 return (ENOMEM);
541 error = copyout(exec_archhandler_ppc.path, oldBuf, len);
542 if (error)
543 return (error);
544 }
545 *oldSize = len - 1;
546 }
547 if (newBuf) {
548 error = suser(vfs_context_ucred(ctx), &p->p_acflag);
549 if (error)
550 return (error);
551 if (newSize >= sizeof(exec_archhandler_ppc.path))
552 return (ENAMETOOLONG);
553 error = copyin(newBuf, handler, newSize);
554 if (error)
555 return (error);
556 handler[newSize] = 0;
557 strlcpy(exec_archhandler_ppc.path, handler, MAXPATHLEN);
558 error = set_archhandler(p, CPU_TYPE_POWERPC);
559 if (error)
560 return (error);
561 }
562 return 0;
563 }
564 /*****************************************************************************/
565
566 static int
567 sysctl_handle_exec_archhandler_ppc(struct sysctl_oid *oidp, void *arg1,
568 int arg2, struct sysctl_req *req)
569 {
570 int error = 0;
571
572 error = sysctl_handle_string(oidp, arg1, arg2, req);
573
574 if (error)
575 goto done;
576
577 if (req->newptr)
578 error = set_archhandler(req->p, CPU_TYPE_POWERPC);
579
580 done:
581 return error;
582
583 }
584
585 SYSCTL_NODE(_kern, KERN_EXEC, exec, CTLFLAG_RD|CTLFLAG_LOCKED, 0, "");
586
587 SYSCTL_NODE(_kern_exec, OID_AUTO, archhandler, CTLFLAG_RD|CTLFLAG_LOCKED, 0, "");
588
589 SYSCTL_PROC(_kern_exec_archhandler, OID_AUTO, powerpc,
590 CTLTYPE_STRING | CTLFLAG_RW, exec_archhandler_ppc.path, 0,
591 sysctl_handle_exec_archhandler_ppc, "A", "");
592
593 extern int get_kernel_symfile(proc_t, char **);
594 __private_extern__ int
595 sysctl_dopanicinfo(int *, u_int, user_addr_t, size_t *, user_addr_t,
596 size_t, proc_t);
597
598 /*
599 * kernel related system variables.
600 */
601 int
602 kern_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp,
603 user_addr_t newp, size_t newlen, proc_t p)
604 {
605 /* all sysctl names not listed below are terminal at this level */
606 if (namelen != 1
607 && !(name[0] == KERN_PROC
608 || name[0] == KERN_PROF
609 || name[0] == KERN_KDEBUG
610 || name[0] == KERN_PROCARGS
611 || name[0] == KERN_PROCARGS2
612 || name[0] == KERN_IPC
613 || name[0] == KERN_SYSV
614 || name[0] == KERN_AFFINITY
615 || name[0] == KERN_TRANSLATE
616 || name[0] == KERN_EXEC
617 || name[0] == KERN_PANICINFO
618 || name[0] == KERN_POSIX
619 || name[0] == KERN_TFP
620 || name[0] == KERN_TTY
621 #if CONFIG_LCTX
622 || name[0] == KERN_LCTX
623 #endif
624 )
625 )
626 return (ENOTDIR); /* overloaded */
627
628 switch (name[0]) {
629 case KERN_PROC:
630 return (sysctl_doproc(name + 1, namelen - 1, oldp, oldlenp));
631 #ifdef GPROF
632 case KERN_PROF:
633 return (sysctl_doprof(name + 1, namelen - 1, oldp, oldlenp,
634 newp, newlen));
635 #endif
636 case KERN_KDEBUG:
637 return (kdebug_ops(name + 1, namelen - 1, oldp, oldlenp, p));
638 case KERN_PROCARGS:
639 /* new one as it does not use kinfo_proc */
640 return (sysctl_procargs(name + 1, namelen - 1, oldp, oldlenp, p));
641 case KERN_PROCARGS2:
642 /* new one as it does not use kinfo_proc */
643 return (sysctl_procargs2(name + 1, namelen - 1, oldp, oldlenp, p));
644 #if PANIC_INFO
645 case KERN_PANICINFO:
646 return(sysctl_dopanicinfo(name + 1, namelen - 1, oldp, oldlenp,
647 newp, newlen, p));
648 #endif
649 case KERN_AFFINITY:
650 return sysctl_affinity(name+1, namelen-1, oldp, oldlenp,
651 newp, newlen, p);
652 case KERN_TRANSLATE:
653 return sysctl_translate(name+1, namelen-1, oldp, oldlenp, newp,
654 newlen, p);
655
656 /* XXX remove once Rosetta has rev'ed */
657 case KERN_EXEC:
658 return sysctl_exec_archhandler_ppc(name+1, namelen-1, oldp,
659 oldlenp, newp, newlen, p);
660 #if COUNT_SYSCALLS
661 case KERN_COUNT_SYSCALLS:
662 {
663 /* valid values passed in:
664 * = 0 means don't keep called counts for each bsd syscall
665 * > 0 means keep called counts for each bsd syscall
666 * = 2 means dump current counts to the system log
667 * = 3 means reset all counts
668 * for example, to dump current counts:
669 * sysctl -w kern.count_calls=2
670 */
671 error = sysctl_int(oldp, oldlenp, newp, newlen, &tmp);
672 if ( error != 0 ) {
673 return (error);
674 }
675
676 if ( tmp == 1 ) {
677 do_count_syscalls = 1;
678 }
679 else if ( tmp == 0 || tmp == 2 || tmp == 3 ) {
680 extern int nsysent;
681 extern int syscalls_log[];
682 extern const char * syscallnames[];
683 int i;
684 for ( i = 0; i < nsysent; i++ ) {
685 if ( syscalls_log[i] != 0 ) {
686 if ( tmp == 2 ) {
687 printf("%d calls - name %s \n", syscalls_log[i], syscallnames[i]);
688 }
689 else {
690 syscalls_log[i] = 0;
691 }
692 }
693 }
694 if ( tmp != 0 ) {
695 do_count_syscalls = 1;
696 }
697 }
698 return (0);
699 }
700 #endif
701 default:
702 return (ENOTSUP);
703 }
704 /* NOTREACHED */
705 }
706
707 #ifdef DEBUG
708 /*
709 * Debugging related system variables.
710 */
711 #if DIAGNOSTIC
712 extern
713 #endif /* DIAGNOSTIC */
714 struct ctldebug debug0, debug1;
715 struct ctldebug debug2, debug3, debug4;
716 struct ctldebug debug5, debug6, debug7, debug8, debug9;
717 struct ctldebug debug10, debug11, debug12, debug13, debug14;
718 struct ctldebug debug15, debug16, debug17, debug18, debug19;
719 static struct ctldebug *debugvars[CTL_DEBUG_MAXID] = {
720 &debug0, &debug1, &debug2, &debug3, &debug4,
721 &debug5, &debug6, &debug7, &debug8, &debug9,
722 &debug10, &debug11, &debug12, &debug13, &debug14,
723 &debug15, &debug16, &debug17, &debug18, &debug19,
724 };
725 int
726 debug_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp,
727 user_addr_t newp, size_t newlen, __unused proc_t p)
728 {
729 struct ctldebug *cdp;
730
731 /* all sysctl names at this level are name and field */
732 if (namelen != 2)
733 return (ENOTDIR); /* overloaded */
734 if (name[0] < 0 || name[0] >= CTL_DEBUG_MAXID)
735 return (ENOTSUP);
736 cdp = debugvars[name[0]];
737 if (cdp->debugname == 0)
738 return (ENOTSUP);
739 switch (name[1]) {
740 case CTL_DEBUG_NAME:
741 return (sysctl_rdstring(oldp, oldlenp, newp, cdp->debugname));
742 case CTL_DEBUG_VALUE:
743 return (sysctl_int(oldp, oldlenp, newp, newlen, cdp->debugvar));
744 default:
745 return (ENOTSUP);
746 }
747 /* NOTREACHED */
748 }
749 #endif /* DEBUG */
750
751 /*
752 * The following sysctl_* functions should not be used
753 * any more, as they can only cope with callers in
754 * user mode: Use new-style
755 * sysctl_io_number()
756 * sysctl_io_string()
757 * sysctl_io_opaque()
758 * instead.
759 */
760
761 /*
762 * Validate parameters and get old / set new parameters
763 * for an integer-valued sysctl function.
764 */
765 int
766 sysctl_int(user_addr_t oldp, size_t *oldlenp,
767 user_addr_t newp, size_t newlen, int *valp)
768 {
769 int error = 0;
770
771 if (oldp != USER_ADDR_NULL && oldlenp == NULL)
772 return (EFAULT);
773 if (oldp && *oldlenp < sizeof(int))
774 return (ENOMEM);
775 if (newp && newlen != sizeof(int))
776 return (EINVAL);
777 *oldlenp = sizeof(int);
778 if (oldp)
779 error = copyout(valp, oldp, sizeof(int));
780 if (error == 0 && newp) {
781 error = copyin(newp, valp, sizeof(int));
782 AUDIT_ARG(value, *valp);
783 }
784 return (error);
785 }
786
787 /*
788 * As above, but read-only.
789 */
790 int
791 sysctl_rdint(user_addr_t oldp, size_t *oldlenp, user_addr_t newp, int val)
792 {
793 int error = 0;
794
795 if (oldp != USER_ADDR_NULL && oldlenp == NULL)
796 return (EFAULT);
797 if (oldp && *oldlenp < sizeof(int))
798 return (ENOMEM);
799 if (newp)
800 return (EPERM);
801 *oldlenp = sizeof(int);
802 if (oldp)
803 error = copyout((caddr_t)&val, oldp, sizeof(int));
804 return (error);
805 }
806
807 /*
808 * Validate parameters and get old / set new parameters
809 * for an quad(64bit)-valued sysctl function.
810 */
811 int
812 sysctl_quad(user_addr_t oldp, size_t *oldlenp,
813 user_addr_t newp, size_t newlen, quad_t *valp)
814 {
815 int error = 0;
816
817 if (oldp != USER_ADDR_NULL && oldlenp == NULL)
818 return (EFAULT);
819 if (oldp && *oldlenp < sizeof(quad_t))
820 return (ENOMEM);
821 if (newp && newlen != sizeof(quad_t))
822 return (EINVAL);
823 *oldlenp = sizeof(quad_t);
824 if (oldp)
825 error = copyout(valp, oldp, sizeof(quad_t));
826 if (error == 0 && newp)
827 error = copyin(newp, valp, sizeof(quad_t));
828 return (error);
829 }
830
831 /*
832 * As above, but read-only.
833 */
834 int
835 sysctl_rdquad(user_addr_t oldp, size_t *oldlenp, user_addr_t newp, quad_t val)
836 {
837 int error = 0;
838
839 if (oldp != USER_ADDR_NULL && oldlenp == NULL)
840 return (EFAULT);
841 if (oldp && *oldlenp < sizeof(quad_t))
842 return (ENOMEM);
843 if (newp)
844 return (EPERM);
845 *oldlenp = sizeof(quad_t);
846 if (oldp)
847 error = copyout((caddr_t)&val, oldp, sizeof(quad_t));
848 return (error);
849 }
850
851 /*
852 * Validate parameters and get old / set new parameters
853 * for a string-valued sysctl function. Unlike sysctl_string, if you
854 * give it a too small (but larger than 0 bytes) buffer, instead of
855 * returning ENOMEM, it truncates the returned string to the buffer
856 * size. This preserves the semantics of some library routines
857 * implemented via sysctl, which truncate their returned data, rather
858 * than simply returning an error. The returned string is always NUL
859 * terminated.
860 */
861 int
862 sysctl_trstring(user_addr_t oldp, size_t *oldlenp,
863 user_addr_t newp, size_t newlen, char *str, int maxlen)
864 {
865 int len, copylen, error = 0;
866
867 if (oldp != USER_ADDR_NULL && oldlenp == NULL)
868 return (EFAULT);
869 copylen = len = strlen(str) + 1;
870 if (oldp && (len < 0 || *oldlenp < 1))
871 return (ENOMEM);
872 if (oldp && (*oldlenp < (size_t)len))
873 copylen = *oldlenp + 1;
874 if (newp && (maxlen < 0 || newlen >= (size_t)maxlen))
875 return (EINVAL);
876 *oldlenp = copylen - 1; /* deal with NULL strings correctly */
877 if (oldp) {
878 error = copyout(str, oldp, copylen);
879 if (!error) {
880 unsigned char c = 0;
881 /* NUL terminate */
882 oldp += *oldlenp;
883 error = copyout((void *)&c, oldp, sizeof(char));
884 }
885 }
886 if (error == 0 && newp) {
887 error = copyin(newp, str, newlen);
888 str[newlen] = 0;
889 AUDIT_ARG(text, (char *)str);
890 }
891 return (error);
892 }
893
894 /*
895 * Validate parameters and get old / set new parameters
896 * for a string-valued sysctl function.
897 */
898 int
899 sysctl_string(user_addr_t oldp, size_t *oldlenp,
900 user_addr_t newp, size_t newlen, char *str, int maxlen)
901 {
902 int len, error = 0;
903
904 if (oldp != USER_ADDR_NULL && oldlenp == NULL)
905 return (EFAULT);
906 len = strlen(str) + 1;
907 if (oldp && (len < 0 || *oldlenp < (size_t)len))
908 return (ENOMEM);
909 if (newp && (maxlen < 0 || newlen >= (size_t)maxlen))
910 return (EINVAL);
911 *oldlenp = len -1; /* deal with NULL strings correctly */
912 if (oldp) {
913 error = copyout(str, oldp, len);
914 }
915 if (error == 0 && newp) {
916 error = copyin(newp, str, newlen);
917 str[newlen] = 0;
918 AUDIT_ARG(text, (char *)str);
919 }
920 return (error);
921 }
922
923 /*
924 * As above, but read-only.
925 */
926 int
927 sysctl_rdstring(user_addr_t oldp, size_t *oldlenp,
928 user_addr_t newp, char *str)
929 {
930 int len, error = 0;
931
932 if (oldp != USER_ADDR_NULL && oldlenp == NULL)
933 return (EFAULT);
934 len = strlen(str) + 1;
935 if (oldp && *oldlenp < (size_t)len)
936 return (ENOMEM);
937 if (newp)
938 return (EPERM);
939 *oldlenp = len;
940 if (oldp)
941 error = copyout(str, oldp, len);
942 return (error);
943 }
944
945 /*
946 * Validate parameters and get old / set new parameters
947 * for a structure oriented sysctl function.
948 */
949 int
950 sysctl_struct(user_addr_t oldp, size_t *oldlenp,
951 user_addr_t newp, size_t newlen, void *sp, int len)
952 {
953 int error = 0;
954
955 if (oldp != USER_ADDR_NULL && oldlenp == NULL)
956 return (EFAULT);
957 if (oldp && (len < 0 || *oldlenp < (size_t)len))
958 return (ENOMEM);
959 if (newp && (len < 0 || newlen > (size_t)len))
960 return (EINVAL);
961 if (oldp) {
962 *oldlenp = len;
963 error = copyout(sp, oldp, len);
964 }
965 if (error == 0 && newp)
966 error = copyin(newp, sp, len);
967 return (error);
968 }
969
970 /*
971 * Validate parameters and get old parameters
972 * for a structure oriented sysctl function.
973 */
974 int
975 sysctl_rdstruct(user_addr_t oldp, size_t *oldlenp,
976 user_addr_t newp, void *sp, int len)
977 {
978 int error = 0;
979
980 if (oldp != USER_ADDR_NULL && oldlenp == NULL)
981 return (EFAULT);
982 if (oldp && (len < 0 || *oldlenp < (size_t)len))
983 return (ENOMEM);
984 if (newp)
985 return (EPERM);
986 *oldlenp = len;
987 if (oldp)
988 error = copyout(sp, oldp, len);
989 return (error);
990 }
991
992 /*
993 * Get file structures.
994 */
995 static int
996 sysctl_file
997 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
998 {
999 int error;
1000 struct fileglob *fg;
1001 struct extern_file nef;
1002
1003 if (req->oldptr == USER_ADDR_NULL) {
1004 /*
1005 * overestimate by 10 files
1006 */
1007 req->oldidx = sizeof(filehead) + (nfiles + 10) * sizeof(struct extern_file);
1008 return (0);
1009 }
1010
1011 /*
1012 * first copyout filehead
1013 */
1014 error = SYSCTL_OUT(req, &filehead, sizeof(filehead));
1015 if (error)
1016 return (error);
1017
1018 /*
1019 * followed by an array of file structures
1020 */
1021 for (fg = filehead.lh_first; fg != 0; fg = fg->f_list.le_next) {
1022 nef.f_list.le_next = (struct extern_file *)fg->f_list.le_next;
1023 nef.f_list.le_prev = (struct extern_file **)fg->f_list.le_prev;
1024 nef.f_flag = (fg->fg_flag & FMASK);
1025 nef.f_type = fg->fg_type;
1026 nef.f_count = fg->fg_count;
1027 nef.f_msgcount = fg->fg_msgcount;
1028 nef.f_cred = fg->fg_cred;
1029 nef.f_ops = fg->fg_ops;
1030 nef.f_offset = fg->fg_offset;
1031 nef.f_data = fg->fg_data;
1032 error = SYSCTL_OUT(req, &nef, sizeof(nef));
1033 if (error)
1034 return (error);
1035 }
1036 return (0);
1037 }
1038
1039 SYSCTL_PROC(_kern, KERN_FILE, file,
1040 CTLTYPE_STRUCT | CTLFLAG_RW,
1041 0, 0, sysctl_file, "S,filehead", "");
1042
1043 static int
1044 sysdoproc_filt_KERN_PROC_PID(proc_t p, void * arg)
1045 {
1046 if (p->p_pid != (pid_t)arg)
1047 return(0);
1048 else
1049 return(1);
1050 }
1051
1052 static int
1053 sysdoproc_filt_KERN_PROC_PGRP(proc_t p, void * arg)
1054 {
1055 if (p->p_pgrpid != (pid_t)arg)
1056 return(0);
1057 else
1058 return(1);
1059 }
1060
1061 static int
1062 sysdoproc_filt_KERN_PROC_TTY(proc_t p, void * arg)
1063 {
1064 boolean_t funnel_state;
1065 int retval;
1066
1067
1068 funnel_state = thread_funnel_set(kernel_flock, TRUE);
1069 /* This is very racy but list lock is held.. Hmmm. */
1070 if ((p->p_flag & P_CONTROLT) == 0 ||
1071 (p->p_pgrp == NULL) || (p->p_pgrp->pg_session == NULL) ||
1072 p->p_pgrp->pg_session->s_ttyp == NULL ||
1073 p->p_pgrp->pg_session->s_ttyp->t_dev != (dev_t)arg)
1074 retval = 0;
1075 else
1076 retval = 1;
1077
1078 thread_funnel_set(kernel_flock, funnel_state);
1079
1080 return(retval);
1081 }
1082
1083 static int
1084 sysdoproc_filt_KERN_PROC_UID(proc_t p, void * arg)
1085 {
1086 kauth_cred_t my_cred;
1087 uid_t uid;
1088
1089 if (p->p_ucred == NULL)
1090 return(0);
1091 my_cred = kauth_cred_proc_ref(p);
1092 uid = kauth_cred_getuid(my_cred);
1093 kauth_cred_unref(&my_cred);
1094
1095 if (uid != (uid_t)arg)
1096 return(0);
1097 else
1098 return(1);
1099 }
1100
1101
1102 static int
1103 sysdoproc_filt_KERN_PROC_RUID(proc_t p, void * arg)
1104 {
1105 kauth_cred_t my_cred;
1106 uid_t ruid;
1107
1108 if (p->p_ucred == NULL)
1109 return(0);
1110 my_cred = kauth_cred_proc_ref(p);
1111 ruid = my_cred->cr_ruid;
1112 kauth_cred_unref(&my_cred);
1113
1114 if (ruid != (uid_t)arg)
1115 return(0);
1116 else
1117 return(1);
1118 }
1119
1120 static int
1121 sysdoproc_filt_KERN_PROC_LCID(proc_t p, void * arg)
1122 {
1123 if ((p->p_lctx == NULL) ||
1124 (p->p_lctx->lc_id != (pid_t)arg))
1125 return(0);
1126 else
1127 return(1);
1128 }
1129
1130 /*
1131 * try over estimating by 5 procs
1132 */
1133 #define KERN_PROCSLOP (5 * sizeof (struct kinfo_proc))
1134 struct sysdoproc_args {
1135 int buflen;
1136 caddr_t kprocp;
1137 boolean_t is_64_bit;
1138 user_addr_t dp;
1139 size_t needed;
1140 int sizeof_kproc;
1141 int * errorp;
1142 int uidcheck;
1143 int ruidcheck;
1144 int ttycheck;
1145 int uidval;
1146 };
1147
1148 int
1149 sysdoproc_callback(proc_t p, void * arg)
1150 {
1151 struct sysdoproc_args * args = (struct sysdoproc_args *)arg;
1152 int error=0;
1153
1154 if (args->buflen >= args->sizeof_kproc) {
1155 if ((args->ruidcheck != 0) && (sysdoproc_filt_KERN_PROC_RUID(p, (void *)args->uidval) == 0))
1156 return(PROC_RETURNED);
1157 if ((args->uidcheck != 0) && (sysdoproc_filt_KERN_PROC_UID(p, (void *)args->uidval) == 0))
1158 return(PROC_RETURNED);
1159 if ((args->ttycheck != 0) && (sysdoproc_filt_KERN_PROC_TTY(p, (void *)args->uidval) == 0))
1160 return(PROC_RETURNED);
1161
1162 bzero(args->kprocp, args->sizeof_kproc);
1163 if (args->is_64_bit) {
1164 fill_user_proc(p, (struct user_kinfo_proc *) args->kprocp);
1165 }
1166 else {
1167 fill_proc(p, (struct kinfo_proc *) args->kprocp);
1168 }
1169 error = copyout(args->kprocp, args->dp, args->sizeof_kproc);
1170 if (error) {
1171 *args->errorp = error;
1172 return(PROC_RETURNED_DONE);
1173 return (error);
1174 }
1175 args->dp += args->sizeof_kproc;
1176 args->buflen -= args->sizeof_kproc;
1177 }
1178 args->needed += args->sizeof_kproc;
1179 return(PROC_RETURNED);
1180 }
1181
1182 int
1183 sysctl_doproc(int *name, u_int namelen, user_addr_t where, size_t *sizep)
1184 {
1185 user_addr_t dp = where;
1186 size_t needed = 0;
1187 int buflen = where != USER_ADDR_NULL ? *sizep : 0;
1188 int error = 0;
1189 boolean_t is_64_bit = FALSE;
1190 struct kinfo_proc kproc;
1191 struct user_kinfo_proc user_kproc;
1192 int sizeof_kproc;
1193 caddr_t kprocp;
1194 int (*filterfn)(proc_t, void *) = 0;
1195 struct sysdoproc_args args;
1196 int uidcheck = 0;
1197 int ruidcheck = 0;
1198 int ttycheck = 0;
1199
1200 if (namelen != 2 && !(namelen == 1 && name[0] == KERN_PROC_ALL))
1201 return (EINVAL);
1202 is_64_bit = proc_is64bit(current_proc());
1203 if (is_64_bit) {
1204 sizeof_kproc = sizeof(user_kproc);
1205 kprocp = (caddr_t) &user_kproc;
1206 }
1207 else {
1208 sizeof_kproc = sizeof(kproc);
1209 kprocp = (caddr_t) &kproc;
1210 }
1211
1212
1213 switch (name[0]) {
1214
1215 case KERN_PROC_PID:
1216 filterfn = sysdoproc_filt_KERN_PROC_PID;
1217 break;
1218
1219 case KERN_PROC_PGRP:
1220 filterfn = sysdoproc_filt_KERN_PROC_PGRP;
1221 break;
1222
1223 case KERN_PROC_TTY:
1224 ttycheck = 1;
1225 break;
1226
1227 case KERN_PROC_UID:
1228 uidcheck = 1;
1229 break;
1230
1231 case KERN_PROC_RUID:
1232 ruidcheck = 1;
1233 break;
1234
1235 #if CONFIG_LCTX
1236 case KERN_PROC_LCID:
1237 filterfn = sysdoproc_filt_KERN_PROC_LCID;
1238 break;
1239 #endif
1240 }
1241
1242 error = 0;
1243 args.buflen = buflen;
1244 args.kprocp = kprocp;
1245 args.is_64_bit = is_64_bit;
1246 args.dp = dp;
1247 args.needed = needed;
1248 args.errorp = &error;
1249 args.uidcheck = uidcheck;
1250 args.ruidcheck = ruidcheck;
1251 args.ttycheck = ttycheck;
1252 args.sizeof_kproc = sizeof_kproc;
1253 args.uidval = name[1];
1254
1255 proc_iterate((PROC_ALLPROCLIST | PROC_ZOMBPROCLIST), sysdoproc_callback, &args, filterfn, (void *)name[1]);
1256
1257 if (error)
1258 return(error);
1259
1260 dp = args.dp;
1261 needed = args.needed;
1262
1263 if (where != USER_ADDR_NULL) {
1264 *sizep = dp - where;
1265 if (needed > *sizep)
1266 return (ENOMEM);
1267 } else {
1268 needed += KERN_PROCSLOP;
1269 *sizep = needed;
1270 }
1271 return (0);
1272 }
1273
1274 /*
1275 * Fill in an eproc structure for the specified process.
1276 */
1277 static void
1278 fill_eproc(proc_t p, struct eproc *ep)
1279 {
1280 struct tty *tp;
1281 kauth_cred_t my_cred;
1282 struct pgrp * pg;
1283 struct session * sessp;
1284
1285 pg = proc_pgrp(p);
1286 sessp = proc_session(p);
1287
1288 ep->e_paddr = p;
1289
1290 if (pg != PGRP_NULL) {
1291 ep->e_sess = sessp;
1292 ep->e_pgid = p->p_pgrpid;
1293 ep->e_jobc = pg->pg_jobc;
1294 if ((sessp != SESSION_NULL) && sessp->s_ttyvp)
1295 ep->e_flag = EPROC_CTTY;
1296 } else {
1297 ep->e_sess = (struct session *)0;
1298 ep->e_pgid = 0;
1299 ep->e_jobc = 0;
1300 }
1301 #if CONFIG_LCTX
1302 if (p->p_lctx) {
1303 ep->e_lcid = p->p_lctx->lc_id;
1304 } else {
1305 ep->e_lcid = 0;
1306 }
1307 #endif
1308 ep->e_ppid = p->p_ppid;
1309 /* Pre-zero the fake historical pcred */
1310 bzero(&ep->e_pcred, sizeof(struct _pcred));
1311 if (p->p_ucred) {
1312 my_cred = kauth_cred_proc_ref(p);
1313
1314 /* A fake historical pcred */
1315 ep->e_pcred.p_ruid = my_cred->cr_ruid;
1316 ep->e_pcred.p_svuid = my_cred->cr_svuid;
1317 ep->e_pcred.p_rgid = my_cred->cr_rgid;
1318 ep->e_pcred.p_svgid = my_cred->cr_svgid;
1319 /* A fake historical *kauth_cred_t */
1320 ep->e_ucred.cr_ref = my_cred->cr_ref;
1321 ep->e_ucred.cr_uid = kauth_cred_getuid(my_cred);
1322 ep->e_ucred.cr_ngroups = my_cred->cr_ngroups;
1323 bcopy(my_cred->cr_groups, ep->e_ucred.cr_groups, NGROUPS*sizeof(gid_t));
1324
1325 kauth_cred_unref(&my_cred);
1326 }
1327 if (p->p_stat == SIDL || p->p_stat == SZOMB) {
1328 ep->e_vm.vm_tsize = 0;
1329 ep->e_vm.vm_dsize = 0;
1330 ep->e_vm.vm_ssize = 0;
1331 }
1332 ep->e_vm.vm_rssize = 0;
1333
1334 if ((p->p_flag & P_CONTROLT) && (sessp != SESSION_NULL) &&
1335 (tp = sessp->s_ttyp)) {
1336 ep->e_tdev = tp->t_dev;
1337 ep->e_tpgid = sessp->s_ttypgrpid;
1338 ep->e_tsess = tp->t_session;
1339 } else
1340 ep->e_tdev = NODEV;
1341
1342 if (SESS_LEADER(p, sessp))
1343 ep->e_flag |= EPROC_SLEADER;
1344 bzero(&ep->e_wmesg[0], WMESGLEN+1);
1345 ep->e_xsize = ep->e_xrssize = 0;
1346 ep->e_xccount = ep->e_xswrss = 0;
1347 if (sessp != SESSION_NULL)
1348 session_rele(sessp);
1349 if(pg != PGRP_NULL)
1350 pg_rele(pg);
1351 }
1352
1353 /*
1354 * Fill in an LP64 version of eproc structure for the specified process.
1355 */
1356 static void
1357 fill_user_eproc(proc_t p, struct user_eproc *ep)
1358 {
1359 struct tty *tp;
1360 struct session *sessp = NULL;
1361 struct pgrp * pg;
1362 kauth_cred_t my_cred;
1363
1364 pg = proc_pgrp(p);
1365 sessp = proc_session(p);
1366
1367 ep->e_paddr = CAST_USER_ADDR_T(p);
1368 if (pg != PGRP_NULL) {
1369 ep->e_sess = CAST_USER_ADDR_T(sessp);
1370 ep->e_pgid = p->p_pgrpid;
1371 ep->e_jobc = pg->pg_jobc;
1372 if (sessp != SESSION_NULL) {
1373 if (sessp->s_ttyvp)
1374 ep->e_flag = EPROC_CTTY;
1375 }
1376 } else {
1377 ep->e_sess = USER_ADDR_NULL;
1378 ep->e_pgid = 0;
1379 ep->e_jobc = 0;
1380 }
1381 #if CONFIG_LCTX
1382 if (p->p_lctx) {
1383 ep->e_lcid = p->p_lctx->lc_id;
1384 } else {
1385 ep->e_lcid = 0;
1386 }
1387 #endif
1388 ep->e_ppid = p->p_ppid;
1389 /* Pre-zero the fake historical pcred */
1390 bzero(&ep->e_pcred, sizeof(ep->e_pcred));
1391 if (p->p_ucred) {
1392 my_cred = kauth_cred_proc_ref(p);
1393
1394 /* A fake historical pcred */
1395 ep->e_pcred.p_ruid = my_cred->cr_ruid;
1396 ep->e_pcred.p_svuid = my_cred->cr_svuid;
1397 ep->e_pcred.p_rgid = my_cred->cr_rgid;
1398 ep->e_pcred.p_svgid = my_cred->cr_svgid;
1399
1400 /* A fake historical *kauth_cred_t */
1401 ep->e_ucred.cr_ref = my_cred->cr_ref;
1402 ep->e_ucred.cr_uid = kauth_cred_getuid(my_cred);
1403 ep->e_ucred.cr_ngroups = my_cred->cr_ngroups;
1404 bcopy(my_cred->cr_groups, ep->e_ucred.cr_groups, NGROUPS*sizeof(gid_t));
1405
1406 kauth_cred_unref(&my_cred);
1407 }
1408 if (p->p_stat == SIDL || p->p_stat == SZOMB) {
1409 ep->e_vm.vm_tsize = 0;
1410 ep->e_vm.vm_dsize = 0;
1411 ep->e_vm.vm_ssize = 0;
1412 }
1413 ep->e_vm.vm_rssize = 0;
1414
1415 if ((p->p_flag & P_CONTROLT) && (sessp != SESSION_NULL) &&
1416 (tp = sessp->s_ttyp)) {
1417 ep->e_tdev = tp->t_dev;
1418 ep->e_tpgid = sessp->s_ttypgrpid;
1419 ep->e_tsess = CAST_USER_ADDR_T(tp->t_session);
1420 } else
1421 ep->e_tdev = NODEV;
1422
1423 if (SESS_LEADER(p, sessp))
1424 ep->e_flag |= EPROC_SLEADER;
1425 bzero(&ep->e_wmesg[0], WMESGLEN+1);
1426 ep->e_xsize = ep->e_xrssize = 0;
1427 ep->e_xccount = ep->e_xswrss = 0;
1428 if (sessp != SESSION_NULL)
1429 session_rele(sessp);
1430 if (pg != PGRP_NULL)
1431 pg_rele(pg);
1432 }
1433
1434 /*
1435 * Fill in an eproc structure for the specified process.
1436 */
1437 static void
1438 fill_externproc(proc_t p, struct extern_proc *exp)
1439 {
1440 exp->p_forw = exp->p_back = NULL;
1441 exp->p_starttime = p->p_start;
1442 exp->p_vmspace = NULL;
1443 exp->p_sigacts = p->p_sigacts;
1444 exp->p_flag = p->p_flag;
1445 if (p->p_lflag & P_LTRACED)
1446 exp->p_flag |= P_TRACED;
1447 if (p->p_lflag & P_LPPWAIT)
1448 exp->p_flag |= P_PPWAIT;
1449 if (p->p_lflag & P_LEXIT)
1450 exp->p_flag |= P_WEXIT;
1451 exp->p_stat = p->p_stat ;
1452 exp->p_pid = p->p_pid ;
1453 exp->p_oppid = p->p_oppid ;
1454 /* Mach related */
1455 exp->user_stack = CAST_DOWN(caddr_t, p->user_stack);
1456 exp->exit_thread = p->exit_thread ;
1457 exp->p_debugger = p->p_debugger ;
1458 exp->sigwait = p->sigwait ;
1459 /* scheduling */
1460 #ifdef _PROC_HAS_SCHEDINFO_
1461 exp->p_estcpu = p->p_estcpu ;
1462 exp->p_pctcpu = p->p_pctcpu ;
1463 exp->p_slptime = p->p_slptime ;
1464 #else
1465 exp->p_estcpu = 0 ;
1466 exp->p_pctcpu = 0 ;
1467 exp->p_slptime = 0 ;
1468 #endif
1469 exp->p_cpticks = 0 ;
1470 exp->p_wchan = 0 ;
1471 exp->p_wmesg = 0 ;
1472 exp->p_swtime = 0 ;
1473 bcopy(&p->p_realtimer, &exp->p_realtimer,sizeof(struct itimerval));
1474 bcopy(&p->p_rtime, &exp->p_rtime,sizeof(struct timeval));
1475 exp->p_uticks = 0 ;
1476 exp->p_sticks = 0 ;
1477 exp->p_iticks = 0 ;
1478 exp->p_traceflag = 0;
1479 exp->p_tracep = 0 ;
1480 exp->p_siglist = 0 ; /* No longer relevant */
1481 exp->p_textvp = p->p_textvp ;
1482 exp->p_holdcnt = 0 ;
1483 exp->p_sigmask = 0 ; /* no longer avaialable */
1484 exp->p_sigignore = p->p_sigignore ;
1485 exp->p_sigcatch = p->p_sigcatch ;
1486 exp->p_priority = p->p_priority ;
1487 exp->p_usrpri = 0 ;
1488 exp->p_nice = p->p_nice ;
1489 bcopy(&p->p_comm, &exp->p_comm,MAXCOMLEN);
1490 exp->p_comm[MAXCOMLEN] = '\0';
1491 exp->p_pgrp = p->p_pgrp ;
1492 exp->p_addr = NULL;
1493 exp->p_xstat = p->p_xstat ;
1494 exp->p_acflag = p->p_acflag ;
1495 exp->p_ru = p->p_ru ; /* XXX may be NULL */
1496 }
1497
1498 /*
1499 * Fill in an LP64 version of extern_proc structure for the specified process.
1500 */
1501 static void
1502 fill_user_externproc(proc_t p, struct user_extern_proc *exp)
1503 {
1504 exp->p_forw = exp->p_back = USER_ADDR_NULL;
1505 exp->p_starttime.tv_sec = p->p_start.tv_sec;
1506 exp->p_starttime.tv_usec = p->p_start.tv_usec;
1507 exp->p_vmspace = USER_ADDR_NULL;
1508 exp->p_sigacts = CAST_USER_ADDR_T(p->p_sigacts);
1509 exp->p_flag = p->p_flag;
1510 if (p->p_lflag & P_LTRACED)
1511 exp->p_flag |= P_TRACED;
1512 if (p->p_lflag & P_LPPWAIT)
1513 exp->p_flag |= P_PPWAIT;
1514 if (p->p_lflag & P_LEXIT)
1515 exp->p_flag |= P_WEXIT;
1516 exp->p_stat = p->p_stat ;
1517 exp->p_pid = p->p_pid ;
1518 exp->p_oppid = p->p_oppid ;
1519 /* Mach related */
1520 exp->user_stack = p->user_stack;
1521 exp->exit_thread = CAST_USER_ADDR_T(p->exit_thread);
1522 exp->p_debugger = p->p_debugger ;
1523 exp->sigwait = p->sigwait ;
1524 /* scheduling */
1525 #ifdef _PROC_HAS_SCHEDINFO_
1526 exp->p_estcpu = p->p_estcpu ;
1527 exp->p_pctcpu = p->p_pctcpu ;
1528 exp->p_slptime = p->p_slptime ;
1529 #else
1530 exp->p_estcpu = 0 ;
1531 exp->p_pctcpu = 0 ;
1532 exp->p_slptime = 0 ;
1533 #endif
1534 exp->p_cpticks = 0 ;
1535 exp->p_wchan = 0;
1536 exp->p_wmesg = 0;
1537 exp->p_swtime = 0 ;
1538 exp->p_realtimer.it_interval.tv_sec = p->p_realtimer.it_interval.tv_sec;
1539 exp->p_realtimer.it_interval.tv_usec = p->p_realtimer.it_interval.tv_usec;
1540 exp->p_realtimer.it_value.tv_sec = p->p_realtimer.it_value.tv_sec;
1541 exp->p_realtimer.it_value.tv_usec = p->p_realtimer.it_value.tv_usec;
1542 exp->p_rtime.tv_sec = p->p_rtime.tv_sec;
1543 exp->p_rtime.tv_usec = p->p_rtime.tv_usec;
1544 exp->p_uticks = 0 ;
1545 exp->p_sticks = 0 ;
1546 exp->p_iticks = 0 ;
1547 exp->p_traceflag = 0 ;
1548 exp->p_tracep = 0;
1549 exp->p_siglist = 0 ; /* No longer relevant */
1550 exp->p_textvp = CAST_USER_ADDR_T(p->p_textvp);
1551 exp->p_holdcnt = 0 ;
1552 exp->p_sigmask = 0 ; /* no longer avaialable */
1553 exp->p_sigignore = p->p_sigignore ;
1554 exp->p_sigcatch = p->p_sigcatch ;
1555 exp->p_priority = p->p_priority ;
1556 exp->p_usrpri = 0 ;
1557 exp->p_nice = p->p_nice ;
1558 bcopy(&p->p_comm, &exp->p_comm,MAXCOMLEN);
1559 exp->p_comm[MAXCOMLEN] = '\0';
1560 exp->p_pgrp = CAST_USER_ADDR_T(p->p_pgrp);
1561 exp->p_addr = USER_ADDR_NULL;
1562 exp->p_xstat = p->p_xstat ;
1563 exp->p_acflag = p->p_acflag ;
1564 exp->p_ru = CAST_USER_ADDR_T(p->p_ru); /* XXX may be NULL */
1565 }
1566
1567 static void
1568 fill_proc(proc_t p, struct kinfo_proc *kp)
1569 {
1570 fill_externproc(p, &kp->kp_proc);
1571 fill_eproc(p, &kp->kp_eproc);
1572 }
1573
1574 static void
1575 fill_user_proc(proc_t p, struct user_kinfo_proc *kp)
1576 {
1577 fill_user_externproc(p, &kp->kp_proc);
1578 fill_user_eproc(p, &kp->kp_eproc);
1579 }
1580
1581 int
1582 kdebug_ops(int *name, u_int namelen, user_addr_t where,
1583 size_t *sizep, proc_t p)
1584 {
1585 int ret=0;
1586
1587 ret = suser(kauth_cred_get(), &p->p_acflag);
1588 if (ret)
1589 return(ret);
1590
1591 switch(name[0]) {
1592 case KERN_KDEFLAGS:
1593 case KERN_KDDFLAGS:
1594 case KERN_KDENABLE:
1595 case KERN_KDGETBUF:
1596 case KERN_KDSETUP:
1597 case KERN_KDREMOVE:
1598 case KERN_KDSETREG:
1599 case KERN_KDGETREG:
1600 case KERN_KDREADTR:
1601 case KERN_KDPIDTR:
1602 case KERN_KDTHRMAP:
1603 case KERN_KDPIDEX:
1604 case KERN_KDSETRTCDEC:
1605 case KERN_KDSETBUF:
1606 case KERN_KDGETENTROPY:
1607 ret = kdbg_control(name, namelen, where, sizep);
1608 break;
1609 default:
1610 ret= ENOTSUP;
1611 break;
1612 }
1613 return(ret);
1614 }
1615
1616
1617 /*
1618 * Return the top *sizep bytes of the user stack, or the entire area of the
1619 * user stack down through the saved exec_path, whichever is smaller.
1620 */
1621 int
1622 sysctl_procargs(int *name, u_int namelen, user_addr_t where,
1623 size_t *sizep, proc_t cur_proc)
1624 {
1625 return sysctl_procargsx( name, namelen, where, sizep, cur_proc, 0);
1626 }
1627
1628 static int
1629 sysctl_procargs2(int *name, u_int namelen, user_addr_t where,
1630 size_t *sizep, proc_t cur_proc)
1631 {
1632 return sysctl_procargsx( name, namelen, where, sizep, cur_proc, 1);
1633 }
1634
1635 static int
1636 sysctl_procargsx(int *name, __unused u_int namelen, user_addr_t where,
1637 size_t *sizep, proc_t cur_proc, int argc_yes)
1638 {
1639 proc_t p;
1640 int buflen = where != USER_ADDR_NULL ? *sizep : 0;
1641 int error = 0;
1642 struct _vm_map *proc_map;
1643 struct task * task;
1644 vm_map_copy_t tmp;
1645 user_addr_t arg_addr;
1646 size_t arg_size;
1647 caddr_t data;
1648 size_t argslen=0;
1649 int size;
1650 vm_offset_t copy_start, copy_end;
1651 kern_return_t ret;
1652 int pid;
1653 kauth_cred_t my_cred;
1654 uid_t uid;
1655
1656 if (argc_yes)
1657 buflen -= sizeof(int); /* reserve first word to return argc */
1658
1659 /* we only care about buflen when where (oldp from sysctl) is not NULL. */
1660 /* when where (oldp from sysctl) is NULL and sizep (oldlenp from sysctl */
1661 /* is not NULL then the caller wants us to return the length needed to */
1662 /* hold the data we would return */
1663 if (where != USER_ADDR_NULL && (buflen <= 0 || buflen > ARG_MAX)) {
1664 return(EINVAL);
1665 }
1666 arg_size = buflen;
1667
1668 /*
1669 * Lookup process by pid
1670 */
1671 pid = name[0];
1672 p = proc_find(pid);
1673 if (p == NULL) {
1674 return(EINVAL);
1675 }
1676
1677 /*
1678 * Copy the top N bytes of the stack.
1679 * On all machines we have so far, the stack grows
1680 * downwards.
1681 *
1682 * If the user expects no more than N bytes of
1683 * argument list, use that as a guess for the
1684 * size.
1685 */
1686
1687 if (!p->user_stack) {
1688 proc_rele(p);
1689 return(EINVAL);
1690 }
1691
1692 if (where == USER_ADDR_NULL) {
1693 /* caller only wants to know length of proc args data */
1694 if (sizep == NULL) {
1695 proc_rele(p);
1696 return(EFAULT);
1697 }
1698
1699 size = p->p_argslen;
1700 proc_rele(p);
1701 if (argc_yes) {
1702 size += sizeof(int);
1703 }
1704 else {
1705 /*
1706 * old PROCARGS will return the executable's path and plus some
1707 * extra space for work alignment and data tags
1708 */
1709 size += PATH_MAX + (6 * sizeof(int));
1710 }
1711 size += (size & (sizeof(int) - 1)) ? (sizeof(int) - (size & (sizeof(int) - 1))) : 0;
1712 *sizep = size;
1713 return (0);
1714 }
1715
1716 my_cred = kauth_cred_proc_ref(p);
1717 uid = kauth_cred_getuid(my_cred);
1718 kauth_cred_unref(&my_cred);
1719
1720 if ((uid != kauth_cred_getuid(kauth_cred_get()))
1721 && suser(kauth_cred_get(), &cur_proc->p_acflag)) {
1722 proc_rele(p);
1723 return (EINVAL);
1724 }
1725
1726 if ((u_int)arg_size > p->p_argslen)
1727 arg_size = round_page(p->p_argslen);
1728
1729 arg_addr = p->user_stack - arg_size;
1730
1731
1732 /*
1733 * Before we can block (any VM code), make another
1734 * reference to the map to keep it alive. We do
1735 * that by getting a reference on the task itself.
1736 */
1737 task = p->task;
1738 if (task == NULL) {
1739 proc_rele(p);
1740 return(EINVAL);
1741 }
1742
1743 argslen = p->p_argslen;
1744 /*
1745 * Once we have a task reference we can convert that into a
1746 * map reference, which we will use in the calls below. The
1747 * task/process may change its map after we take this reference
1748 * (see execve), but the worst that will happen then is a return
1749 * of stale info (which is always a possibility).
1750 */
1751 task_reference(task);
1752 proc_rele(p);
1753 proc_map = get_task_map_reference(task);
1754 task_deallocate(task);
1755
1756 if (proc_map == NULL)
1757 return(EINVAL);
1758
1759
1760 ret = kmem_alloc(kernel_map, &copy_start, round_page(arg_size));
1761 if (ret != KERN_SUCCESS) {
1762 vm_map_deallocate(proc_map);
1763 return(ENOMEM);
1764 }
1765
1766 copy_end = round_page(copy_start + arg_size);
1767
1768 if( vm_map_copyin(proc_map, (vm_map_address_t)arg_addr,
1769 (vm_map_size_t)arg_size, FALSE, &tmp) != KERN_SUCCESS) {
1770 vm_map_deallocate(proc_map);
1771 kmem_free(kernel_map, copy_start,
1772 round_page(arg_size));
1773 return (EIO);
1774 }
1775
1776 /*
1777 * Now that we've done the copyin from the process'
1778 * map, we can release the reference to it.
1779 */
1780 vm_map_deallocate(proc_map);
1781
1782 if( vm_map_copy_overwrite(kernel_map,
1783 (vm_map_address_t)copy_start,
1784 tmp, FALSE) != KERN_SUCCESS) {
1785 kmem_free(kernel_map, copy_start,
1786 round_page(arg_size));
1787 return (EIO);
1788 }
1789
1790 if (arg_size > argslen) {
1791 data = (caddr_t) (copy_end - argslen);
1792 size = argslen;
1793 } else {
1794 data = (caddr_t) (copy_end - arg_size);
1795 size = arg_size;
1796 }
1797
1798 if (argc_yes) {
1799 /* Put processes argc as the first word in the copyout buffer */
1800 suword(where, p->p_argc);
1801 error = copyout(data, (where + sizeof(int)), size);
1802 size += sizeof(int);
1803 } else {
1804 error = copyout(data, where, size);
1805
1806 /*
1807 * Make the old PROCARGS work to return the executable's path
1808 * But, only if there is enough space in the provided buffer
1809 *
1810 * on entry: data [possibily] points to the beginning of the path
1811 *
1812 * Note: we keep all pointers&sizes aligned to word boundries
1813 */
1814 if ( (! error) && (buflen > 0 && (u_int)buflen > argslen) )
1815 {
1816 int binPath_sz, alignedBinPath_sz = 0;
1817 int extraSpaceNeeded, addThis;
1818 user_addr_t placeHere;
1819 char * str = (char *) data;
1820 int max_len = size;
1821
1822 /* Some apps are really bad about messing up their stacks
1823 So, we have to be extra careful about getting the length
1824 of the executing binary. If we encounter an error, we bail.
1825 */
1826
1827 /* Limit ourselves to PATH_MAX paths */
1828 if ( max_len > PATH_MAX ) max_len = PATH_MAX;
1829
1830 binPath_sz = 0;
1831
1832 while ( (binPath_sz < max_len-1) && (*str++ != 0) )
1833 binPath_sz++;
1834
1835 /* If we have a NUL terminator, copy it, too */
1836 if (binPath_sz < max_len-1) binPath_sz += 1;
1837
1838 /* Pre-Flight the space requiremnts */
1839
1840 /* Account for the padding that fills out binPath to the next word */
1841 alignedBinPath_sz += (binPath_sz & (sizeof(int)-1)) ? (sizeof(int)-(binPath_sz & (sizeof(int)-1))) : 0;
1842
1843 placeHere = where + size;
1844
1845 /* Account for the bytes needed to keep placeHere word aligned */
1846 addThis = (placeHere & (sizeof(int)-1)) ? (sizeof(int)-(placeHere & (sizeof(int)-1))) : 0;
1847
1848 /* Add up all the space that is needed */
1849 extraSpaceNeeded = alignedBinPath_sz + addThis + binPath_sz + (4 * sizeof(int));
1850
1851 /* is there is room to tack on argv[0]? */
1852 if ( (buflen & ~(sizeof(int)-1)) >= ( argslen + extraSpaceNeeded ))
1853 {
1854 placeHere += addThis;
1855 suword(placeHere, 0);
1856 placeHere += sizeof(int);
1857 suword(placeHere, 0xBFFF0000);
1858 placeHere += sizeof(int);
1859 suword(placeHere, 0);
1860 placeHere += sizeof(int);
1861 error = copyout(data, placeHere, binPath_sz);
1862 if ( ! error )
1863 {
1864 placeHere += binPath_sz;
1865 suword(placeHere, 0);
1866 size += extraSpaceNeeded;
1867 }
1868 }
1869 }
1870 }
1871
1872 if (copy_start != (vm_offset_t) 0) {
1873 kmem_free(kernel_map, copy_start, copy_end - copy_start);
1874 }
1875 if (error) {
1876 return(error);
1877 }
1878
1879 if (where != USER_ADDR_NULL)
1880 *sizep = size;
1881 return (0);
1882 }
1883
1884
1885 /*
1886 * Max number of concurrent aio requests
1887 */
1888 static int
1889 sysctl_aiomax
1890 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
1891 {
1892 int new_value, changed;
1893 int error = sysctl_io_number(req, aio_max_requests, sizeof(int), &new_value, &changed);
1894 if (changed) {
1895 /* make sure the system-wide limit is greater than the per process limit */
1896 if (new_value >= aio_max_requests_per_process)
1897 aio_max_requests = new_value;
1898 else
1899 error = EINVAL;
1900 }
1901 return(error);
1902 }
1903
1904
1905 /*
1906 * Max number of concurrent aio requests per process
1907 */
1908 static int
1909 sysctl_aioprocmax
1910 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
1911 {
1912 int new_value, changed;
1913 int error = sysctl_io_number(req, aio_max_requests_per_process, sizeof(int), &new_value, &changed);
1914 if (changed) {
1915 /* make sure per process limit is less than the system-wide limit */
1916 if (new_value <= aio_max_requests && new_value >= AIO_LISTIO_MAX)
1917 aio_max_requests_per_process = new_value;
1918 else
1919 error = EINVAL;
1920 }
1921 return(error);
1922 }
1923
1924
1925 /*
1926 * Max number of async IO worker threads
1927 */
1928 static int
1929 sysctl_aiothreads
1930 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
1931 {
1932 int new_value, changed;
1933 int error = sysctl_io_number(req, aio_worker_threads, sizeof(int), &new_value, &changed);
1934 if (changed) {
1935 /* we only allow an increase in the number of worker threads */
1936 if (new_value > aio_worker_threads ) {
1937 _aio_create_worker_threads((new_value - aio_worker_threads));
1938 aio_worker_threads = new_value;
1939 }
1940 else
1941 error = EINVAL;
1942 }
1943 return(error);
1944 }
1945
1946
1947 /*
1948 * System-wide limit on the max number of processes
1949 */
1950 static int
1951 sysctl_maxproc
1952 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
1953 {
1954 int new_value, changed;
1955 int error = sysctl_io_number(req, maxproc, sizeof(int), &new_value, &changed);
1956 if (changed) {
1957 AUDIT_ARG(value, new_value);
1958 /* make sure the system-wide limit is less than the configured hard
1959 limit set at kernel compilation */
1960 if (new_value <= hard_maxproc && new_value > 0)
1961 maxproc = new_value;
1962 else
1963 error = EINVAL;
1964 }
1965 return(error);
1966 }
1967
1968 SYSCTL_STRING(_kern, KERN_OSTYPE, ostype,
1969 CTLFLAG_RD | CTLFLAG_KERN,
1970 ostype, 0, "");
1971 SYSCTL_STRING(_kern, KERN_OSRELEASE, osrelease,
1972 CTLFLAG_RD | CTLFLAG_KERN,
1973 osrelease, 0, "");
1974 SYSCTL_INT(_kern, KERN_OSREV, osrevision,
1975 CTLFLAG_RD | CTLFLAG_KERN,
1976 NULL, BSD, "");
1977 SYSCTL_STRING(_kern, KERN_VERSION, version,
1978 CTLFLAG_RD | CTLFLAG_KERN,
1979 version, 0, "");
1980
1981 /* PR-5293665: need to use a callback function for kern.osversion to set
1982 * osversion in IORegistry */
1983
1984 static int
1985 sysctl_osversion(__unused struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req)
1986 {
1987 int rval = 0;
1988
1989 rval = sysctl_handle_string(oidp, arg1, arg2, req);
1990
1991 if (req->newptr) {
1992 IORegistrySetOSBuildVersion((char *)arg1);
1993 }
1994
1995 return rval;
1996 }
1997
1998 SYSCTL_PROC(_kern, KERN_OSVERSION, osversion,
1999 CTLFLAG_RW | CTLFLAG_KERN | CTLTYPE_STRING,
2000 osversion, 256 /* OSVERSIZE*/,
2001 sysctl_osversion, "A", "");
2002
2003 static int
2004 sysctl_sysctl_bootargs
2005 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2006 {
2007 int error;
2008 char buf[256];
2009
2010 strlcpy(buf, PE_boot_args(), 256);
2011 error = sysctl_io_string(req, buf, 256, 0, NULL);
2012 return(error);
2013 }
2014
2015 SYSCTL_PROC(_kern, OID_AUTO, bootargs,
2016 CTLFLAG_LOCKED | CTLFLAG_RD | CTLFLAG_KERN | CTLTYPE_STRING,
2017 NULL, 0,
2018 sysctl_sysctl_bootargs, "A", "bootargs");
2019
2020 SYSCTL_INT(_kern, KERN_MAXFILES, maxfiles,
2021 CTLFLAG_RW | CTLFLAG_KERN,
2022 &maxfiles, 0, "");
2023 SYSCTL_INT(_kern, KERN_ARGMAX, argmax,
2024 CTLFLAG_RD | CTLFLAG_KERN,
2025 NULL, ARG_MAX, "");
2026 SYSCTL_INT(_kern, KERN_POSIX1, posix1version,
2027 CTLFLAG_RD | CTLFLAG_KERN,
2028 NULL, _POSIX_VERSION, "");
2029 SYSCTL_INT(_kern, KERN_NGROUPS, ngroups,
2030 CTLFLAG_RD | CTLFLAG_KERN,
2031 NULL, NGROUPS_MAX, "");
2032 SYSCTL_INT(_kern, KERN_JOB_CONTROL, job_control,
2033 CTLFLAG_RD | CTLFLAG_KERN,
2034 NULL, 1, "");
2035 #if 1 /* _POSIX_SAVED_IDS from <unistd.h> */
2036 SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids,
2037 CTLFLAG_RD | CTLFLAG_KERN,
2038 NULL, 1, "");
2039 #else
2040 SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids,
2041 CTLFLAG_RD | CTLFLAG_KERN,
2042 NULL, 0, "");
2043 #endif
2044
2045 static int
2046 sysctl_maxvnodes (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2047 {
2048 unsigned int oldval = desiredvnodes;
2049 int error = sysctl_io_number(req, desiredvnodes, sizeof(int), &desiredvnodes, NULL);
2050 reset_vmobjectcache(oldval, desiredvnodes);
2051 resize_namecache(desiredvnodes);
2052 return(error);
2053 }
2054
2055 SYSCTL_PROC(_kern, KERN_MAXVNODES, maxvnodes,
2056 CTLTYPE_INT | CTLFLAG_RW,
2057 0, 0, sysctl_maxvnodes, "I", "");
2058
2059 SYSCTL_PROC(_kern, KERN_MAXPROC, maxproc,
2060 CTLTYPE_INT | CTLFLAG_RW,
2061 0, 0, sysctl_maxproc, "I", "");
2062
2063 SYSCTL_PROC(_kern, KERN_AIOMAX, aiomax,
2064 CTLTYPE_INT | CTLFLAG_RW,
2065 0, 0, sysctl_aiomax, "I", "");
2066
2067 SYSCTL_PROC(_kern, KERN_AIOPROCMAX, aioprocmax,
2068 CTLTYPE_INT | CTLFLAG_RW,
2069 0, 0, sysctl_aioprocmax, "I", "");
2070
2071 SYSCTL_PROC(_kern, KERN_AIOTHREADS, aiothreads,
2072 CTLTYPE_INT | CTLFLAG_RW,
2073 0, 0, sysctl_aiothreads, "I", "");
2074
2075 static int
2076 sysctl_securelvl
2077 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2078 {
2079 int new_value, changed;
2080 int error = sysctl_io_number(req, securelevel, sizeof(int), &new_value, &changed);
2081 if (changed) {
2082 if (!(new_value < securelevel && req->p->p_pid != 1)) {
2083 proc_list_lock();
2084 securelevel = new_value;
2085 proc_list_unlock();
2086 } else {
2087 error = EPERM;
2088 }
2089 }
2090 return(error);
2091 }
2092
2093 SYSCTL_PROC(_kern, KERN_SECURELVL, securelevel,
2094 CTLTYPE_INT | CTLFLAG_RW,
2095 0, 0, sysctl_securelvl, "I", "");
2096
2097
2098 static int
2099 sysctl_domainname
2100 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2101 {
2102 int error, changed;
2103 error = sysctl_io_string(req, domainname, sizeof(domainname), 0, &changed);
2104 if (changed) {
2105 domainnamelen = strlen(domainname);
2106 }
2107 return(error);
2108 }
2109
2110 SYSCTL_PROC(_kern, KERN_DOMAINNAME, nisdomainname,
2111 CTLTYPE_STRING | CTLFLAG_RW,
2112 0, 0, sysctl_domainname, "A", "");
2113
2114 SYSCTL_INT(_kern, KERN_HOSTID, hostid,
2115 CTLFLAG_RW | CTLFLAG_KERN,
2116 &hostid, 0, "");
2117
2118 static int
2119 sysctl_hostname
2120 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2121 {
2122 int error, changed;
2123 error = sysctl_io_string(req, hostname, sizeof(hostname), 1, &changed);
2124 if (changed) {
2125 hostnamelen = req->newlen;
2126 }
2127 return(error);
2128 }
2129
2130
2131 SYSCTL_PROC(_kern, KERN_HOSTNAME, hostname,
2132 CTLTYPE_STRING | CTLFLAG_RW,
2133 0, 0, sysctl_hostname, "A", "");
2134
2135 static int
2136 sysctl_procname
2137 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2138 {
2139 /* Original code allowed writing, I'm copying this, although this all makes
2140 no sense to me. Besides, this sysctl is never used. */
2141 return sysctl_io_string(req, &req->p->p_name[0], (2*MAXCOMLEN+1), 1, NULL);
2142 }
2143
2144 SYSCTL_PROC(_kern, KERN_PROCNAME, procname,
2145 CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_ANYBODY,
2146 0, 0, sysctl_procname, "A", "");
2147
2148 SYSCTL_INT(_kern, KERN_SPECULATIVE_READS, speculative_reads_disabled,
2149 CTLFLAG_RW | CTLFLAG_KERN,
2150 &speculative_reads_disabled, 0, "");
2151
2152 static int
2153 sysctl_boottime
2154 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2155 {
2156 struct timeval t;
2157
2158 t.tv_sec = boottime_sec();
2159 t.tv_usec = 0;
2160
2161 return sysctl_io_opaque(req, &t, sizeof(t), NULL);
2162 }
2163
2164 SYSCTL_PROC(_kern, KERN_BOOTTIME, boottime,
2165 CTLTYPE_STRUCT | CTLFLAG_RD,
2166 0, 0, sysctl_boottime, "S,timeval", "");
2167
2168 static int
2169 sysctl_symfile
2170 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2171 {
2172 char *str;
2173 int error = get_kernel_symfile(req->p, &str);
2174 if (error)
2175 return (error);
2176 return sysctl_io_string(req, str, 0, 0, NULL);
2177 }
2178
2179
2180 SYSCTL_PROC(_kern, KERN_SYMFILE, symfile,
2181 CTLTYPE_STRING | CTLFLAG_RD,
2182 0, 0, sysctl_symfile, "A", "");
2183
2184 #if NFSCLIENT
2185 static int
2186 sysctl_netboot
2187 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2188 {
2189 return sysctl_io_number(req, netboot_root(), sizeof(int), NULL, NULL);
2190 }
2191
2192 SYSCTL_PROC(_kern, KERN_NETBOOT, netboot,
2193 CTLTYPE_INT | CTLFLAG_RD,
2194 0, 0, sysctl_netboot, "I", "");
2195 #endif
2196
2197 static int
2198 sysctl_usrstack
2199 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2200 {
2201 return sysctl_io_number(req, (int)req->p->user_stack, sizeof(int), NULL, NULL);
2202 }
2203
2204 SYSCTL_PROC(_kern, KERN_USRSTACK, usrstack,
2205 CTLTYPE_INT | CTLFLAG_RD,
2206 0, 0, sysctl_usrstack, "I", "");
2207
2208 static int
2209 sysctl_usrstack64
2210 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2211 {
2212 return sysctl_io_number(req, req->p->user_stack, sizeof(req->p->user_stack), NULL, NULL);
2213 }
2214
2215 SYSCTL_PROC(_kern, KERN_USRSTACK64, usrstack64,
2216 CTLTYPE_QUAD | CTLFLAG_RD,
2217 0, 0, sysctl_usrstack64, "Q", "");
2218
2219 SYSCTL_STRING(_kern, KERN_COREFILE, corefile,
2220 CTLFLAG_RW | CTLFLAG_KERN,
2221 corefilename, sizeof(corefilename), "");
2222
2223 static int
2224 sysctl_coredump
2225 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2226 {
2227 int new_value, changed;
2228 int error = sysctl_io_number(req, do_coredump, sizeof(int), &new_value, &changed);
2229 if (changed) {
2230 if ((new_value == 0) || (new_value == 1))
2231 do_coredump = new_value;
2232 else
2233 error = EINVAL;
2234 }
2235 return(error);
2236 }
2237
2238 SYSCTL_PROC(_kern, KERN_COREDUMP, coredump,
2239 CTLTYPE_INT | CTLFLAG_RW,
2240 0, 0, sysctl_coredump, "I", "");
2241
2242 static int
2243 sysctl_suid_coredump
2244 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2245 {
2246 int new_value, changed;
2247 int error = sysctl_io_number(req, sugid_coredump, sizeof(int), &new_value, &changed);
2248 if (changed) {
2249 if ((new_value == 0) || (new_value == 1))
2250 sugid_coredump = new_value;
2251 else
2252 error = EINVAL;
2253 }
2254 return(error);
2255 }
2256
2257 SYSCTL_PROC(_kern, KERN_SUGID_COREDUMP, sugid_coredump,
2258 CTLTYPE_INT | CTLFLAG_RW,
2259 0, 0, sysctl_suid_coredump, "I", "");
2260
2261 static int
2262 sysctl_delayterm
2263 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2264 {
2265 struct proc *p = req->p;
2266 int new_value, changed;
2267 int error = sysctl_io_number(req, (req->p->p_lflag & P_LDELAYTERM)? 1: 0, sizeof(int), &new_value, &changed);
2268 if (changed) {
2269 proc_lock(p);
2270 if (new_value)
2271 req->p->p_lflag |= P_LDELAYTERM;
2272 else
2273 req->p->p_lflag &= ~P_LDELAYTERM;
2274 proc_unlock(p);
2275 }
2276 return(error);
2277 }
2278
2279 SYSCTL_PROC(_kern, KERN_PROCDELAYTERM, delayterm,
2280 CTLTYPE_INT | CTLFLAG_RW,
2281 0, 0, sysctl_delayterm, "I", "");
2282
2283 static int
2284 sysctl_proc_low_pri_io
2285 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2286 {
2287 struct proc *p = req->p;
2288 int new_value, old_value, changed;
2289 int error;
2290
2291 proc_lock(p);
2292 switch (req->p->p_iopol_disk) {
2293 case IOPOL_DEFAULT:
2294 case IOPOL_NORMAL:
2295 old_value = 0;
2296 break;
2297 case IOPOL_THROTTLE:
2298 old_value = 1;
2299 break;
2300 case IOPOL_PASSIVE:
2301 old_value = 2;
2302 break;
2303 default:
2304 /*\ 5 this should never happen, but to be robust, return the default value */
2305 old_value = 0;
2306 break;
2307 }
2308 proc_unlock(p);
2309
2310 error = sysctl_io_number(req, old_value, sizeof(int), &new_value, &changed);
2311 if (changed) {
2312 proc_lock(p);
2313 if (new_value & 0x01)
2314 req->p->p_iopol_disk = IOPOL_THROTTLE;
2315 else if (new_value & 0x02)
2316 req->p->p_iopol_disk = IOPOL_PASSIVE;
2317 else if (new_value == 0)
2318 req->p->p_iopol_disk = IOPOL_NORMAL;
2319 proc_unlock(p);
2320 }
2321 return(error);
2322 }
2323
2324 SYSCTL_PROC(_kern, KERN_PROC_LOW_PRI_IO, proc_low_pri_io,
2325 CTLTYPE_INT | CTLFLAG_RW,
2326 0, 0, sysctl_proc_low_pri_io, "I", "");
2327
2328 static int
2329 sysctl_rage_vnode
2330 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2331 {
2332 struct proc *p = req->p;
2333 struct uthread *ut;
2334 int new_value, old_value, changed;
2335 int error;
2336
2337 ut = get_bsdthread_info(current_thread());
2338
2339 if (ut->uu_flag & UT_RAGE_VNODES)
2340 old_value = KERN_RAGE_THREAD;
2341 else if (p->p_lflag & P_LRAGE_VNODES)
2342 old_value = KERN_RAGE_PROC;
2343 else
2344 old_value = 0;
2345
2346 error = sysctl_io_number(req, old_value, sizeof(int), &new_value, &changed);
2347
2348 if (error == 0) {
2349 switch (new_value) {
2350 case KERN_RAGE_PROC:
2351 proc_lock(p);
2352 p->p_lflag |= P_LRAGE_VNODES;
2353 proc_unlock(p);
2354 break;
2355 case KERN_UNRAGE_PROC:
2356 proc_lock(p);
2357 p->p_lflag &= ~P_LRAGE_VNODES;
2358 proc_unlock(p);
2359 break;
2360
2361 case KERN_RAGE_THREAD:
2362 ut->uu_flag |= UT_RAGE_VNODES;
2363 break;
2364 case KERN_UNRAGE_THREAD:
2365 ut = get_bsdthread_info(current_thread());
2366 ut->uu_flag &= ~UT_RAGE_VNODES;
2367 break;
2368 }
2369 }
2370 return(error);
2371 }
2372
2373 SYSCTL_PROC(_kern, KERN_RAGEVNODE, rage_vnode,
2374 CTLTYPE_INT | CTLFLAG_RW,
2375 0, 0, sysctl_rage_vnode, "I", "");
2376
2377
2378 static int
2379 sysctl_kern_check_openevt
2380 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2381 {
2382 struct proc *p = req->p;
2383 int new_value, old_value, changed;
2384 int error;
2385
2386 if (p->p_flag & P_CHECKOPENEVT) {
2387 old_value = KERN_OPENEVT_PROC;
2388 } else {
2389 old_value = 0;
2390 }
2391
2392 error = sysctl_io_number(req, old_value, sizeof(int), &new_value, &changed);
2393
2394 if (error == 0) {
2395 switch (new_value) {
2396 case KERN_OPENEVT_PROC:
2397 OSBitOrAtomic(P_CHECKOPENEVT, (UInt32 *)&p->p_flag);
2398 break;
2399
2400 case KERN_UNOPENEVT_PROC:
2401 OSBitAndAtomic(~((uint32_t)P_CHECKOPENEVT), (UInt32 *)&p->p_flag);
2402 break;
2403
2404 default:
2405 error = EINVAL;
2406 }
2407 }
2408 return(error);
2409 }
2410
2411 SYSCTL_PROC(_kern, KERN_CHECKOPENEVT, check_openevt, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY,
2412 0, 0, sysctl_kern_check_openevt, "I", "set the per-process check-open-evt flag");
2413
2414
2415
2416 static int
2417 sysctl_nx
2418 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2419 {
2420 #ifdef SECURE_KERNEL
2421 return ENOTSUP;
2422 #endif
2423 int new_value, changed;
2424 int error;
2425
2426 error = sysctl_io_number(req, nx_enabled, sizeof(nx_enabled), &new_value, &changed);
2427 if (error)
2428 return error;
2429
2430 if (changed) {
2431 #ifdef __i386__
2432 /*
2433 * Only allow setting if NX is supported on the chip
2434 */
2435 if (!(cpuid_extfeatures() & CPUID_EXTFEATURE_XD))
2436 return ENOTSUP;
2437 #endif
2438 nx_enabled = new_value;
2439 }
2440 return(error);
2441 }
2442
2443
2444
2445 SYSCTL_PROC(_kern, KERN_NX_PROTECTION, nx,
2446 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_KERN,
2447 0, 0, sysctl_nx, "I", "");
2448
2449 static int
2450 sysctl_loadavg
2451 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2452 {
2453 if (proc_is64bit(req->p)) {
2454 struct user_loadavg loadinfo64;
2455 loadavg32to64(&averunnable, &loadinfo64);
2456 return sysctl_io_opaque(req, &loadinfo64, sizeof(loadinfo64), NULL);
2457 } else {
2458 return sysctl_io_opaque(req, &averunnable, sizeof(averunnable), NULL);
2459 }
2460 }
2461
2462 SYSCTL_PROC(_vm, VM_LOADAVG, loadavg,
2463 CTLTYPE_STRUCT | CTLFLAG_RD,
2464 0, 0, sysctl_loadavg, "S,loadavg", "");
2465
2466 static int
2467 sysctl_swapusage
2468 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2469 {
2470 int error;
2471 uint64_t swap_total;
2472 uint64_t swap_avail;
2473 uint32_t swap_pagesize;
2474 boolean_t swap_encrypted;
2475 struct xsw_usage xsu;
2476
2477 error = macx_swapinfo(&swap_total,
2478 &swap_avail,
2479 &swap_pagesize,
2480 &swap_encrypted);
2481 if (error)
2482 return error;
2483
2484 xsu.xsu_total = swap_total;
2485 xsu.xsu_avail = swap_avail;
2486 xsu.xsu_used = swap_total - swap_avail;
2487 xsu.xsu_pagesize = swap_pagesize;
2488 xsu.xsu_encrypted = swap_encrypted;
2489 return sysctl_io_opaque(req, &xsu, sizeof(xsu), NULL);
2490 }
2491
2492
2493
2494 SYSCTL_PROC(_vm, VM_SWAPUSAGE, swapusage,
2495 CTLTYPE_STRUCT | CTLFLAG_RD,
2496 0, 0, sysctl_swapusage, "S,xsw_usage", "");
2497
2498
2499 /* this kernel does NOT implement shared_region_make_private_np() */
2500 SYSCTL_INT(_kern, KERN_SHREG_PRIVATIZABLE, shreg_private,
2501 CTLFLAG_RD,
2502 NULL, 0, "");
2503
2504 #if __i386__
2505 static int
2506 sysctl_sysctl_exec_affinity(__unused struct sysctl_oid *oidp,
2507 __unused void *arg1, __unused int arg2,
2508 struct sysctl_req *req)
2509 {
2510 proc_t cur_proc = req->p;
2511 int error;
2512
2513 if (req->oldptr != USER_ADDR_NULL) {
2514 cpu_type_t oldcputype = (cur_proc->p_flag & P_AFFINITY) ? CPU_TYPE_POWERPC : CPU_TYPE_I386;
2515 if ((error = SYSCTL_OUT(req, &oldcputype, sizeof(oldcputype))))
2516 return error;
2517 }
2518
2519 if (req->newptr != USER_ADDR_NULL) {
2520 cpu_type_t newcputype;
2521 if ((error = SYSCTL_IN(req, &newcputype, sizeof(newcputype))))
2522 return error;
2523 if (newcputype == CPU_TYPE_I386)
2524 OSBitAndAtomic(~((uint32_t)P_AFFINITY), (UInt32 *)&cur_proc->p_flag);
2525 else if (newcputype == CPU_TYPE_POWERPC)
2526 OSBitOrAtomic(P_AFFINITY, (UInt32 *)&cur_proc->p_flag);
2527 else
2528 return (EINVAL);
2529 }
2530
2531 return 0;
2532 }
2533 SYSCTL_PROC(_sysctl, OID_AUTO, proc_exec_affinity, CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY, 0, 0, sysctl_sysctl_exec_affinity ,"I","proc_exec_affinity");
2534 #endif
2535
2536 static int
2537 fetch_process_cputype(
2538 proc_t cur_proc,
2539 int *name,
2540 u_int namelen,
2541 cpu_type_t *cputype)
2542 {
2543 proc_t p = PROC_NULL;
2544 int refheld = 0;
2545 cpu_type_t ret = 0;
2546 int error = 0;
2547
2548 if (namelen == 0)
2549 p = cur_proc;
2550 else if (namelen == 1) {
2551 p = proc_find(name[0]);
2552 if (p == NULL)
2553 return (EINVAL);
2554 refheld = 1;
2555 } else {
2556 error = EINVAL;
2557 goto out;
2558 }
2559
2560 #if __i386__
2561 if (p->p_flag & P_TRANSLATED) {
2562 ret = CPU_TYPE_POWERPC;
2563 }
2564 else
2565 #endif
2566 {
2567 ret = cpu_type();
2568 if (IS_64BIT_PROCESS(p))
2569 ret |= CPU_ARCH_ABI64;
2570 }
2571 *cputype = ret;
2572
2573 if (refheld != 0)
2574 proc_rele(p);
2575 out:
2576 return (error);
2577 }
2578
2579 static int
2580 sysctl_sysctl_native(__unused struct sysctl_oid *oidp, void *arg1, int arg2,
2581 struct sysctl_req *req)
2582 {
2583 int error;
2584 cpu_type_t proc_cputype = 0;
2585 if ((error = fetch_process_cputype(req->p, (int *)arg1, arg2, &proc_cputype)) != 0)
2586 return error;
2587 int res = 1;
2588 if ((proc_cputype & ~CPU_ARCH_MASK) != (cpu_type() & ~CPU_ARCH_MASK))
2589 res = 0;
2590 return SYSCTL_OUT(req, &res, sizeof(res));
2591 }
2592 SYSCTL_PROC(_sysctl, OID_AUTO, proc_native, CTLTYPE_NODE|CTLFLAG_RD, 0, 0, sysctl_sysctl_native ,"I","proc_native");
2593
2594 static int
2595 sysctl_sysctl_cputype(__unused struct sysctl_oid *oidp, void *arg1, int arg2,
2596 struct sysctl_req *req)
2597 {
2598 int error;
2599 cpu_type_t proc_cputype = 0;
2600 if ((error = fetch_process_cputype(req->p, (int *)arg1, arg2, &proc_cputype)) != 0)
2601 return error;
2602 return SYSCTL_OUT(req, &proc_cputype, sizeof(proc_cputype));
2603 }
2604 SYSCTL_PROC(_sysctl, OID_AUTO, proc_cputype, CTLTYPE_NODE|CTLFLAG_RD, 0, 0, sysctl_sysctl_cputype ,"I","proc_cputype");
2605
2606 static int
2607 sysctl_safeboot
2608 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2609 {
2610 return sysctl_io_number(req, boothowto & RB_SAFEBOOT ? 1 : 0, sizeof(int), NULL, NULL);
2611 }
2612
2613 SYSCTL_PROC(_kern, KERN_SAFEBOOT, safeboot,
2614 CTLTYPE_INT | CTLFLAG_RD,
2615 0, 0, sysctl_safeboot, "I", "");
2616
2617 static int
2618 sysctl_singleuser
2619 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2620 {
2621 return sysctl_io_number(req, boothowto & RB_SINGLE ? 1 : 0, sizeof(int), NULL, NULL);
2622 }
2623
2624 SYSCTL_PROC(_kern, OID_AUTO, singleuser,
2625 CTLTYPE_INT | CTLFLAG_RD,
2626 0, 0, sysctl_singleuser, "I", "");
2627
2628 /*
2629 * Controls for debugging affinity sets - see osfmk/kern/affinity.c
2630 */
2631 extern boolean_t affinity_sets_enabled;
2632 extern int affinity_sets_mapping;
2633
2634 SYSCTL_INT (_kern, OID_AUTO, affinity_sets_enabled,
2635 CTLFLAG_RW, (int *) &affinity_sets_enabled, 0, "hinting enabled");
2636 SYSCTL_INT (_kern, OID_AUTO, affinity_sets_mapping,
2637 CTLFLAG_RW, &affinity_sets_mapping, 0, "mapping policy");
2638
2639 /*
2640 * Limit on total memory users can wire.
2641 *
2642 * vm_global_user_wire_limit - system wide limit on wired memory from all processes combined.
2643 *
2644 * vm_user_wire_limit - per address space limit on wired memory. This puts a cap on the process's rlimit value.
2645 *
2646 * These values are initialized to reasonable defaults at boot time based on the available physical memory in
2647 * kmem_init().
2648 *
2649 * All values are in bytes.
2650 */
2651
2652 vm_map_size_t vm_global_user_wire_limit;
2653 vm_map_size_t vm_user_wire_limit;
2654
2655 SYSCTL_QUAD(_vm, OID_AUTO, global_user_wire_limit, CTLFLAG_RW, &vm_global_user_wire_limit, "");
2656 SYSCTL_QUAD(_vm, OID_AUTO, user_wire_limit, CTLFLAG_RW, &vm_user_wire_limit, "");
mirror of XNU