]> git.saurik.com Git - apple/xnu.git/blob - bsd/kern/kern_sysctl.c
projects / apple / xnu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
xnu-4903.231.4.tar.gz
[apple/xnu.git] / bsd / kern / kern_sysctl.c
1 /*
2 * Copyright (c) 2000-2011 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 #include <sys/memory_maintenance.h>
106 #include <sys/priv.h>
107 #include <stdatomic.h>
108
109 #include <security/audit/audit.h>
110 #include <kern/kalloc.h>
111
112 #include <machine/smp.h>
113 #include <mach/machine.h>
114 #include <mach/mach_host.h>
115 #include <mach/mach_types.h>
116 #include <mach/processor_info.h>
117 #include <mach/vm_param.h>
118 #include <kern/debug.h>
119 #include <kern/mach_param.h>
120 #include <kern/task.h>
121 #include <kern/thread.h>
122 #include <kern/thread_group.h>
123 #include <kern/processor.h>
124 #include <kern/cpu_number.h>
125 #include <kern/cpu_quiesce.h>
126 #include <kern/debug.h>
127 #include <kern/sched_prim.h>
128 #include <vm/vm_kern.h>
129 #include <vm/vm_map.h>
130 #include <mach/host_info.h>
131
132 #include <sys/mount_internal.h>
133 #include <sys/kdebug.h>
134
135 #include <IOKit/IOPlatformExpert.h>
136 #include <pexpert/pexpert.h>
137
138 #include <machine/machine_routines.h>
139 #include <machine/exec.h>
140
141 #include <vm/vm_protos.h>
142 #include <vm/vm_pageout.h>
143 #include <vm/vm_compressor_algorithms.h>
144 #include <sys/imgsrc.h>
145 #include <kern/timer_call.h>
146
147 #if defined(__i386__) || defined(__x86_64__)
148 #include <i386/cpuid.h>
149 #endif
150
151 #if CONFIG_FREEZE
152 #include <sys/kern_memorystatus.h>
153 #endif
154
155 #if KPERF
156 #include <kperf/kperf.h>
157 #endif
158
159 #if HYPERVISOR
160 #include <kern/hv_support.h>
161 #endif
162
163 /*
164 * deliberately setting max requests to really high number
165 * so that runaway settings do not cause MALLOC overflows
166 */
167 #define AIO_MAX_REQUESTS (128 * CONFIG_AIO_MAX)
168
169 extern int aio_max_requests;
170 extern int aio_max_requests_per_process;
171 extern int aio_worker_threads;
172 extern int lowpri_IO_window_msecs;
173 extern int lowpri_IO_delay_msecs;
174 extern int nx_enabled;
175 extern int speculative_reads_disabled;
176 extern unsigned int speculative_prefetch_max;
177 extern unsigned int speculative_prefetch_max_iosize;
178 extern unsigned int preheat_max_bytes;
179 extern unsigned int preheat_min_bytes;
180 extern long numvnodes;
181
182 extern uuid_string_t bootsessionuuid_string;
183
184 extern unsigned int vm_max_delayed_work_limit;
185 extern unsigned int vm_max_batch;
186
187 extern unsigned int vm_page_free_min;
188 extern unsigned int vm_page_free_target;
189 extern unsigned int vm_page_free_reserved;
190
191 #if (DEVELOPMENT || DEBUG)
192 extern uint32_t vm_page_creation_throttled_hard;
193 extern uint32_t vm_page_creation_throttled_soft;
194 #endif /* DEVELOPMENT || DEBUG */
195
196 /*
197 * Conditionally allow dtrace to see these functions for debugging purposes.
198 */
199 #ifdef STATIC
200 #undef STATIC
201 #endif
202 #if 0
203 #define STATIC
204 #else
205 #define STATIC static
206 #endif
207
208 extern boolean_t mach_timer_coalescing_enabled;
209
210 extern uint64_t timer_deadline_tracking_bin_1, timer_deadline_tracking_bin_2;
211
212 STATIC void
213 fill_user32_eproc(proc_t, struct user32_eproc *__restrict);
214 STATIC void
215 fill_user32_externproc(proc_t, struct user32_extern_proc *__restrict);
216 STATIC void
217 fill_user64_eproc(proc_t, struct user64_eproc *__restrict);
218 STATIC void
219 fill_user64_proc(proc_t, struct user64_kinfo_proc *__restrict);
220 STATIC void
221 fill_user64_externproc(proc_t, struct user64_extern_proc *__restrict);
222 STATIC void
223 fill_user32_proc(proc_t, struct user32_kinfo_proc *__restrict);
224
225 extern int
226 kdbg_control(int *name, u_int namelen, user_addr_t where, size_t * sizep);
227 #if NFSCLIENT
228 extern int
229 netboot_root(void);
230 #endif
231 int
232 pcsamples_ops(int *name, u_int namelen, user_addr_t where, size_t *sizep,
233 proc_t p);
234 int
235 sysctl_procargs(int *name, u_int namelen, user_addr_t where,
236 size_t *sizep, proc_t cur_proc);
237 STATIC int
238 sysctl_procargsx(int *name, u_int namelen, user_addr_t where, size_t *sizep,
239 proc_t cur_proc, int argc_yes);
240 int
241 sysctl_struct(user_addr_t oldp, size_t *oldlenp, user_addr_t newp,
242 size_t newlen, void *sp, int len);
243
244 STATIC int sysdoproc_filt_KERN_PROC_PID(proc_t p, void * arg);
245 STATIC int sysdoproc_filt_KERN_PROC_PGRP(proc_t p, void * arg);
246 STATIC int sysdoproc_filt_KERN_PROC_TTY(proc_t p, void * arg);
247 STATIC int sysdoproc_filt_KERN_PROC_UID(proc_t p, void * arg);
248 STATIC int sysdoproc_filt_KERN_PROC_RUID(proc_t p, void * arg);
249 int sysdoproc_callback(proc_t p, void *arg);
250
251
252 /* forward declarations for non-static STATIC */
253 STATIC void fill_loadavg64(struct loadavg *la, struct user64_loadavg *la64);
254 STATIC void fill_loadavg32(struct loadavg *la, struct user32_loadavg *la32);
255 STATIC int sysctl_handle_kern_threadname(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
256 STATIC int sysctl_sched_stats(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
257 STATIC int sysctl_sched_stats_enable(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
258 STATIC int sysctl_kdebug_ops SYSCTL_HANDLER_ARGS;
259 #if COUNT_SYSCALLS
260 STATIC int sysctl_docountsyscalls SYSCTL_HANDLER_ARGS;
261 #endif /* COUNT_SYSCALLS */
262 #if !CONFIG_EMBEDDED
263 STATIC int sysctl_doprocargs SYSCTL_HANDLER_ARGS;
264 #endif /* !CONFIG_EMBEDDED */
265 STATIC int sysctl_doprocargs2 SYSCTL_HANDLER_ARGS;
266 STATIC int sysctl_prochandle SYSCTL_HANDLER_ARGS;
267 STATIC int sysctl_aiomax(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
268 STATIC int sysctl_aioprocmax(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
269 STATIC int sysctl_aiothreads(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
270 STATIC int sysctl_maxproc(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
271 STATIC int sysctl_osversion(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
272 STATIC int sysctl_sysctl_bootargs(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
273 STATIC int sysctl_maxvnodes(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
274 STATIC int sysctl_securelvl(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
275 STATIC int sysctl_domainname(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
276 STATIC int sysctl_hostname(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
277 STATIC int sysctl_procname(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
278 STATIC int sysctl_boottime(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
279 STATIC int sysctl_symfile(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
280 #if NFSCLIENT
281 STATIC int sysctl_netboot(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
282 #endif
283 #ifdef CONFIG_IMGSRC_ACCESS
284 STATIC int sysctl_imgsrcdev(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
285 #endif
286 STATIC int sysctl_usrstack(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
287 STATIC int sysctl_usrstack64(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
288 #if CONFIG_COREDUMP
289 STATIC int sysctl_coredump(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
290 STATIC int sysctl_suid_coredump(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
291 #endif
292 STATIC int sysctl_delayterm(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
293 STATIC int sysctl_rage_vnode(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
294 STATIC int sysctl_kern_check_openevt(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
295 STATIC int sysctl_nx(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
296 STATIC int sysctl_loadavg(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
297 STATIC int sysctl_vm_toggle_address_reuse(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
298 STATIC int sysctl_swapusage(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
299 STATIC int fetch_process_cputype( proc_t cur_proc, int *name, u_int namelen, cpu_type_t *cputype);
300 STATIC int sysctl_sysctl_native(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
301 STATIC int sysctl_sysctl_cputype(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
302 STATIC int sysctl_safeboot(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
303 STATIC int sysctl_singleuser(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
304 STATIC int sysctl_minimalboot(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
305 STATIC int sysctl_slide(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
306
307 #ifdef CONFIG_XNUPOST
308 #include <tests/xnupost.h>
309
310 STATIC int sysctl_debug_test_oslog_ctl(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
311 STATIC int sysctl_debug_test_stackshot_mutex_owner(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
312 STATIC int sysctl_debug_test_stackshot_rwlck_owner(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
313 #endif
314
315 extern void IORegistrySetOSBuildVersion(char * build_version);
316
317 STATIC void
318 fill_loadavg64(struct loadavg *la, struct user64_loadavg *la64)
319 {
320 la64->ldavg[0] = la->ldavg[0];
321 la64->ldavg[1] = la->ldavg[1];
322 la64->ldavg[2] = la->ldavg[2];
323 la64->fscale = (user64_long_t)la->fscale;
324 }
325
326 STATIC void
327 fill_loadavg32(struct loadavg *la, struct user32_loadavg *la32)
328 {
329 la32->ldavg[0] = la->ldavg[0];
330 la32->ldavg[1] = la->ldavg[1];
331 la32->ldavg[2] = la->ldavg[2];
332 la32->fscale = (user32_long_t)la->fscale;
333 }
334
335 #if CONFIG_COREDUMP
336 /*
337 * Attributes stored in the kernel.
338 */
339 extern char corefilename[MAXPATHLEN+1];
340 extern int do_coredump;
341 extern int sugid_coredump;
342 #endif
343
344 #if COUNT_SYSCALLS
345 extern int do_count_syscalls;
346 #endif
347
348 #ifdef INSECURE
349 int securelevel = -1;
350 #else
351 int securelevel;
352 #endif
353
354 STATIC int
355 sysctl_handle_kern_threadname( __unused struct sysctl_oid *oidp, __unused void *arg1,
356 __unused int arg2, struct sysctl_req *req)
357 {
358 int error;
359 struct uthread *ut = get_bsdthread_info(current_thread());
360 user_addr_t oldp=0, newp=0;
361 size_t *oldlenp=NULL;
362 size_t newlen=0;
363
364 oldp = req->oldptr;
365 oldlenp = &(req->oldlen);
366 newp = req->newptr;
367 newlen = req->newlen;
368
369 /* We want the current length, and maybe the string itself */
370 if(oldlenp) {
371 /* if we have no thread name yet tell'em we want MAXTHREADNAMESIZE - 1 */
372 size_t currlen = MAXTHREADNAMESIZE - 1;
373
374 if(ut->pth_name)
375 /* use length of current thread name */
376 currlen = strlen(ut->pth_name);
377 if(oldp) {
378 if(*oldlenp < currlen)
379 return ENOMEM;
380 /* NOTE - we do not copy the NULL terminator */
381 if(ut->pth_name) {
382 error = copyout(ut->pth_name,oldp,currlen);
383 if(error)
384 return error;
385 }
386 }
387 /* return length of thread name minus NULL terminator (just like strlen) */
388 req->oldidx = currlen;
389 }
390
391 /* We want to set the name to something */
392 if(newp)
393 {
394 if(newlen > (MAXTHREADNAMESIZE - 1))
395 return ENAMETOOLONG;
396 if(!ut->pth_name)
397 {
398 ut->pth_name = (char*)kalloc( MAXTHREADNAMESIZE );
399 if(!ut->pth_name)
400 return ENOMEM;
401 } else {
402 kernel_debug_string_simple(TRACE_STRING_THREADNAME_PREV, ut->pth_name);
403 }
404 bzero(ut->pth_name, MAXTHREADNAMESIZE);
405 error = copyin(newp, ut->pth_name, newlen);
406 if (error) {
407 return error;
408 }
409
410 kernel_debug_string_simple(TRACE_STRING_THREADNAME, ut->pth_name);
411 }
412
413 return 0;
414 }
415
416 SYSCTL_PROC(_kern, KERN_THREADNAME, threadname, CTLFLAG_ANYBODY | CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_LOCKED, 0, 0, sysctl_handle_kern_threadname,"A","");
417
418 #define BSD_HOST 1
419 STATIC int
420 sysctl_sched_stats(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
421 {
422 host_basic_info_data_t hinfo;
423 kern_return_t kret;
424 uint32_t size;
425 int changed;
426 mach_msg_type_number_t count = HOST_BASIC_INFO_COUNT;
427 struct _processor_statistics_np *buf;
428 int error;
429
430 kret = host_info((host_t)BSD_HOST, HOST_BASIC_INFO, (host_info_t)&hinfo, &count);
431 if (kret != KERN_SUCCESS) {
432 return EINVAL;
433 }
434
435 size = sizeof(struct _processor_statistics_np) * (hinfo.logical_cpu_max + 2); /* One for RT Queue, One for Fair Share Queue */
436
437 if (req->oldlen < size) {
438 return EINVAL;
439 }
440
441 MALLOC(buf, struct _processor_statistics_np*, size, M_TEMP, M_ZERO | M_WAITOK);
442
443 kret = get_sched_statistics(buf, &size);
444 if (kret != KERN_SUCCESS) {
445 error = EINVAL;
446 goto out;
447 }
448
449 error = sysctl_io_opaque(req, buf, size, &changed);
450 if (error) {
451 goto out;
452 }
453
454 if (changed) {
455 panic("Sched info changed?!");
456 }
457 out:
458 FREE(buf, M_TEMP);
459 return error;
460 }
461
462 SYSCTL_PROC(_kern, OID_AUTO, sched_stats, CTLFLAG_LOCKED, 0, 0, sysctl_sched_stats, "-", "");
463
464 STATIC int
465 sysctl_sched_stats_enable(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, __unused struct sysctl_req *req)
466 {
467 boolean_t active;
468 int res;
469
470 if (req->newlen != sizeof(active)) {
471 return EINVAL;
472 }
473
474 res = copyin(req->newptr, &active, sizeof(active));
475 if (res != 0) {
476 return res;
477 }
478
479 return set_sched_stats_active(active);
480 }
481
482 SYSCTL_PROC(_kern, OID_AUTO, sched_stats_enable, CTLFLAG_LOCKED | CTLFLAG_WR, 0, 0, sysctl_sched_stats_enable, "-", "");
483
484 extern uint32_t sched_debug_flags;
485 SYSCTL_INT(_debug, OID_AUTO, sched, CTLFLAG_RW | CTLFLAG_LOCKED, &sched_debug_flags, 0, "scheduler debug");
486
487 #if (DEBUG || DEVELOPMENT)
488 extern boolean_t doprnt_hide_pointers;
489 SYSCTL_INT(_debug, OID_AUTO, hide_kernel_pointers, CTLFLAG_RW | CTLFLAG_LOCKED, &doprnt_hide_pointers, 0, "hide kernel pointers from log");
490 #endif
491
492 extern int get_kernel_symfile(proc_t, char **);
493
494 #if COUNT_SYSCALLS
495 #define KERN_COUNT_SYSCALLS (KERN_OSTYPE + 1000)
496
497 extern unsigned int nsysent;
498 extern int syscalls_log[];
499 extern const char *syscallnames[];
500
501 STATIC int
502 sysctl_docountsyscalls SYSCTL_HANDLER_ARGS
503 {
504 __unused int cmd = oidp->oid_arg2; /* subcommand*/
505 __unused int *name = arg1; /* oid element argument vector */
506 __unused int namelen = arg2; /* number of oid element arguments */
507 user_addr_t oldp = req->oldptr; /* user buffer copy out address */
508 size_t *oldlenp = &req->oldlen; /* user buffer copy out size */
509 user_addr_t newp = req->newptr; /* user buffer copy in address */
510 size_t newlen = req->newlen; /* user buffer copy in size */
511 int error;
512
513 int tmp;
514
515 /* valid values passed in:
516 * = 0 means don't keep called counts for each bsd syscall
517 * > 0 means keep called counts for each bsd syscall
518 * = 2 means dump current counts to the system log
519 * = 3 means reset all counts
520 * for example, to dump current counts:
521 * sysctl -w kern.count_calls=2
522 */
523 error = sysctl_int(oldp, oldlenp, newp, newlen, &tmp);
524 if ( error != 0 ) {
525 return (error);
526 }
527
528 if ( tmp == 1 ) {
529 do_count_syscalls = 1;
530 }
531 else if ( tmp == 0 || tmp == 2 || tmp == 3 ) {
532 int i;
533 for ( i = 0; i < nsysent; i++ ) {
534 if ( syscalls_log[i] != 0 ) {
535 if ( tmp == 2 ) {
536 printf("%d calls - name %s \n", syscalls_log[i], syscallnames[i]);
537 }
538 else {
539 syscalls_log[i] = 0;
540 }
541 }
542 }
543 if ( tmp != 0 ) {
544 do_count_syscalls = 1;
545 }
546 }
547
548 /* adjust index so we return the right required/consumed amount */
549 if (!error)
550 req->oldidx += req->oldlen;
551
552 return (error);
553 }
554 SYSCTL_PROC(_kern, KERN_COUNT_SYSCALLS, count_syscalls, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
555 0, /* Pointer argument (arg1) */
556 0, /* Integer argument (arg2) */
557 sysctl_docountsyscalls, /* Handler function */
558 NULL, /* Data pointer */
559 "");
560 #endif /* COUNT_SYSCALLS */
561
562 /*
563 * The following sysctl_* functions should not be used
564 * any more, as they can only cope with callers in
565 * user mode: Use new-style
566 * sysctl_io_number()
567 * sysctl_io_string()
568 * sysctl_io_opaque()
569 * instead.
570 */
571
572 /*
573 * Validate parameters and get old / set new parameters
574 * for an integer-valued sysctl function.
575 */
576 int
577 sysctl_int(user_addr_t oldp, size_t *oldlenp,
578 user_addr_t newp, size_t newlen, int *valp)
579 {
580 int error = 0;
581
582 if (oldp != USER_ADDR_NULL && oldlenp == NULL)
583 return (EFAULT);
584 if (oldp && *oldlenp < sizeof(int))
585 return (ENOMEM);
586 if (newp && newlen != sizeof(int))
587 return (EINVAL);
588 *oldlenp = sizeof(int);
589 if (oldp)
590 error = copyout(valp, oldp, sizeof(int));
591 if (error == 0 && newp) {
592 error = copyin(newp, valp, sizeof(int));
593 AUDIT_ARG(value32, *valp);
594 }
595 return (error);
596 }
597
598 /*
599 * Validate parameters and get old / set new parameters
600 * for an quad(64bit)-valued sysctl function.
601 */
602 int
603 sysctl_quad(user_addr_t oldp, size_t *oldlenp,
604 user_addr_t newp, size_t newlen, quad_t *valp)
605 {
606 int error = 0;
607
608 if (oldp != USER_ADDR_NULL && oldlenp == NULL)
609 return (EFAULT);
610 if (oldp && *oldlenp < sizeof(quad_t))
611 return (ENOMEM);
612 if (newp && newlen != sizeof(quad_t))
613 return (EINVAL);
614 *oldlenp = sizeof(quad_t);
615 if (oldp)
616 error = copyout(valp, oldp, sizeof(quad_t));
617 if (error == 0 && newp)
618 error = copyin(newp, valp, sizeof(quad_t));
619 return (error);
620 }
621
622 STATIC int
623 sysdoproc_filt_KERN_PROC_PID(proc_t p, void * arg)
624 {
625 if (p->p_pid != (pid_t)*(int*)arg)
626 return(0);
627 else
628 return(1);
629 }
630
631 STATIC int
632 sysdoproc_filt_KERN_PROC_PGRP(proc_t p, void * arg)
633 {
634 if (p->p_pgrpid != (pid_t)*(int*)arg)
635 return(0);
636 else
637 return(1);
638 }
639
640 STATIC int
641 sysdoproc_filt_KERN_PROC_TTY(proc_t p, void * arg)
642 {
643 int retval;
644 struct tty *tp;
645
646 /* This is very racy but list lock is held.. Hmmm. */
647 if ((p->p_flag & P_CONTROLT) == 0 ||
648 (p->p_pgrp == NULL) || (p->p_pgrp->pg_session == NULL) ||
649 (tp = SESSION_TP(p->p_pgrp->pg_session)) == TTY_NULL ||
650 tp->t_dev != (dev_t)*(int*)arg)
651 retval = 0;
652 else
653 retval = 1;
654
655 return(retval);
656 }
657
658 STATIC int
659 sysdoproc_filt_KERN_PROC_UID(proc_t p, void * arg)
660 {
661 kauth_cred_t my_cred;
662 uid_t uid;
663
664 if (p->p_ucred == NULL)
665 return(0);
666 my_cred = kauth_cred_proc_ref(p);
667 uid = kauth_cred_getuid(my_cred);
668 kauth_cred_unref(&my_cred);
669
670 if (uid != (uid_t)*(int*)arg)
671 return(0);
672 else
673 return(1);
674 }
675
676
677 STATIC int
678 sysdoproc_filt_KERN_PROC_RUID(proc_t p, void * arg)
679 {
680 kauth_cred_t my_cred;
681 uid_t ruid;
682
683 if (p->p_ucred == NULL)
684 return(0);
685 my_cred = kauth_cred_proc_ref(p);
686 ruid = kauth_cred_getruid(my_cred);
687 kauth_cred_unref(&my_cred);
688
689 if (ruid != (uid_t)*(int*)arg)
690 return(0);
691 else
692 return(1);
693 }
694
695 /*
696 * try over estimating by 5 procs
697 */
698 #define KERN_PROCSLOP (5 * sizeof (struct kinfo_proc))
699 struct sysdoproc_args {
700 int buflen;
701 void *kprocp;
702 boolean_t is_64_bit;
703 user_addr_t dp;
704 size_t needed;
705 int sizeof_kproc;
706 int *errorp;
707 int uidcheck;
708 int ruidcheck;
709 int ttycheck;
710 int uidval;
711 };
712
713 int
714 sysdoproc_callback(proc_t p, void *arg)
715 {
716 struct sysdoproc_args *args = arg;
717
718 if (args->buflen >= args->sizeof_kproc) {
719 if ((args->ruidcheck != 0) && (sysdoproc_filt_KERN_PROC_RUID(p, &args->uidval) == 0))
720 return (PROC_RETURNED);
721 if ((args->uidcheck != 0) && (sysdoproc_filt_KERN_PROC_UID(p, &args->uidval) == 0))
722 return (PROC_RETURNED);
723 if ((args->ttycheck != 0) && (sysdoproc_filt_KERN_PROC_TTY(p, &args->uidval) == 0))
724 return (PROC_RETURNED);
725
726 bzero(args->kprocp, args->sizeof_kproc);
727 if (args->is_64_bit)
728 fill_user64_proc(p, args->kprocp);
729 else
730 fill_user32_proc(p, args->kprocp);
731 int error = copyout(args->kprocp, args->dp, args->sizeof_kproc);
732 if (error) {
733 *args->errorp = error;
734 return (PROC_RETURNED_DONE);
735 }
736 args->dp += args->sizeof_kproc;
737 args->buflen -= args->sizeof_kproc;
738 }
739 args->needed += args->sizeof_kproc;
740 return (PROC_RETURNED);
741 }
742
743 SYSCTL_NODE(_kern, KERN_PROC, proc, CTLFLAG_RD | CTLFLAG_LOCKED, 0, "");
744 STATIC int
745 sysctl_prochandle SYSCTL_HANDLER_ARGS
746 {
747 int cmd = oidp->oid_arg2; /* subcommand for multiple nodes */
748 int *name = arg1; /* oid element argument vector */
749 int namelen = arg2; /* number of oid element arguments */
750 user_addr_t where = req->oldptr;/* user buffer copy out address */
751
752 user_addr_t dp = where;
753 size_t needed = 0;
754 int buflen = where != USER_ADDR_NULL ? req->oldlen : 0;
755 int error = 0;
756 boolean_t is_64_bit = proc_is64bit(current_proc());
757 struct user32_kinfo_proc user32_kproc;
758 struct user64_kinfo_proc user_kproc;
759 int sizeof_kproc;
760 void *kprocp;
761 int (*filterfn)(proc_t, void *) = 0;
762 struct sysdoproc_args args;
763 int uidcheck = 0;
764 int ruidcheck = 0;
765 int ttycheck = 0;
766 int success = 0;
767
768 if (namelen != 1 && !(namelen == 0 && cmd == KERN_PROC_ALL))
769 return (EINVAL);
770
771 if (is_64_bit) {
772 sizeof_kproc = sizeof(user_kproc);
773 kprocp = &user_kproc;
774 } else {
775 sizeof_kproc = sizeof(user32_kproc);
776 kprocp = &user32_kproc;
777 }
778
779 switch (cmd) {
780
781 case KERN_PROC_PID:
782 filterfn = sysdoproc_filt_KERN_PROC_PID;
783 break;
784
785 case KERN_PROC_PGRP:
786 filterfn = sysdoproc_filt_KERN_PROC_PGRP;
787 break;
788
789 case KERN_PROC_TTY:
790 ttycheck = 1;
791 break;
792
793 case KERN_PROC_UID:
794 uidcheck = 1;
795 break;
796
797 case KERN_PROC_RUID:
798 ruidcheck = 1;
799 break;
800
801 case KERN_PROC_ALL:
802 break;
803
804 default:
805 /* must be kern.proc.<unknown> */
806 return (ENOTSUP);
807 }
808
809 error = 0;
810 args.buflen = buflen;
811 args.kprocp = kprocp;
812 args.is_64_bit = is_64_bit;
813 args.dp = dp;
814 args.needed = needed;
815 args.errorp = &error;
816 args.uidcheck = uidcheck;
817 args.ruidcheck = ruidcheck;
818 args.ttycheck = ttycheck;
819 args.sizeof_kproc = sizeof_kproc;
820 if (namelen)
821 args.uidval = name[0];
822
823 success = proc_iterate((PROC_ALLPROCLIST | PROC_ZOMBPROCLIST),
824 sysdoproc_callback, &args, filterfn, name);
825
826 /*
827 * rdar://problem/28433391: if we can't iterate over the processes,
828 * make sure to return an error.
829 */
830
831 if (success != 0)
832 return (ENOMEM);
833
834 if (error)
835 return (error);
836
837 dp = args.dp;
838 needed = args.needed;
839
840 if (where != USER_ADDR_NULL) {
841 req->oldlen = dp - where;
842 if (needed > req->oldlen)
843 return (ENOMEM);
844 } else {
845 needed += KERN_PROCSLOP;
846 req->oldlen = needed;
847 }
848 /* adjust index so we return the right required/consumed amount */
849 req->oldidx += req->oldlen;
850 return (0);
851 }
852
853 /*
854 * We specify the subcommand code for multiple nodes as the 'req->arg2' value
855 * in the sysctl declaration itself, which comes into the handler function
856 * as 'oidp->oid_arg2'.
857 *
858 * For these particular sysctls, since they have well known OIDs, we could
859 * have just obtained it from the '((int *)arg1)[0]' parameter, but that would
860 * not demonstrate how to handle multiple sysctls that used OID_AUTO instead
861 * of a well known value with a common handler function. This is desirable,
862 * because we want well known values to "go away" at some future date.
863 *
864 * It should be noted that the value of '((int *)arg1)[1]' is used for many
865 * an integer parameter to the subcommand for many of these sysctls; we'd
866 * rather have used '((int *)arg1)[0]' for that, or even better, an element
867 * in a structure passed in as the the 'newp' argument to sysctlbyname(3),
868 * and then use leaf-node permissions enforcement, but that would have
869 * necessitated modifying user space code to correspond to the interface
870 * change, and we are striving for binary backward compatibility here; even
871 * though these are SPI, and not intended for use by user space applications
872 * which are not themselves system tools or libraries, some applications
873 * have erroneously used them.
874 */
875 SYSCTL_PROC(_kern_proc, KERN_PROC_ALL, all, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
876 0, /* Pointer argument (arg1) */
877 KERN_PROC_ALL, /* Integer argument (arg2) */
878 sysctl_prochandle, /* Handler function */
879 NULL, /* Data is size variant on ILP32/LP64 */
880 "");
881 SYSCTL_PROC(_kern_proc, KERN_PROC_PID, pid, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
882 0, /* Pointer argument (arg1) */
883 KERN_PROC_PID, /* Integer argument (arg2) */
884 sysctl_prochandle, /* Handler function */
885 NULL, /* Data is size variant on ILP32/LP64 */
886 "");
887 SYSCTL_PROC(_kern_proc, KERN_PROC_TTY, tty, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
888 0, /* Pointer argument (arg1) */
889 KERN_PROC_TTY, /* Integer argument (arg2) */
890 sysctl_prochandle, /* Handler function */
891 NULL, /* Data is size variant on ILP32/LP64 */
892 "");
893 SYSCTL_PROC(_kern_proc, KERN_PROC_PGRP, pgrp, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
894 0, /* Pointer argument (arg1) */
895 KERN_PROC_PGRP, /* Integer argument (arg2) */
896 sysctl_prochandle, /* Handler function */
897 NULL, /* Data is size variant on ILP32/LP64 */
898 "");
899 SYSCTL_PROC(_kern_proc, KERN_PROC_UID, uid, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
900 0, /* Pointer argument (arg1) */
901 KERN_PROC_UID, /* Integer argument (arg2) */
902 sysctl_prochandle, /* Handler function */
903 NULL, /* Data is size variant on ILP32/LP64 */
904 "");
905 SYSCTL_PROC(_kern_proc, KERN_PROC_RUID, ruid, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
906 0, /* Pointer argument (arg1) */
907 KERN_PROC_RUID, /* Integer argument (arg2) */
908 sysctl_prochandle, /* Handler function */
909 NULL, /* Data is size variant on ILP32/LP64 */
910 "");
911 SYSCTL_PROC(_kern_proc, KERN_PROC_LCID, lcid, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
912 0, /* Pointer argument (arg1) */
913 KERN_PROC_LCID, /* Integer argument (arg2) */
914 sysctl_prochandle, /* Handler function */
915 NULL, /* Data is size variant on ILP32/LP64 */
916 "");
917
918
919 /*
920 * Fill in non-zero fields of an eproc structure for the specified process.
921 */
922 STATIC void
923 fill_user32_eproc(proc_t p, struct user32_eproc *__restrict ep)
924 {
925 struct tty *tp;
926 struct pgrp *pg;
927 struct session *sessp;
928 kauth_cred_t my_cred;
929
930 pg = proc_pgrp(p);
931 sessp = proc_session(p);
932
933 if (pg != PGRP_NULL) {
934 ep->e_pgid = p->p_pgrpid;
935 ep->e_jobc = pg->pg_jobc;
936 if (sessp != SESSION_NULL && sessp->s_ttyvp)
937 ep->e_flag = EPROC_CTTY;
938 }
939 ep->e_ppid = p->p_ppid;
940 if (p->p_ucred) {
941 my_cred = kauth_cred_proc_ref(p);
942
943 /* A fake historical pcred */
944 ep->e_pcred.p_ruid = kauth_cred_getruid(my_cred);
945 ep->e_pcred.p_svuid = kauth_cred_getsvuid(my_cred);
946 ep->e_pcred.p_rgid = kauth_cred_getrgid(my_cred);
947 ep->e_pcred.p_svgid = kauth_cred_getsvgid(my_cred);
948
949 /* A fake historical *kauth_cred_t */
950 ep->e_ucred.cr_ref = my_cred->cr_ref;
951 ep->e_ucred.cr_uid = kauth_cred_getuid(my_cred);
952 ep->e_ucred.cr_ngroups = posix_cred_get(my_cred)->cr_ngroups;
953 bcopy(posix_cred_get(my_cred)->cr_groups,
954 ep->e_ucred.cr_groups, NGROUPS * sizeof (gid_t));
955
956 kauth_cred_unref(&my_cred);
957 }
958
959 if ((p->p_flag & P_CONTROLT) && (sessp != SESSION_NULL) &&
960 (tp = SESSION_TP(sessp))) {
961 ep->e_tdev = tp->t_dev;
962 ep->e_tpgid = sessp->s_ttypgrpid;
963 } else
964 ep->e_tdev = NODEV;
965
966 if (sessp != SESSION_NULL) {
967 if (SESS_LEADER(p, sessp))
968 ep->e_flag |= EPROC_SLEADER;
969 session_rele(sessp);
970 }
971 if (pg != PGRP_NULL)
972 pg_rele(pg);
973 }
974
975 /*
976 * Fill in non-zero fields of an LP64 eproc structure for the specified process.
977 */
978 STATIC void
979 fill_user64_eproc(proc_t p, struct user64_eproc *__restrict ep)
980 {
981 struct tty *tp;
982 struct pgrp *pg;
983 struct session *sessp;
984 kauth_cred_t my_cred;
985
986 pg = proc_pgrp(p);
987 sessp = proc_session(p);
988
989 if (pg != PGRP_NULL) {
990 ep->e_pgid = p->p_pgrpid;
991 ep->e_jobc = pg->pg_jobc;
992 if (sessp != SESSION_NULL && sessp->s_ttyvp)
993 ep->e_flag = EPROC_CTTY;
994 }
995 ep->e_ppid = p->p_ppid;
996 if (p->p_ucred) {
997 my_cred = kauth_cred_proc_ref(p);
998
999 /* A fake historical pcred */
1000 ep->e_pcred.p_ruid = kauth_cred_getruid(my_cred);
1001 ep->e_pcred.p_svuid = kauth_cred_getsvuid(my_cred);
1002 ep->e_pcred.p_rgid = kauth_cred_getrgid(my_cred);
1003 ep->e_pcred.p_svgid = kauth_cred_getsvgid(my_cred);
1004
1005 /* A fake historical *kauth_cred_t */
1006 ep->e_ucred.cr_ref = my_cred->cr_ref;
1007 ep->e_ucred.cr_uid = kauth_cred_getuid(my_cred);
1008 ep->e_ucred.cr_ngroups = posix_cred_get(my_cred)->cr_ngroups;
1009 bcopy(posix_cred_get(my_cred)->cr_groups,
1010 ep->e_ucred.cr_groups, NGROUPS * sizeof (gid_t));
1011
1012 kauth_cred_unref(&my_cred);
1013 }
1014
1015 if ((p->p_flag & P_CONTROLT) && (sessp != SESSION_NULL) &&
1016 (tp = SESSION_TP(sessp))) {
1017 ep->e_tdev = tp->t_dev;
1018 ep->e_tpgid = sessp->s_ttypgrpid;
1019 } else
1020 ep->e_tdev = NODEV;
1021
1022 if (sessp != SESSION_NULL) {
1023 if (SESS_LEADER(p, sessp))
1024 ep->e_flag |= EPROC_SLEADER;
1025 session_rele(sessp);
1026 }
1027 if (pg != PGRP_NULL)
1028 pg_rele(pg);
1029 }
1030
1031 /*
1032 * Fill in an eproc structure for the specified process.
1033 * bzeroed by our caller, so only set non-zero fields.
1034 */
1035 STATIC void
1036 fill_user32_externproc(proc_t p, struct user32_extern_proc *__restrict exp)
1037 {
1038 exp->p_starttime.tv_sec = p->p_start.tv_sec;
1039 exp->p_starttime.tv_usec = p->p_start.tv_usec;
1040 exp->p_flag = p->p_flag;
1041 if (p->p_lflag & P_LTRACED)
1042 exp->p_flag |= P_TRACED;
1043 if (p->p_lflag & P_LPPWAIT)
1044 exp->p_flag |= P_PPWAIT;
1045 if (p->p_lflag & P_LEXIT)
1046 exp->p_flag |= P_WEXIT;
1047 exp->p_stat = p->p_stat;
1048 exp->p_pid = p->p_pid;
1049 exp->p_oppid = p->p_oppid;
1050 /* Mach related */
1051 exp->user_stack = p->user_stack;
1052 exp->p_debugger = p->p_debugger;
1053 exp->sigwait = p->sigwait;
1054 /* scheduling */
1055 #ifdef _PROC_HAS_SCHEDINFO_
1056 exp->p_estcpu = p->p_estcpu;
1057 exp->p_pctcpu = p->p_pctcpu;
1058 exp->p_slptime = p->p_slptime;
1059 #endif
1060 exp->p_realtimer.it_interval.tv_sec =
1061 (user32_time_t)p->p_realtimer.it_interval.tv_sec;
1062 exp->p_realtimer.it_interval.tv_usec =
1063 (__int32_t)p->p_realtimer.it_interval.tv_usec;
1064
1065 exp->p_realtimer.it_value.tv_sec =
1066 (user32_time_t)p->p_realtimer.it_value.tv_sec;
1067 exp->p_realtimer.it_value.tv_usec =
1068 (__int32_t)p->p_realtimer.it_value.tv_usec;
1069
1070 exp->p_rtime.tv_sec = (user32_time_t)p->p_rtime.tv_sec;
1071 exp->p_rtime.tv_usec = (__int32_t)p->p_rtime.tv_usec;
1072
1073 exp->p_sigignore = p->p_sigignore;
1074 exp->p_sigcatch = p->p_sigcatch;
1075 exp->p_priority = p->p_priority;
1076 exp->p_nice = p->p_nice;
1077 bcopy(&p->p_comm, &exp->p_comm, MAXCOMLEN);
1078 exp->p_xstat = p->p_xstat;
1079 exp->p_acflag = p->p_acflag;
1080 }
1081
1082 /*
1083 * Fill in an LP64 version of extern_proc structure for the specified process.
1084 */
1085 STATIC void
1086 fill_user64_externproc(proc_t p, struct user64_extern_proc *__restrict exp)
1087 {
1088 exp->p_starttime.tv_sec = p->p_start.tv_sec;
1089 exp->p_starttime.tv_usec = p->p_start.tv_usec;
1090 exp->p_flag = p->p_flag;
1091 if (p->p_lflag & P_LTRACED)
1092 exp->p_flag |= P_TRACED;
1093 if (p->p_lflag & P_LPPWAIT)
1094 exp->p_flag |= P_PPWAIT;
1095 if (p->p_lflag & P_LEXIT)
1096 exp->p_flag |= P_WEXIT;
1097 exp->p_stat = p->p_stat;
1098 exp->p_pid = p->p_pid;
1099 exp->p_oppid = p->p_oppid;
1100 /* Mach related */
1101 exp->user_stack = p->user_stack;
1102 exp->p_debugger = p->p_debugger;
1103 exp->sigwait = p->sigwait;
1104 /* scheduling */
1105 #ifdef _PROC_HAS_SCHEDINFO_
1106 exp->p_estcpu = p->p_estcpu;
1107 exp->p_pctcpu = p->p_pctcpu;
1108 exp->p_slptime = p->p_slptime;
1109 #endif
1110 exp->p_realtimer.it_interval.tv_sec = p->p_realtimer.it_interval.tv_sec;
1111 exp->p_realtimer.it_interval.tv_usec = p->p_realtimer.it_interval.tv_usec;
1112
1113 exp->p_realtimer.it_value.tv_sec = p->p_realtimer.it_value.tv_sec;
1114 exp->p_realtimer.it_value.tv_usec = p->p_realtimer.it_value.tv_usec;
1115
1116 exp->p_rtime.tv_sec = p->p_rtime.tv_sec;
1117 exp->p_rtime.tv_usec = p->p_rtime.tv_usec;
1118
1119 exp->p_sigignore = p->p_sigignore;
1120 exp->p_sigcatch = p->p_sigcatch;
1121 exp->p_priority = p->p_priority;
1122 exp->p_nice = p->p_nice;
1123 bcopy(&p->p_comm, &exp->p_comm, MAXCOMLEN);
1124 exp->p_xstat = p->p_xstat;
1125 exp->p_acflag = p->p_acflag;
1126 }
1127
1128 STATIC void
1129 fill_user32_proc(proc_t p, struct user32_kinfo_proc *__restrict kp)
1130 {
1131 /* on a 64 bit kernel, 32 bit users get some truncated information */
1132 fill_user32_externproc(p, &kp->kp_proc);
1133 fill_user32_eproc(p, &kp->kp_eproc);
1134 }
1135
1136 STATIC void
1137 fill_user64_proc(proc_t p, struct user64_kinfo_proc *__restrict kp)
1138 {
1139 fill_user64_externproc(p, &kp->kp_proc);
1140 fill_user64_eproc(p, &kp->kp_eproc);
1141 }
1142
1143 STATIC int
1144 sysctl_kdebug_ops SYSCTL_HANDLER_ARGS
1145 {
1146 __unused int cmd = oidp->oid_arg2; /* subcommand*/
1147 int *name = arg1; /* oid element argument vector */
1148 int namelen = arg2; /* number of oid element arguments */
1149 user_addr_t oldp = req->oldptr; /* user buffer copy out address */
1150 size_t *oldlenp = &req->oldlen; /* user buffer copy out size */
1151 // user_addr_t newp = req->newptr; /* user buffer copy in address */
1152 // size_t newlen = req->newlen; /* user buffer copy in size */
1153
1154 int ret=0;
1155
1156 if (namelen == 0)
1157 return(ENOTSUP);
1158
1159 switch(name[0]) {
1160 case KERN_KDEFLAGS:
1161 case KERN_KDDFLAGS:
1162 case KERN_KDENABLE:
1163 case KERN_KDGETBUF:
1164 case KERN_KDSETUP:
1165 case KERN_KDREMOVE:
1166 case KERN_KDSETREG:
1167 case KERN_KDGETREG:
1168 case KERN_KDREADTR:
1169 case KERN_KDWRITETR:
1170 case KERN_KDWRITEMAP:
1171 case KERN_KDTEST:
1172 case KERN_KDPIDTR:
1173 case KERN_KDTHRMAP:
1174 case KERN_KDPIDEX:
1175 case KERN_KDSETBUF:
1176 case KERN_KDREADCURTHRMAP:
1177 case KERN_KDSET_TYPEFILTER:
1178 case KERN_KDBUFWAIT:
1179 case KERN_KDCPUMAP:
1180 case KERN_KDWRITEMAP_V3:
1181 case KERN_KDWRITETR_V3:
1182 ret = kdbg_control(name, namelen, oldp, oldlenp);
1183 break;
1184 default:
1185 ret= ENOTSUP;
1186 break;
1187 }
1188
1189 /* adjust index so we return the right required/consumed amount */
1190 if (!ret)
1191 req->oldidx += req->oldlen;
1192
1193 return (ret);
1194 }
1195 SYSCTL_PROC(_kern, KERN_KDEBUG, kdebug, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
1196 0, /* Pointer argument (arg1) */
1197 0, /* Integer argument (arg2) */
1198 sysctl_kdebug_ops, /* Handler function */
1199 NULL, /* Data pointer */
1200 "");
1201
1202
1203 #if !CONFIG_EMBEDDED
1204 /*
1205 * Return the top *sizep bytes of the user stack, or the entire area of the
1206 * user stack down through the saved exec_path, whichever is smaller.
1207 */
1208 STATIC int
1209 sysctl_doprocargs SYSCTL_HANDLER_ARGS
1210 {
1211 __unused int cmd = oidp->oid_arg2; /* subcommand*/
1212 int *name = arg1; /* oid element argument vector */
1213 int namelen = arg2; /* number of oid element arguments */
1214 user_addr_t oldp = req->oldptr; /* user buffer copy out address */
1215 size_t *oldlenp = &req->oldlen; /* user buffer copy out size */
1216 // user_addr_t newp = req->newptr; /* user buffer copy in address */
1217 // size_t newlen = req->newlen; /* user buffer copy in size */
1218 int error;
1219
1220 error = sysctl_procargsx( name, namelen, oldp, oldlenp, current_proc(), 0);
1221
1222 /* adjust index so we return the right required/consumed amount */
1223 if (!error)
1224 req->oldidx += req->oldlen;
1225
1226 return (error);
1227 }
1228 SYSCTL_PROC(_kern, KERN_PROCARGS, procargs, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
1229 0, /* Pointer argument (arg1) */
1230 0, /* Integer argument (arg2) */
1231 sysctl_doprocargs, /* Handler function */
1232 NULL, /* Data pointer */
1233 "");
1234 #endif /* !CONFIG_EMBEDDED */
1235
1236 STATIC int
1237 sysctl_doprocargs2 SYSCTL_HANDLER_ARGS
1238 {
1239 __unused int cmd = oidp->oid_arg2; /* subcommand*/
1240 int *name = arg1; /* oid element argument vector */
1241 int namelen = arg2; /* number of oid element arguments */
1242 user_addr_t oldp = req->oldptr; /* user buffer copy out address */
1243 size_t *oldlenp = &req->oldlen; /* user buffer copy out size */
1244 // user_addr_t newp = req->newptr; /* user buffer copy in address */
1245 // size_t newlen = req->newlen; /* user buffer copy in size */
1246 int error;
1247
1248 error = sysctl_procargsx( name, namelen, oldp, oldlenp, current_proc(), 1);
1249
1250 /* adjust index so we return the right required/consumed amount */
1251 if (!error)
1252 req->oldidx += req->oldlen;
1253
1254 return (error);
1255 }
1256 SYSCTL_PROC(_kern, KERN_PROCARGS2, procargs2, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
1257 0, /* Pointer argument (arg1) */
1258 0, /* Integer argument (arg2) */
1259 sysctl_doprocargs2, /* Handler function */
1260 NULL, /* Data pointer */
1261 "");
1262
1263 STATIC int
1264 sysctl_procargsx(int *name, u_int namelen, user_addr_t where,
1265 size_t *sizep, proc_t cur_proc, int argc_yes)
1266 {
1267 proc_t p;
1268 int buflen = where != USER_ADDR_NULL ? *sizep : 0;
1269 int error = 0;
1270 struct _vm_map *proc_map;
1271 struct task * task;
1272 vm_map_copy_t tmp;
1273 user_addr_t arg_addr;
1274 size_t arg_size;
1275 caddr_t data;
1276 size_t argslen=0;
1277 int size;
1278 vm_size_t alloc_size = 0;
1279 vm_offset_t copy_start, copy_end;
1280 kern_return_t ret;
1281 int pid;
1282 kauth_cred_t my_cred;
1283 uid_t uid;
1284 int argc = -1;
1285
1286 if ( namelen < 1 )
1287 return(EINVAL);
1288
1289 if (argc_yes)
1290 buflen -= sizeof(int); /* reserve first word to return argc */
1291
1292 /* we only care about buflen when where (oldp from sysctl) is not NULL. */
1293 /* when where (oldp from sysctl) is NULL and sizep (oldlenp from sysctl */
1294 /* is not NULL then the caller wants us to return the length needed to */
1295 /* hold the data we would return */
1296 if (where != USER_ADDR_NULL && (buflen <= 0 || buflen > ARG_MAX)) {
1297 return(EINVAL);
1298 }
1299 arg_size = buflen;
1300
1301 /*
1302 * Lookup process by pid
1303 */
1304 pid = name[0];
1305 p = proc_find(pid);
1306 if (p == NULL) {
1307 return(EINVAL);
1308 }
1309
1310 /*
1311 * Copy the top N bytes of the stack.
1312 * On all machines we have so far, the stack grows
1313 * downwards.
1314 *
1315 * If the user expects no more than N bytes of
1316 * argument list, use that as a guess for the
1317 * size.
1318 */
1319
1320 if (!p->user_stack) {
1321 proc_rele(p);
1322 return(EINVAL);
1323 }
1324
1325 if (where == USER_ADDR_NULL) {
1326 /* caller only wants to know length of proc args data */
1327 if (sizep == NULL) {
1328 proc_rele(p);
1329 return(EFAULT);
1330 }
1331
1332 size = p->p_argslen;
1333 proc_rele(p);
1334 if (argc_yes) {
1335 size += sizeof(int);
1336 } else {
1337 /*
1338 * old PROCARGS will return the executable's path and plus some
1339 * extra space for work alignment and data tags
1340 */
1341 size += PATH_MAX + (6 * sizeof(int));
1342 }
1343 size += (size & (sizeof(int) - 1)) ? (sizeof(int) - (size & (sizeof(int) - 1))) : 0;
1344 *sizep = size;
1345 return (0);
1346 }
1347
1348 my_cred = kauth_cred_proc_ref(p);
1349 uid = kauth_cred_getuid(my_cred);
1350 kauth_cred_unref(&my_cred);
1351
1352 if ((uid != kauth_cred_getuid(kauth_cred_get()))
1353 && suser(kauth_cred_get(), &cur_proc->p_acflag)) {
1354 proc_rele(p);
1355 return (EINVAL);
1356 }
1357
1358 if ((u_int)arg_size > p->p_argslen)
1359 arg_size = round_page(p->p_argslen);
1360
1361 arg_addr = p->user_stack - arg_size;
1362
1363 /*
1364 * Before we can block (any VM code), make another
1365 * reference to the map to keep it alive. We do
1366 * that by getting a reference on the task itself.
1367 */
1368 task = p->task;
1369 if (task == NULL) {
1370 proc_rele(p);
1371 return(EINVAL);
1372 }
1373
1374 /* save off argc before releasing the proc */
1375 argc = p->p_argc;
1376
1377 argslen = p->p_argslen;
1378 /*
1379 * Once we have a task reference we can convert that into a
1380 * map reference, which we will use in the calls below. The
1381 * task/process may change its map after we take this reference
1382 * (see execve), but the worst that will happen then is a return
1383 * of stale info (which is always a possibility).
1384 */
1385 task_reference(task);
1386 proc_rele(p);
1387 proc_map = get_task_map_reference(task);
1388 task_deallocate(task);
1389
1390 if (proc_map == NULL)
1391 return(EINVAL);
1392
1393 alloc_size = round_page(arg_size);
1394 ret = kmem_alloc(kernel_map, &copy_start, alloc_size, VM_KERN_MEMORY_BSD);
1395 if (ret != KERN_SUCCESS) {
1396 vm_map_deallocate(proc_map);
1397 return(ENOMEM);
1398 }
1399 bzero((void *)copy_start, alloc_size);
1400
1401 copy_end = round_page(copy_start + arg_size);
1402
1403 if( vm_map_copyin(proc_map, (vm_map_address_t)arg_addr,
1404 (vm_map_size_t)arg_size, FALSE, &tmp) != KERN_SUCCESS) {
1405 vm_map_deallocate(proc_map);
1406 kmem_free(kernel_map, copy_start,
1407 round_page(arg_size));
1408 return (EIO);
1409 }
1410
1411 /*
1412 * Now that we've done the copyin from the process'
1413 * map, we can release the reference to it.
1414 */
1415 vm_map_deallocate(proc_map);
1416
1417 if( vm_map_copy_overwrite(kernel_map,
1418 (vm_map_address_t)copy_start,
1419 tmp, FALSE) != KERN_SUCCESS) {
1420 kmem_free(kernel_map, copy_start,
1421 round_page(arg_size));
1422 vm_map_copy_discard(tmp);
1423 return (EIO);
1424 }
1425
1426 if (arg_size > argslen) {
1427 data = (caddr_t) (copy_end - argslen);
1428 size = argslen;
1429 } else {
1430 data = (caddr_t) (copy_end - arg_size);
1431 size = arg_size;
1432 }
1433
1434 /*
1435 * When these sysctls were introduced, the first string in the strings
1436 * section was just the bare path of the executable. However, for security
1437 * reasons we now prefix this string with executable_path= so it can be
1438 * parsed getenv style. To avoid binary compatability issues with exising
1439 * callers of this sysctl, we strip it off here if present.
1440 * (rdar://problem/13746466)
1441 */
1442 #define EXECUTABLE_KEY "executable_path="
1443 if (strncmp(EXECUTABLE_KEY, data, strlen(EXECUTABLE_KEY)) == 0){
1444 data += strlen(EXECUTABLE_KEY);
1445 size -= strlen(EXECUTABLE_KEY);
1446 }
1447
1448 if (argc_yes) {
1449 /* Put processes argc as the first word in the copyout buffer */
1450 suword(where, argc);
1451 error = copyout(data, (where + sizeof(int)), size);
1452 size += sizeof(int);
1453 } else {
1454 error = copyout(data, where, size);
1455
1456 /*
1457 * Make the old PROCARGS work to return the executable's path
1458 * But, only if there is enough space in the provided buffer
1459 *
1460 * on entry: data [possibily] points to the beginning of the path
1461 *
1462 * Note: we keep all pointers&sizes aligned to word boundries
1463 */
1464 if ( (! error) && (buflen > 0 && (u_int)buflen > argslen) )
1465 {
1466 int binPath_sz, alignedBinPath_sz = 0;
1467 int extraSpaceNeeded, addThis;
1468 user_addr_t placeHere;
1469 char * str = (char *) data;
1470 int max_len = size;
1471
1472 /* Some apps are really bad about messing up their stacks
1473 So, we have to be extra careful about getting the length
1474 of the executing binary. If we encounter an error, we bail.
1475 */
1476
1477 /* Limit ourselves to PATH_MAX paths */
1478 if ( max_len > PATH_MAX ) max_len = PATH_MAX;
1479
1480 binPath_sz = 0;
1481
1482 while ( (binPath_sz < max_len-1) && (*str++ != 0) )
1483 binPath_sz++;
1484
1485 /* If we have a NUL terminator, copy it, too */
1486 if (binPath_sz < max_len-1) binPath_sz += 1;
1487
1488 /* Pre-Flight the space requiremnts */
1489
1490 /* Account for the padding that fills out binPath to the next word */
1491 alignedBinPath_sz += (binPath_sz & (sizeof(int)-1)) ? (sizeof(int)-(binPath_sz & (sizeof(int)-1))) : 0;
1492
1493 placeHere = where + size;
1494
1495 /* Account for the bytes needed to keep placeHere word aligned */
1496 addThis = (placeHere & (sizeof(int)-1)) ? (sizeof(int)-(placeHere & (sizeof(int)-1))) : 0;
1497
1498 /* Add up all the space that is needed */
1499 extraSpaceNeeded = alignedBinPath_sz + addThis + binPath_sz + (4 * sizeof(int));
1500
1501 /* is there is room to tack on argv[0]? */
1502 if ( (buflen & ~(sizeof(int)-1)) >= ( argslen + extraSpaceNeeded ))
1503 {
1504 placeHere += addThis;
1505 suword(placeHere, 0);
1506 placeHere += sizeof(int);
1507 suword(placeHere, 0xBFFF0000);
1508 placeHere += sizeof(int);
1509 suword(placeHere, 0);
1510 placeHere += sizeof(int);
1511 error = copyout(data, placeHere, binPath_sz);
1512 if ( ! error )
1513 {
1514 placeHere += binPath_sz;
1515 suword(placeHere, 0);
1516 size += extraSpaceNeeded;
1517 }
1518 }
1519 }
1520 }
1521
1522 if (copy_start != (vm_offset_t) 0) {
1523 kmem_free(kernel_map, copy_start, copy_end - copy_start);
1524 }
1525 if (error) {
1526 return(error);
1527 }
1528
1529 if (where != USER_ADDR_NULL)
1530 *sizep = size;
1531 return (0);
1532 }
1533
1534
1535 /*
1536 * Max number of concurrent aio requests
1537 */
1538 STATIC int
1539 sysctl_aiomax
1540 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
1541 {
1542 int new_value, changed;
1543 int error = sysctl_io_number(req, aio_max_requests, sizeof(int), &new_value, &changed);
1544 if (changed) {
1545 /* make sure the system-wide limit is greater than the per process limit */
1546 if (new_value >= aio_max_requests_per_process && new_value <= AIO_MAX_REQUESTS)
1547 aio_max_requests = new_value;
1548 else
1549 error = EINVAL;
1550 }
1551 return(error);
1552 }
1553
1554
1555 /*
1556 * Max number of concurrent aio requests per process
1557 */
1558 STATIC int
1559 sysctl_aioprocmax
1560 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
1561 {
1562 int new_value, changed;
1563 int error = sysctl_io_number(req, aio_max_requests_per_process, sizeof(int), &new_value, &changed);
1564 if (changed) {
1565 /* make sure per process limit is less than the system-wide limit */
1566 if (new_value <= aio_max_requests && new_value >= AIO_LISTIO_MAX)
1567 aio_max_requests_per_process = new_value;
1568 else
1569 error = EINVAL;
1570 }
1571 return(error);
1572 }
1573
1574
1575 /*
1576 * Max number of async IO worker threads
1577 */
1578 STATIC int
1579 sysctl_aiothreads
1580 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
1581 {
1582 int new_value, changed;
1583 int error = sysctl_io_number(req, aio_worker_threads, sizeof(int), &new_value, &changed);
1584 if (changed) {
1585 /* we only allow an increase in the number of worker threads */
1586 if (new_value > aio_worker_threads ) {
1587 _aio_create_worker_threads((new_value - aio_worker_threads));
1588 aio_worker_threads = new_value;
1589 }
1590 else
1591 error = EINVAL;
1592 }
1593 return(error);
1594 }
1595
1596
1597 /*
1598 * System-wide limit on the max number of processes
1599 */
1600 STATIC int
1601 sysctl_maxproc
1602 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
1603 {
1604 int new_value, changed;
1605 int error = sysctl_io_number(req, maxproc, sizeof(int), &new_value, &changed);
1606 if (changed) {
1607 AUDIT_ARG(value32, new_value);
1608 /* make sure the system-wide limit is less than the configured hard
1609 limit set at kernel compilation */
1610 if (new_value <= hard_maxproc && new_value > 0)
1611 maxproc = new_value;
1612 else
1613 error = EINVAL;
1614 }
1615 return(error);
1616 }
1617
1618 SYSCTL_STRING(_kern, KERN_OSTYPE, ostype,
1619 CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
1620 ostype, 0, "");
1621 SYSCTL_STRING(_kern, KERN_OSRELEASE, osrelease,
1622 CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
1623 osrelease, 0, "");
1624 SYSCTL_INT(_kern, KERN_OSREV, osrevision,
1625 CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
1626 (int *)NULL, BSD, "");
1627 SYSCTL_STRING(_kern, KERN_VERSION, version,
1628 CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
1629 version, 0, "");
1630 SYSCTL_STRING(_kern, OID_AUTO, uuid,
1631 CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
1632 &kernel_uuid_string[0], 0, "");
1633
1634 SYSCTL_STRING(_kern, OID_AUTO, osbuildconfig,
1635 CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED | CTLFLAG_MASKED,
1636 &osbuild_config[0], 0, "");
1637
1638 #if DEBUG
1639 #ifndef DKPR
1640 #define DKPR 1
1641 #endif
1642 #endif
1643
1644 #if DKPR
1645 int debug_kprint_syscall = 0;
1646 char debug_kprint_syscall_process[MAXCOMLEN+1];
1647
1648 /* Thread safe: bits and string value are not used to reclaim state */
1649 SYSCTL_INT (_debug, OID_AUTO, kprint_syscall,
1650 CTLFLAG_RW | CTLFLAG_LOCKED, &debug_kprint_syscall, 0, "kprintf syscall tracing");
1651 SYSCTL_STRING(_debug, OID_AUTO, kprint_syscall_process,
1652 CTLFLAG_RW | CTLFLAG_LOCKED, debug_kprint_syscall_process, sizeof(debug_kprint_syscall_process),
1653 "name of process for kprintf syscall tracing");
1654
1655 int debug_kprint_current_process(const char **namep)
1656 {
1657 struct proc *p = current_proc();
1658
1659 if (p == NULL) {
1660 return 0;
1661 }
1662
1663 if (debug_kprint_syscall_process[0]) {
1664 /* user asked to scope tracing to a particular process name */
1665 if(0 == strncmp(debug_kprint_syscall_process,
1666 p->p_comm, sizeof(debug_kprint_syscall_process))) {
1667 /* no value in telling the user that we traced what they asked */
1668 if(namep) *namep = NULL;
1669
1670 return 1;
1671 } else {
1672 return 0;
1673 }
1674 }
1675
1676 /* trace all processes. Tell user what we traced */
1677 if (namep) {
1678 *namep = p->p_comm;
1679 }
1680
1681 return 1;
1682 }
1683 #endif
1684
1685 /* PR-5293665: need to use a callback function for kern.osversion to set
1686 * osversion in IORegistry */
1687
1688 STATIC int
1689 sysctl_osversion(__unused struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req)
1690 {
1691 int rval = 0;
1692
1693 rval = sysctl_handle_string(oidp, arg1, arg2, req);
1694
1695 if (req->newptr) {
1696 IORegistrySetOSBuildVersion((char *)arg1);
1697 }
1698
1699 return rval;
1700 }
1701
1702 SYSCTL_PROC(_kern, KERN_OSVERSION, osversion,
1703 CTLFLAG_RW | CTLFLAG_KERN | CTLTYPE_STRING | CTLFLAG_LOCKED,
1704 osversion, 256 /* OSVERSIZE*/,
1705 sysctl_osversion, "A", "");
1706
1707 static uint64_t osproductversion_string[48];
1708
1709 STATIC int
1710 sysctl_osproductversion(__unused struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req)
1711 {
1712 if (req->newptr != 0) {
1713 /*
1714 * Can only ever be set by launchd, and only once at boot.
1715 */
1716 if (req->p->p_pid != 1 || osproductversion_string[0] != '\0') {
1717 return EPERM;
1718 }
1719 }
1720
1721 return sysctl_handle_string(oidp, arg1, arg2, req);
1722 }
1723
1724 SYSCTL_PROC(_kern, OID_AUTO, osproductversion,
1725 CTLFLAG_RW | CTLFLAG_KERN | CTLTYPE_STRING | CTLFLAG_LOCKED,
1726 osproductversion_string, sizeof(osproductversion_string),
1727 sysctl_osproductversion, "A", "The ProductVersion from SystemVersion.plist");
1728
1729 static uint64_t osvariant_status = 0;
1730
1731 STATIC int
1732 sysctl_osvariant_status(__unused struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req)
1733 {
1734 if (req->newptr != 0) {
1735 /*
1736 * Can only ever be set by launchd, and only once at boot.
1737 */
1738 if (req->p->p_pid != 1 || osvariant_status != 0) {
1739 return EPERM;
1740 }
1741 }
1742
1743 return sysctl_handle_quad(oidp, arg1, arg2, req);
1744 }
1745
1746 SYSCTL_PROC(_kern, OID_AUTO, osvariant_status,
1747 CTLFLAG_RW | CTLTYPE_QUAD | CTLFLAG_LOCKED | CTLFLAG_MASKED,
1748 &osvariant_status, sizeof(osvariant_status),
1749 sysctl_osvariant_status, "Q", "Opaque flags used to cache OS variant information");
1750
1751 STATIC int
1752 sysctl_sysctl_bootargs
1753 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
1754 {
1755 int error;
1756 /* BOOT_LINE_LENGTH */
1757 #if CONFIG_EMBEDDED
1758 size_t boot_args_len = 256;
1759 #else
1760 size_t boot_args_len = 1024;
1761 #endif
1762 char buf[boot_args_len];
1763
1764 strlcpy(buf, PE_boot_args(), boot_args_len);
1765 error = sysctl_io_string(req, buf, boot_args_len, 0, NULL);
1766 return(error);
1767 }
1768
1769 SYSCTL_PROC(_kern, OID_AUTO, bootargs,
1770 CTLFLAG_LOCKED | CTLFLAG_RD | CTLFLAG_KERN | CTLTYPE_STRING,
1771 NULL, 0,
1772 sysctl_sysctl_bootargs, "A", "bootargs");
1773
1774 STATIC int
1775 sysctl_kernelcacheuuid(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req)
1776 {
1777 int rval = ENOENT;
1778 if (kernelcache_uuid_valid) {
1779 rval = sysctl_handle_string(oidp, arg1, arg2, req);
1780 }
1781 return rval;
1782 }
1783
1784 SYSCTL_PROC(_kern, OID_AUTO, kernelcacheuuid,
1785 CTLFLAG_RD | CTLFLAG_KERN | CTLTYPE_STRING | CTLFLAG_LOCKED,
1786 kernelcache_uuid_string, sizeof(kernelcache_uuid_string),
1787 sysctl_kernelcacheuuid, "A", "");
1788
1789 SYSCTL_INT(_kern, KERN_MAXFILES, maxfiles,
1790 CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
1791 &maxfiles, 0, "");
1792 SYSCTL_INT(_kern, KERN_ARGMAX, argmax,
1793 CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
1794 (int *)NULL, ARG_MAX, "");
1795 SYSCTL_INT(_kern, KERN_POSIX1, posix1version,
1796 CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
1797 (int *)NULL, _POSIX_VERSION, "");
1798 SYSCTL_INT(_kern, KERN_NGROUPS, ngroups,
1799 CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
1800 (int *)NULL, NGROUPS_MAX, "");
1801 SYSCTL_INT(_kern, KERN_JOB_CONTROL, job_control,
1802 CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
1803 (int *)NULL, 1, "");
1804 #if 1 /* _POSIX_SAVED_IDS from <unistd.h> */
1805 SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids,
1806 CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
1807 (int *)NULL, 1, "");
1808 #else
1809 SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids,
1810 CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
1811 NULL, 0, "");
1812 #endif
1813 SYSCTL_INT(_kern, OID_AUTO, num_files,
1814 CTLFLAG_RD | CTLFLAG_LOCKED,
1815 &nfiles, 0, "");
1816 SYSCTL_COMPAT_INT(_kern, OID_AUTO, num_vnodes,
1817 CTLFLAG_RD | CTLFLAG_LOCKED,
1818 &numvnodes, 0, "");
1819 SYSCTL_INT(_kern, OID_AUTO, num_tasks,
1820 CTLFLAG_RD | CTLFLAG_LOCKED,
1821 &task_max, 0, "");
1822 SYSCTL_INT(_kern, OID_AUTO, num_threads,
1823 CTLFLAG_RD | CTLFLAG_LOCKED,
1824 &thread_max, 0, "");
1825 SYSCTL_INT(_kern, OID_AUTO, num_taskthreads,
1826 CTLFLAG_RD | CTLFLAG_LOCKED,
1827 &task_threadmax, 0, "");
1828
1829 STATIC int
1830 sysctl_maxvnodes (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
1831 {
1832 int oldval = desiredvnodes;
1833 int error = sysctl_io_number(req, desiredvnodes, sizeof(int), &desiredvnodes, NULL);
1834
1835 if (oldval != desiredvnodes) {
1836 resize_namecache(desiredvnodes);
1837 }
1838
1839 return(error);
1840 }
1841
1842 SYSCTL_INT(_kern, OID_AUTO, namecache_disabled,
1843 CTLFLAG_RW | CTLFLAG_LOCKED,
1844 &nc_disabled, 0, "");
1845
1846 SYSCTL_PROC(_kern, KERN_MAXVNODES, maxvnodes,
1847 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
1848 0, 0, sysctl_maxvnodes, "I", "");
1849
1850 SYSCTL_PROC(_kern, KERN_MAXPROC, maxproc,
1851 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
1852 0, 0, sysctl_maxproc, "I", "");
1853
1854 SYSCTL_PROC(_kern, KERN_AIOMAX, aiomax,
1855 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
1856 0, 0, sysctl_aiomax, "I", "");
1857
1858 SYSCTL_PROC(_kern, KERN_AIOPROCMAX, aioprocmax,
1859 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
1860 0, 0, sysctl_aioprocmax, "I", "");
1861
1862 SYSCTL_PROC(_kern, KERN_AIOTHREADS, aiothreads,
1863 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
1864 0, 0, sysctl_aiothreads, "I", "");
1865
1866 #if (DEVELOPMENT || DEBUG)
1867 extern int sched_smt_balance;
1868 SYSCTL_INT(_kern, OID_AUTO, sched_smt_balance,
1869 CTLFLAG_KERN| CTLFLAG_RW| CTLFLAG_LOCKED,
1870 &sched_smt_balance, 0, "");
1871 extern int sched_allow_rt_smt;
1872 SYSCTL_INT(_kern, OID_AUTO, sched_allow_rt_smt,
1873 CTLFLAG_KERN| CTLFLAG_RW| CTLFLAG_LOCKED,
1874 &sched_allow_rt_smt, 0, "");
1875 #if __arm__ || __arm64__
1876 extern uint32_t perfcontrol_requested_recommended_cores;
1877 SYSCTL_UINT(_kern, OID_AUTO, sched_recommended_cores,
1878 CTLFLAG_KERN | CTLFLAG_RD | CTLFLAG_LOCKED,
1879 &perfcontrol_requested_recommended_cores, 0, "");
1880
1881 /* Scheduler perfcontrol callouts sysctls */
1882 SYSCTL_DECL(_kern_perfcontrol_callout);
1883 SYSCTL_NODE(_kern, OID_AUTO, perfcontrol_callout, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
1884 "scheduler perfcontrol callouts");
1885
1886 extern int perfcontrol_callout_stats_enabled;
1887 SYSCTL_INT(_kern_perfcontrol_callout, OID_AUTO, stats_enabled,
1888 CTLFLAG_KERN| CTLFLAG_RW| CTLFLAG_LOCKED,
1889 &perfcontrol_callout_stats_enabled, 0, "");
1890
1891 extern uint64_t perfcontrol_callout_stat_avg(perfcontrol_callout_type_t type,
1892 perfcontrol_callout_stat_t stat);
1893
1894 /* On-Core Callout */
1895 STATIC int
1896 sysctl_perfcontrol_callout_stat
1897 (__unused struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req)
1898 {
1899 perfcontrol_callout_stat_t stat = (perfcontrol_callout_stat_t)arg1;
1900 perfcontrol_callout_type_t type = (perfcontrol_callout_type_t)arg2;
1901 return sysctl_io_number(req, (int)perfcontrol_callout_stat_avg(type, stat),
1902 sizeof(int), NULL, NULL);
1903 }
1904
1905 SYSCTL_PROC(_kern_perfcontrol_callout, OID_AUTO, oncore_instr,
1906 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
1907 (void *)PERFCONTROL_STAT_INSTRS, PERFCONTROL_CALLOUT_ON_CORE,
1908 sysctl_perfcontrol_callout_stat, "I", "");
1909 SYSCTL_PROC(_kern_perfcontrol_callout, OID_AUTO, oncore_cycles,
1910 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
1911 (void *)PERFCONTROL_STAT_CYCLES, PERFCONTROL_CALLOUT_ON_CORE,
1912 sysctl_perfcontrol_callout_stat, "I", "");
1913 SYSCTL_PROC(_kern_perfcontrol_callout, OID_AUTO, offcore_instr,
1914 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
1915 (void *)PERFCONTROL_STAT_INSTRS, PERFCONTROL_CALLOUT_OFF_CORE,
1916 sysctl_perfcontrol_callout_stat, "I", "");
1917 SYSCTL_PROC(_kern_perfcontrol_callout, OID_AUTO, offcore_cycles,
1918 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
1919 (void *)PERFCONTROL_STAT_CYCLES, PERFCONTROL_CALLOUT_OFF_CORE,
1920 sysctl_perfcontrol_callout_stat, "I", "");
1921 SYSCTL_PROC(_kern_perfcontrol_callout, OID_AUTO, context_instr,
1922 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
1923 (void *)PERFCONTROL_STAT_INSTRS, PERFCONTROL_CALLOUT_CONTEXT,
1924 sysctl_perfcontrol_callout_stat, "I", "");
1925 SYSCTL_PROC(_kern_perfcontrol_callout, OID_AUTO, context_cycles,
1926 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
1927 (void *)PERFCONTROL_STAT_CYCLES, PERFCONTROL_CALLOUT_CONTEXT,
1928 sysctl_perfcontrol_callout_stat, "I", "");
1929 SYSCTL_PROC(_kern_perfcontrol_callout, OID_AUTO, update_instr,
1930 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
1931 (void *)PERFCONTROL_STAT_INSTRS, PERFCONTROL_CALLOUT_STATE_UPDATE,
1932 sysctl_perfcontrol_callout_stat, "I", "");
1933 SYSCTL_PROC(_kern_perfcontrol_callout, OID_AUTO, update_cycles,
1934 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
1935 (void *)PERFCONTROL_STAT_CYCLES, PERFCONTROL_CALLOUT_STATE_UPDATE,
1936 sysctl_perfcontrol_callout_stat, "I", "");
1937
1938 #endif /* __arm__ || __arm64__ */
1939 #endif /* (DEVELOPMENT || DEBUG) */
1940
1941 STATIC int
1942 sysctl_securelvl
1943 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
1944 {
1945 int new_value, changed;
1946 int error = sysctl_io_number(req, securelevel, sizeof(int), &new_value, &changed);
1947 if (changed) {
1948 if (!(new_value < securelevel && req->p->p_pid != 1)) {
1949 proc_list_lock();
1950 securelevel = new_value;
1951 proc_list_unlock();
1952 } else {
1953 error = EPERM;
1954 }
1955 }
1956 return(error);
1957 }
1958
1959 SYSCTL_PROC(_kern, KERN_SECURELVL, securelevel,
1960 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
1961 0, 0, sysctl_securelvl, "I", "");
1962
1963
1964 STATIC int
1965 sysctl_domainname
1966 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
1967 {
1968 int error, changed;
1969 error = sysctl_io_string(req, domainname, sizeof(domainname), 0, &changed);
1970 if (changed) {
1971 domainnamelen = strlen(domainname);
1972 }
1973 return(error);
1974 }
1975
1976 SYSCTL_PROC(_kern, KERN_DOMAINNAME, nisdomainname,
1977 CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_LOCKED,
1978 0, 0, sysctl_domainname, "A", "");
1979
1980 SYSCTL_COMPAT_INT(_kern, KERN_HOSTID, hostid,
1981 CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
1982 &hostid, 0, "");
1983
1984 STATIC int
1985 sysctl_hostname
1986 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
1987 {
1988 int error, changed;
1989 error = sysctl_io_string(req, hostname, sizeof(hostname), 1, &changed);
1990 if (changed) {
1991 hostnamelen = req->newlen;
1992 }
1993 return(error);
1994 }
1995
1996
1997 SYSCTL_PROC(_kern, KERN_HOSTNAME, hostname,
1998 CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_LOCKED,
1999 0, 0, sysctl_hostname, "A", "");
2000
2001 STATIC int
2002 sysctl_procname
2003 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2004 {
2005 /* Original code allowed writing, I'm copying this, although this all makes
2006 no sense to me. Besides, this sysctl is never used. */
2007 return sysctl_io_string(req, &req->p->p_name[0], (2*MAXCOMLEN+1), 1, NULL);
2008 }
2009
2010 SYSCTL_PROC(_kern, KERN_PROCNAME, procname,
2011 CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_LOCKED,
2012 0, 0, sysctl_procname, "A", "");
2013
2014 SYSCTL_INT(_kern, KERN_SPECULATIVE_READS, speculative_reads_disabled,
2015 CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
2016 &speculative_reads_disabled, 0, "");
2017
2018 SYSCTL_UINT(_kern, OID_AUTO, preheat_max_bytes,
2019 CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
2020 &preheat_max_bytes, 0, "");
2021
2022 SYSCTL_UINT(_kern, OID_AUTO, preheat_min_bytes,
2023 CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
2024 &preheat_min_bytes, 0, "");
2025
2026 SYSCTL_UINT(_kern, OID_AUTO, speculative_prefetch_max,
2027 CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
2028 &speculative_prefetch_max, 0, "");
2029
2030 SYSCTL_UINT(_kern, OID_AUTO, speculative_prefetch_max_iosize,
2031 CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
2032 &speculative_prefetch_max_iosize, 0, "");
2033
2034 SYSCTL_UINT(_kern, OID_AUTO, vm_page_free_target,
2035 CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
2036 &vm_page_free_target, 0, "");
2037
2038 SYSCTL_UINT(_kern, OID_AUTO, vm_page_free_min,
2039 CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
2040 &vm_page_free_min, 0, "");
2041
2042 SYSCTL_UINT(_kern, OID_AUTO, vm_page_free_reserved,
2043 CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
2044 &vm_page_free_reserved, 0, "");
2045
2046 SYSCTL_UINT(_kern, OID_AUTO, vm_page_speculative_percentage,
2047 CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
2048 &vm_pageout_state.vm_page_speculative_percentage, 0, "");
2049
2050 SYSCTL_UINT(_kern, OID_AUTO, vm_page_speculative_q_age_ms,
2051 CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
2052 &vm_pageout_state.vm_page_speculative_q_age_ms, 0, "");
2053
2054 SYSCTL_UINT(_kern, OID_AUTO, vm_max_delayed_work_limit,
2055 CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
2056 &vm_max_delayed_work_limit, 0, "");
2057
2058 SYSCTL_UINT(_kern, OID_AUTO, vm_max_batch,
2059 CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
2060 &vm_max_batch, 0, "");
2061
2062 SYSCTL_STRING(_kern, OID_AUTO, bootsessionuuid,
2063 CTLFLAG_RD | CTLFLAG_LOCKED,
2064 &bootsessionuuid_string, sizeof(bootsessionuuid_string) , "");
2065
2066 STATIC int
2067 sysctl_boottime
2068 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2069 {
2070 struct timeval tv;
2071 boottime_timeval(&tv);
2072 struct proc *p = req->p;
2073
2074 if (proc_is64bit(p)) {
2075 struct user64_timeval t = {};
2076 t.tv_sec = tv.tv_sec;
2077 t.tv_usec = tv.tv_usec;
2078 return sysctl_io_opaque(req, &t, sizeof(t), NULL);
2079 } else {
2080 struct user32_timeval t = {};
2081 t.tv_sec = tv.tv_sec;
2082 t.tv_usec = tv.tv_usec;
2083 return sysctl_io_opaque(req, &t, sizeof(t), NULL);
2084 }
2085 }
2086
2087 SYSCTL_PROC(_kern, KERN_BOOTTIME, boottime,
2088 CTLTYPE_STRUCT | CTLFLAG_KERN | CTLFLAG_RD | CTLFLAG_LOCKED,
2089 0, 0, sysctl_boottime, "S,timeval", "");
2090
2091 STATIC int
2092 sysctl_symfile
2093 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2094 {
2095 char *str;
2096 int error = get_kernel_symfile(req->p, &str);
2097 if (error)
2098 return (error);
2099 return sysctl_io_string(req, str, 0, 0, NULL);
2100 }
2101
2102
2103 SYSCTL_PROC(_kern, KERN_SYMFILE, symfile,
2104 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_LOCKED,
2105 0, 0, sysctl_symfile, "A", "");
2106
2107 #if NFSCLIENT
2108 STATIC int
2109 sysctl_netboot
2110 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2111 {
2112 return sysctl_io_number(req, netboot_root(), sizeof(int), NULL, NULL);
2113 }
2114
2115 SYSCTL_PROC(_kern, KERN_NETBOOT, netboot,
2116 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
2117 0, 0, sysctl_netboot, "I", "");
2118 #endif
2119
2120 #ifdef CONFIG_IMGSRC_ACCESS
2121 /*
2122 * Legacy--act as if only one layer of nesting is possible.
2123 */
2124 STATIC int
2125 sysctl_imgsrcdev
2126 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2127 {
2128 vfs_context_t ctx = vfs_context_current();
2129 vnode_t devvp;
2130 int result;
2131
2132 if (!vfs_context_issuser(ctx)) {
2133 return EPERM;
2134 }
2135
2136 if (imgsrc_rootvnodes[0] == NULL) {
2137 return ENOENT;
2138 }
2139
2140 result = vnode_getwithref(imgsrc_rootvnodes[0]);
2141 if (result != 0) {
2142 return result;
2143 }
2144
2145 devvp = vnode_mount(imgsrc_rootvnodes[0])->mnt_devvp;
2146 result = vnode_getwithref(devvp);
2147 if (result != 0) {
2148 goto out;
2149 }
2150
2151 result = sysctl_io_number(req, vnode_specrdev(devvp), sizeof(dev_t), NULL, NULL);
2152
2153 vnode_put(devvp);
2154 out:
2155 vnode_put(imgsrc_rootvnodes[0]);
2156 return result;
2157 }
2158
2159 SYSCTL_PROC(_kern, OID_AUTO, imgsrcdev,
2160 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
2161 0, 0, sysctl_imgsrcdev, "I", "");
2162
2163 STATIC int
2164 sysctl_imgsrcinfo
2165 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2166 {
2167 int error;
2168 struct imgsrc_info info[MAX_IMAGEBOOT_NESTING] = {}; /* 2 for now, no problem */
2169 uint32_t i;
2170 vnode_t rvp, devvp;
2171
2172 if (imgsrc_rootvnodes[0] == NULLVP) {
2173 return ENXIO;
2174 }
2175
2176 for (i = 0; i < MAX_IMAGEBOOT_NESTING; i++) {
2177 /*
2178 * Go get the root vnode.
2179 */
2180 rvp = imgsrc_rootvnodes[i];
2181 if (rvp == NULLVP) {
2182 break;
2183 }
2184
2185 error = vnode_get(rvp);
2186 if (error != 0) {
2187 return error;
2188 }
2189
2190 /*
2191 * For now, no getting at a non-local volume.
2192 */
2193 devvp = vnode_mount(rvp)->mnt_devvp;
2194 if (devvp == NULL) {
2195 vnode_put(rvp);
2196 return EINVAL;
2197 }
2198
2199 error = vnode_getwithref(devvp);
2200 if (error != 0) {
2201 vnode_put(rvp);
2202 return error;
2203 }
2204
2205 /*
2206 * Fill in info.
2207 */
2208 info[i].ii_dev = vnode_specrdev(devvp);
2209 info[i].ii_flags = 0;
2210 info[i].ii_height = i;
2211 bzero(info[i].ii_reserved, sizeof(info[i].ii_reserved));
2212
2213 vnode_put(devvp);
2214 vnode_put(rvp);
2215 }
2216
2217 return sysctl_io_opaque(req, info, i * sizeof(info[0]), NULL);
2218 }
2219
2220 SYSCTL_PROC(_kern, OID_AUTO, imgsrcinfo,
2221 CTLTYPE_OPAQUE | CTLFLAG_RD | CTLFLAG_LOCKED,
2222 0, 0, sysctl_imgsrcinfo, "I", "");
2223
2224 #endif /* CONFIG_IMGSRC_ACCESS */
2225
2226
2227 SYSCTL_DECL(_kern_timer);
2228 SYSCTL_NODE(_kern, OID_AUTO, timer, CTLFLAG_RW | CTLFLAG_LOCKED, 0, "timer");
2229
2230
2231 SYSCTL_INT(_kern_timer, OID_AUTO, coalescing_enabled,
2232 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
2233 &mach_timer_coalescing_enabled, 0, "");
2234
2235 SYSCTL_QUAD(_kern_timer, OID_AUTO, deadline_tracking_bin_1,
2236 CTLFLAG_RW | CTLFLAG_LOCKED,
2237 &timer_deadline_tracking_bin_1, "");
2238 SYSCTL_QUAD(_kern_timer, OID_AUTO, deadline_tracking_bin_2,
2239 CTLFLAG_RW | CTLFLAG_LOCKED,
2240 &timer_deadline_tracking_bin_2, "");
2241
2242 SYSCTL_DECL(_kern_timer_longterm);
2243 SYSCTL_NODE(_kern_timer, OID_AUTO, longterm, CTLFLAG_RW | CTLFLAG_LOCKED, 0, "longterm");
2244
2245
2246 /* Must match definition in osfmk/kern/timer_call.c */
2247 enum {
2248 THRESHOLD, QCOUNT,
2249 ENQUEUES, DEQUEUES, ESCALATES, SCANS, PREEMPTS,
2250 LATENCY, LATENCY_MIN, LATENCY_MAX, SCAN_LIMIT, SCAN_INTERVAL, PAUSES
2251 };
2252 extern uint64_t timer_sysctl_get(int);
2253 extern int timer_sysctl_set(int, uint64_t);
2254
2255 STATIC int
2256 sysctl_timer
2257 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2258 {
2259 int oid = (int)arg1;
2260 uint64_t value = timer_sysctl_get(oid);
2261 uint64_t new_value;
2262 int error;
2263 int changed;
2264
2265 error = sysctl_io_number(req, value, sizeof(value), &new_value, &changed);
2266 if (changed)
2267 error = timer_sysctl_set(oid, new_value);
2268
2269 return error;
2270 }
2271
2272 SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, threshold,
2273 CTLTYPE_QUAD | CTLFLAG_RW | CTLFLAG_LOCKED,
2274 (void *) THRESHOLD, 0, sysctl_timer, "Q", "");
2275 SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, scan_limit,
2276 CTLTYPE_QUAD | CTLFLAG_RW | CTLFLAG_LOCKED,
2277 (void *) SCAN_LIMIT, 0, sysctl_timer, "Q", "");
2278 SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, scan_interval,
2279 CTLTYPE_QUAD | CTLFLAG_RW | CTLFLAG_LOCKED,
2280 (void *) SCAN_INTERVAL, 0, sysctl_timer, "Q", "");
2281
2282 SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, qlen,
2283 CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
2284 (void *) QCOUNT, 0, sysctl_timer, "Q", "");
2285 SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, scan_pauses,
2286 CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
2287 (void *) PAUSES, 0, sysctl_timer, "Q", "");
2288
2289 #if DEBUG
2290 SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, enqueues,
2291 CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
2292 (void *) ENQUEUES, 0, sysctl_timer, "Q", "");
2293 SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, dequeues,
2294 CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
2295 (void *) DEQUEUES, 0, sysctl_timer, "Q", "");
2296 SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, escalates,
2297 CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
2298 (void *) ESCALATES, 0, sysctl_timer, "Q", "");
2299 SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, scans,
2300 CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
2301 (void *) SCANS, 0, sysctl_timer, "Q", "");
2302 SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, preempts,
2303 CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
2304 (void *) PREEMPTS, 0, sysctl_timer, "Q", "");
2305 SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, latency,
2306 CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
2307 (void *) LATENCY, 0, sysctl_timer, "Q", "");
2308 SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, latency_min,
2309 CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
2310 (void *) LATENCY_MIN, 0, sysctl_timer, "Q", "");
2311 SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, latency_max,
2312 CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
2313 (void *) LATENCY_MAX, 0, sysctl_timer, "Q", "");
2314 #endif /* DEBUG */
2315
2316 STATIC int
2317 sysctl_usrstack
2318 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2319 {
2320 return sysctl_io_number(req, (int)req->p->user_stack, sizeof(int), NULL, NULL);
2321 }
2322
2323 SYSCTL_PROC(_kern, KERN_USRSTACK32, usrstack,
2324 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
2325 0, 0, sysctl_usrstack, "I", "");
2326
2327 STATIC int
2328 sysctl_usrstack64
2329 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2330 {
2331 return sysctl_io_number(req, req->p->user_stack, sizeof(req->p->user_stack), NULL, NULL);
2332 }
2333
2334 SYSCTL_PROC(_kern, KERN_USRSTACK64, usrstack64,
2335 CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
2336 0, 0, sysctl_usrstack64, "Q", "");
2337
2338 #if CONFIG_COREDUMP
2339
2340 SYSCTL_STRING(_kern, KERN_COREFILE, corefile,
2341 CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
2342 corefilename, sizeof(corefilename), "");
2343
2344 STATIC int
2345 sysctl_coredump
2346 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2347 {
2348 #ifdef SECURE_KERNEL
2349 (void)req;
2350 return (ENOTSUP);
2351 #else
2352 int new_value, changed;
2353 int error = sysctl_io_number(req, do_coredump, sizeof(int), &new_value, &changed);
2354 if (changed) {
2355 if ((new_value == 0) || (new_value == 1))
2356 do_coredump = new_value;
2357 else
2358 error = EINVAL;
2359 }
2360 return(error);
2361 #endif
2362 }
2363
2364 SYSCTL_PROC(_kern, KERN_COREDUMP, coredump,
2365 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
2366 0, 0, sysctl_coredump, "I", "");
2367
2368 STATIC int
2369 sysctl_suid_coredump
2370 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2371 {
2372 #ifdef SECURE_KERNEL
2373 (void)req;
2374 return (ENOTSUP);
2375 #else
2376 int new_value, changed;
2377 int error = sysctl_io_number(req, sugid_coredump, sizeof(int), &new_value, &changed);
2378 if (changed) {
2379 if ((new_value == 0) || (new_value == 1))
2380 sugid_coredump = new_value;
2381 else
2382 error = EINVAL;
2383 }
2384 return(error);
2385 #endif
2386 }
2387
2388 SYSCTL_PROC(_kern, KERN_SUGID_COREDUMP, sugid_coredump,
2389 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
2390 0, 0, sysctl_suid_coredump, "I", "");
2391
2392 #endif /* CONFIG_COREDUMP */
2393
2394 STATIC int
2395 sysctl_delayterm
2396 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2397 {
2398 struct proc *p = req->p;
2399 int new_value, changed;
2400 int error = sysctl_io_number(req, (req->p->p_lflag & P_LDELAYTERM)? 1: 0, sizeof(int), &new_value, &changed);
2401 if (changed) {
2402 proc_lock(p);
2403 if (new_value)
2404 req->p->p_lflag |= P_LDELAYTERM;
2405 else
2406 req->p->p_lflag &= ~P_LDELAYTERM;
2407 proc_unlock(p);
2408 }
2409 return(error);
2410 }
2411
2412 SYSCTL_PROC(_kern, KERN_PROCDELAYTERM, delayterm,
2413 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
2414 0, 0, sysctl_delayterm, "I", "");
2415
2416
2417 STATIC int
2418 sysctl_rage_vnode
2419 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2420 {
2421 struct proc *p = req->p;
2422 struct uthread *ut;
2423 int new_value, old_value, changed;
2424 int error;
2425
2426 ut = get_bsdthread_info(current_thread());
2427
2428 if (ut->uu_flag & UT_RAGE_VNODES)
2429 old_value = KERN_RAGE_THREAD;
2430 else if (p->p_lflag & P_LRAGE_VNODES)
2431 old_value = KERN_RAGE_PROC;
2432 else
2433 old_value = 0;
2434
2435 error = sysctl_io_number(req, old_value, sizeof(int), &new_value, &changed);
2436
2437 if (error == 0) {
2438 switch (new_value) {
2439 case KERN_RAGE_PROC:
2440 proc_lock(p);
2441 p->p_lflag |= P_LRAGE_VNODES;
2442 proc_unlock(p);
2443 break;
2444 case KERN_UNRAGE_PROC:
2445 proc_lock(p);
2446 p->p_lflag &= ~P_LRAGE_VNODES;
2447 proc_unlock(p);
2448 break;
2449
2450 case KERN_RAGE_THREAD:
2451 ut->uu_flag |= UT_RAGE_VNODES;
2452 break;
2453 case KERN_UNRAGE_THREAD:
2454 ut = get_bsdthread_info(current_thread());
2455 ut->uu_flag &= ~UT_RAGE_VNODES;
2456 break;
2457 }
2458 }
2459 return(error);
2460 }
2461
2462 SYSCTL_PROC(_kern, KERN_RAGEVNODE, rage_vnode,
2463 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_LOCKED,
2464 0, 0, sysctl_rage_vnode, "I", "");
2465
2466 /* XXX move this interface into libproc and remove this sysctl */
2467 STATIC int
2468 sysctl_setthread_cpupercent
2469 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2470 {
2471 int new_value, old_value;
2472 int error = 0;
2473 kern_return_t kret = KERN_SUCCESS;
2474 uint8_t percent = 0;
2475 int ms_refill = 0;
2476
2477 if (!req->newptr)
2478 return (0);
2479
2480 old_value = 0;
2481
2482 if ((error = sysctl_io_number(req, old_value, sizeof(old_value), &new_value, NULL)) != 0)
2483 return (error);
2484
2485 percent = new_value & 0xff; /* low 8 bytes for perent */
2486 ms_refill = (new_value >> 8) & 0xffffff; /* upper 24bytes represent ms refill value */
2487 if (percent > 100)
2488 return (EINVAL);
2489
2490 /*
2491 * If the caller is specifying a percentage of 0, this will unset the CPU limit, if present.
2492 */
2493 if ((kret = thread_set_cpulimit(THREAD_CPULIMIT_BLOCK, percent, ms_refill * (int)NSEC_PER_MSEC)) != 0)
2494 return (EIO);
2495
2496 return (0);
2497 }
2498
2499 SYSCTL_PROC(_kern, OID_AUTO, setthread_cpupercent,
2500 CTLTYPE_INT | CTLFLAG_WR | CTLFLAG_ANYBODY,
2501 0, 0, sysctl_setthread_cpupercent, "I", "set thread cpu percentage limit");
2502
2503
2504 STATIC int
2505 sysctl_kern_check_openevt
2506 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2507 {
2508 struct proc *p = req->p;
2509 int new_value, old_value, changed;
2510 int error;
2511
2512 if (p->p_flag & P_CHECKOPENEVT) {
2513 old_value = KERN_OPENEVT_PROC;
2514 } else {
2515 old_value = 0;
2516 }
2517
2518 error = sysctl_io_number(req, old_value, sizeof(int), &new_value, &changed);
2519
2520 if (error == 0) {
2521 switch (new_value) {
2522 case KERN_OPENEVT_PROC:
2523 OSBitOrAtomic(P_CHECKOPENEVT, &p->p_flag);
2524 break;
2525
2526 case KERN_UNOPENEVT_PROC:
2527 OSBitAndAtomic(~((uint32_t)P_CHECKOPENEVT), &p->p_flag);
2528 break;
2529
2530 default:
2531 error = EINVAL;
2532 }
2533 }
2534 return(error);
2535 }
2536
2537 SYSCTL_PROC(_kern, KERN_CHECKOPENEVT, check_openevt, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_LOCKED,
2538 0, 0, sysctl_kern_check_openevt, "I", "set the per-process check-open-evt flag");
2539
2540
2541
2542 STATIC int
2543 sysctl_nx
2544 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2545 {
2546 #ifdef SECURE_KERNEL
2547 (void)req;
2548 return ENOTSUP;
2549 #else
2550 int new_value, changed;
2551 int error;
2552
2553 error = sysctl_io_number(req, nx_enabled, sizeof(nx_enabled), &new_value, &changed);
2554 if (error)
2555 return error;
2556
2557 if (changed) {
2558 #if defined(__i386__) || defined(__x86_64__)
2559 /*
2560 * Only allow setting if NX is supported on the chip
2561 */
2562 if (!(cpuid_extfeatures() & CPUID_EXTFEATURE_XD))
2563 return ENOTSUP;
2564 #endif
2565 nx_enabled = new_value;
2566 }
2567 return(error);
2568 #endif /* SECURE_KERNEL */
2569 }
2570
2571
2572
2573 SYSCTL_PROC(_kern, KERN_NX_PROTECTION, nx,
2574 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
2575 0, 0, sysctl_nx, "I", "");
2576
2577 STATIC int
2578 sysctl_loadavg
2579 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2580 {
2581 if (proc_is64bit(req->p)) {
2582 struct user64_loadavg loadinfo64 = {};
2583 fill_loadavg64(&averunnable, &loadinfo64);
2584 return sysctl_io_opaque(req, &loadinfo64, sizeof(loadinfo64), NULL);
2585 } else {
2586 struct user32_loadavg loadinfo32 = {};
2587 fill_loadavg32(&averunnable, &loadinfo32);
2588 return sysctl_io_opaque(req, &loadinfo32, sizeof(loadinfo32), NULL);
2589 }
2590 }
2591
2592 SYSCTL_PROC(_vm, VM_LOADAVG, loadavg,
2593 CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_LOCKED,
2594 0, 0, sysctl_loadavg, "S,loadavg", "");
2595
2596 /*
2597 * Note: Thread safe; vm_map_lock protects in vm_toggle_entry_reuse()
2598 */
2599 STATIC int
2600 sysctl_vm_toggle_address_reuse(__unused struct sysctl_oid *oidp, __unused void *arg1,
2601 __unused int arg2, struct sysctl_req *req)
2602 {
2603 int old_value=0, new_value=0, error=0;
2604
2605 if(vm_toggle_entry_reuse( VM_TOGGLE_GETVALUE, &old_value ))
2606 return(error);
2607 error = sysctl_io_number(req, old_value, sizeof(int), &new_value, NULL);
2608 if (!error) {
2609 return (vm_toggle_entry_reuse(new_value, NULL));
2610 }
2611 return(error);
2612 }
2613
2614 SYSCTL_PROC(_debug, OID_AUTO, toggle_address_reuse, CTLFLAG_ANYBODY | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED, 0, 0, sysctl_vm_toggle_address_reuse,"I","");
2615
2616 #ifdef CONFIG_XNUPOST
2617
2618 extern int xnupost_export_testdata(void *outp, uint32_t size, uint32_t *lenp);
2619 extern uint32_t xnupost_get_estimated_testdata_size(void);
2620
2621 extern int xnupost_reset_all_tests(void);
2622
2623 STATIC int
2624 sysctl_handle_xnupost_get_tests SYSCTL_HANDLER_ARGS
2625 {
2626 /* fixup unused arguments warnings */
2627 __unused int _oa2 = arg2;
2628 __unused void * _oa1 = arg1;
2629 __unused struct sysctl_oid * _oidp = oidp;
2630
2631 int error = 0;
2632 user_addr_t oldp = 0;
2633 user_addr_t newp = 0;
2634 uint32_t usedbytes = 0;
2635
2636 oldp = req->oldptr;
2637 newp = req->newptr;
2638
2639 if (newp)
2640 return ENOTSUP;
2641
2642 if ((void *)oldp == NULL) {
2643 /* return estimated size for second call where info can be placed */
2644 req->oldidx = xnupost_get_estimated_testdata_size();
2645 } else {
2646 error = xnupost_export_testdata((void *)oldp, req->oldlen, &usedbytes);
2647 req->oldidx = usedbytes;
2648 }
2649
2650 return error;
2651 }
2652
2653 SYSCTL_PROC(_debug,
2654 OID_AUTO,
2655 xnupost_get_tests,
2656 CTLFLAG_MASKED | CTLFLAG_ANYBODY | CTLTYPE_OPAQUE | CTLFLAG_RD | CTLFLAG_LOCKED,
2657 0,
2658 0,
2659 sysctl_handle_xnupost_get_tests,
2660 "-",
2661 "read xnupost test data in kernel");
2662
2663 STATIC int
2664 sysctl_debug_xnupost_ctl SYSCTL_HANDLER_ARGS
2665 {
2666 /* fixup unused arguments warnings */
2667 __unused int _oa2 = arg2;
2668 __unused void * _oa1 = arg1;
2669 __unused struct sysctl_oid * _oidp = oidp;
2670
2671 #define ARRCOUNT 4
2672 /*
2673 * INPUT: ACTION, PARAM1, PARAM2, PARAM3
2674 * OUTPUT: RESULTCODE, ADDITIONAL DATA
2675 */
2676 int32_t outval[ARRCOUNT] = {0};
2677 int32_t input[ARRCOUNT] = {0};
2678 int32_t out_size = sizeof(outval);
2679 int32_t in_size = sizeof(input);
2680 int error = 0;
2681
2682 /* if this is NULL call to find out size, send out size info */
2683 if (!req->newptr) {
2684 goto out;
2685 }
2686
2687 /* pull in provided value from userspace */
2688 error = SYSCTL_IN(req, &input[0], in_size);
2689 if (error)
2690 return error;
2691
2692 if (input[0] == XTCTL_RESET_TESTDATA) {
2693 outval[0] = xnupost_reset_all_tests();
2694 goto out;
2695 }
2696
2697 out:
2698 error = SYSCTL_OUT(req, &outval[0], out_size);
2699 return error;
2700 }
2701
2702 SYSCTL_PROC(_debug,
2703 OID_AUTO,
2704 xnupost_testctl,
2705 CTLFLAG_MASKED | CTLFLAG_ANYBODY | CTLTYPE_OPAQUE | CTLFLAG_RW | CTLFLAG_LOCKED,
2706 0,
2707 0,
2708 sysctl_debug_xnupost_ctl,
2709 "I",
2710 "xnupost control for kernel testing");
2711
2712 extern void test_oslog_handleOSLogCtl(int32_t * in, int32_t * out, int32_t arraycount);
2713
2714 STATIC int
2715 sysctl_debug_test_oslog_ctl(__unused struct sysctl_oid * oidp, __unused void * arg1, __unused int arg2, struct sysctl_req * req)
2716 {
2717 #define ARRCOUNT 4
2718 int32_t outval[ARRCOUNT] = {0};
2719 int32_t input[ARRCOUNT] = {0};
2720 int32_t size_outval = sizeof(outval);
2721 int32_t size_inval = sizeof(input);
2722 int32_t error;
2723
2724 /* if this is NULL call to find out size, send out size info */
2725 if (!req->newptr) {
2726 error = SYSCTL_OUT(req, &outval[0], size_outval);
2727 return error;
2728 }
2729
2730 /* pull in provided value from userspace */
2731 error = SYSCTL_IN(req, &input[0], size_inval);
2732 if (error)
2733 return error;
2734
2735 test_oslog_handleOSLogCtl(input, outval, ARRCOUNT);
2736
2737 error = SYSCTL_OUT(req, &outval[0], size_outval);
2738
2739 return error;
2740 }
2741
2742 SYSCTL_PROC(_debug,
2743 OID_AUTO,
2744 test_OSLogCtl,
2745 CTLFLAG_MASKED | CTLFLAG_ANYBODY | CTLTYPE_OPAQUE | CTLFLAG_RW | CTLFLAG_LOCKED,
2746 0,
2747 0,
2748 sysctl_debug_test_oslog_ctl,
2749 "I",
2750 "testing oslog in kernel");
2751
2752 #include <mach/task.h>
2753 #include <mach/semaphore.h>
2754
2755 extern lck_grp_t * sysctl_debug_test_stackshot_owner_grp; /* used for both mutexes and rwlocks */
2756 extern lck_mtx_t * sysctl_debug_test_stackshot_owner_init_mtx; /* used to protect lck_*_init */
2757
2758 /* This is a sysctl for testing collection of owner info on a lock in kernel space. A multi-threaded
2759 * test from userland sets this sysctl in such a way that a thread blocks in kernel mode, and a
2760 * stackshot is taken to see if the owner of the lock can be identified.
2761 *
2762 * We can't return to userland with a kernel lock held, so be sure to unlock before we leave.
2763 * the semaphores allow us to artificially create cases where the lock is being held and the
2764 * thread is hanging / taking a long time to do something. */
2765
2766 volatile char sysctl_debug_test_stackshot_mtx_inited = 0;
2767 semaphore_t sysctl_debug_test_stackshot_mutex_sem;
2768 lck_mtx_t sysctl_debug_test_stackshot_owner_lck;
2769
2770 #define SYSCTL_DEBUG_MTX_ACQUIRE_WAIT 1
2771 #define SYSCTL_DEBUG_MTX_ACQUIRE_NOWAIT 2
2772 #define SYSCTL_DEBUG_MTX_SIGNAL 3
2773 #define SYSCTL_DEBUG_MTX_TEARDOWN 4
2774
2775 STATIC int
2776 sysctl_debug_test_stackshot_mutex_owner(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2777 {
2778 long long option = -1;
2779 /* if the user tries to read the sysctl, we tell them what the address of the lock is (to test against stackshot's output) */
2780 long long mtx_unslid_addr = (long long)VM_KERNEL_UNSLIDE_OR_PERM(&sysctl_debug_test_stackshot_owner_lck);
2781 int error = sysctl_io_number(req, mtx_unslid_addr, sizeof(long long), (void*)&option, NULL);
2782
2783 lck_mtx_lock(sysctl_debug_test_stackshot_owner_init_mtx);
2784 if (!sysctl_debug_test_stackshot_mtx_inited) {
2785 lck_mtx_init(&sysctl_debug_test_stackshot_owner_lck,
2786 sysctl_debug_test_stackshot_owner_grp,
2787 LCK_ATTR_NULL);
2788 semaphore_create(kernel_task,
2789 &sysctl_debug_test_stackshot_mutex_sem,
2790 SYNC_POLICY_FIFO, 0);
2791 sysctl_debug_test_stackshot_mtx_inited = 1;
2792 }
2793 lck_mtx_unlock(sysctl_debug_test_stackshot_owner_init_mtx);
2794
2795 if (!error) {
2796 switch(option) {
2797 case SYSCTL_DEBUG_MTX_ACQUIRE_NOWAIT:
2798 lck_mtx_lock(&sysctl_debug_test_stackshot_owner_lck);
2799 lck_mtx_unlock(&sysctl_debug_test_stackshot_owner_lck);
2800 break;
2801 case SYSCTL_DEBUG_MTX_ACQUIRE_WAIT:
2802 lck_mtx_lock(&sysctl_debug_test_stackshot_owner_lck);
2803 semaphore_wait(sysctl_debug_test_stackshot_mutex_sem);
2804 lck_mtx_unlock(&sysctl_debug_test_stackshot_owner_lck);
2805 break;
2806 case SYSCTL_DEBUG_MTX_SIGNAL:
2807 semaphore_signal(sysctl_debug_test_stackshot_mutex_sem);
2808 break;
2809 case SYSCTL_DEBUG_MTX_TEARDOWN:
2810 lck_mtx_lock(sysctl_debug_test_stackshot_owner_init_mtx);
2811
2812 lck_mtx_destroy(&sysctl_debug_test_stackshot_owner_lck,
2813 sysctl_debug_test_stackshot_owner_grp);
2814 semaphore_destroy(kernel_task,
2815 sysctl_debug_test_stackshot_mutex_sem);
2816 sysctl_debug_test_stackshot_mtx_inited = 0;
2817
2818 lck_mtx_unlock(sysctl_debug_test_stackshot_owner_init_mtx);
2819 break;
2820 case -1: /* user just wanted to read the value, so do nothing */
2821 break;
2822 default:
2823 error = EINVAL;
2824 break;
2825 }
2826 }
2827 return error;
2828 }
2829
2830 /* we can't return to userland with a kernel rwlock held, so be sure to unlock before we leave.
2831 * the semaphores allow us to artificially create cases where the lock is being held and the
2832 * thread is hanging / taking a long time to do something. */
2833
2834 SYSCTL_PROC(_debug,
2835 OID_AUTO,
2836 test_MutexOwnerCtl,
2837 CTLFLAG_MASKED | CTLFLAG_ANYBODY | CTLTYPE_QUAD | CTLFLAG_RW | CTLFLAG_LOCKED,
2838 0,
2839 0,
2840 sysctl_debug_test_stackshot_mutex_owner,
2841 "-",
2842 "Testing mutex owner in kernel");
2843
2844 volatile char sysctl_debug_test_stackshot_rwlck_inited = 0;
2845 lck_rw_t sysctl_debug_test_stackshot_owner_rwlck;
2846 semaphore_t sysctl_debug_test_stackshot_rwlck_sem;
2847
2848 #define SYSCTL_DEBUG_KRWLCK_RACQUIRE_NOWAIT 1
2849 #define SYSCTL_DEBUG_KRWLCK_RACQUIRE_WAIT 2
2850 #define SYSCTL_DEBUG_KRWLCK_WACQUIRE_NOWAIT 3
2851 #define SYSCTL_DEBUG_KRWLCK_WACQUIRE_WAIT 4
2852 #define SYSCTL_DEBUG_KRWLCK_SIGNAL 5
2853 #define SYSCTL_DEBUG_KRWLCK_TEARDOWN 6
2854
2855 STATIC int
2856 sysctl_debug_test_stackshot_rwlck_owner(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2857 {
2858 long long option = -1;
2859 /* if the user tries to read the sysctl, we tell them what the address of the lock is
2860 * (to test against stackshot's output) */
2861 long long rwlck_unslid_addr = (long long)VM_KERNEL_UNSLIDE_OR_PERM(&sysctl_debug_test_stackshot_owner_rwlck);
2862 int error = sysctl_io_number(req, rwlck_unslid_addr, sizeof(long long), (void*)&option, NULL);
2863
2864 lck_mtx_lock(sysctl_debug_test_stackshot_owner_init_mtx);
2865 if (!sysctl_debug_test_stackshot_rwlck_inited) {
2866 lck_rw_init(&sysctl_debug_test_stackshot_owner_rwlck,
2867 sysctl_debug_test_stackshot_owner_grp,
2868 LCK_ATTR_NULL);
2869 semaphore_create(kernel_task,
2870 &sysctl_debug_test_stackshot_rwlck_sem,
2871 SYNC_POLICY_FIFO,
2872 0);
2873 sysctl_debug_test_stackshot_rwlck_inited = 1;
2874 }
2875 lck_mtx_unlock(sysctl_debug_test_stackshot_owner_init_mtx);
2876
2877 if (!error) {
2878 switch(option) {
2879 case SYSCTL_DEBUG_KRWLCK_RACQUIRE_NOWAIT:
2880 lck_rw_lock(&sysctl_debug_test_stackshot_owner_rwlck, LCK_RW_TYPE_SHARED);
2881 lck_rw_unlock(&sysctl_debug_test_stackshot_owner_rwlck, LCK_RW_TYPE_SHARED);
2882 break;
2883 case SYSCTL_DEBUG_KRWLCK_RACQUIRE_WAIT:
2884 lck_rw_lock(&sysctl_debug_test_stackshot_owner_rwlck, LCK_RW_TYPE_SHARED);
2885 semaphore_wait(sysctl_debug_test_stackshot_rwlck_sem);
2886 lck_rw_unlock(&sysctl_debug_test_stackshot_owner_rwlck, LCK_RW_TYPE_SHARED);
2887 break;
2888 case SYSCTL_DEBUG_KRWLCK_WACQUIRE_NOWAIT:
2889 lck_rw_lock(&sysctl_debug_test_stackshot_owner_rwlck, LCK_RW_TYPE_EXCLUSIVE);
2890 lck_rw_unlock(&sysctl_debug_test_stackshot_owner_rwlck, LCK_RW_TYPE_EXCLUSIVE);
2891 break;
2892 case SYSCTL_DEBUG_KRWLCK_WACQUIRE_WAIT:
2893 lck_rw_lock(&sysctl_debug_test_stackshot_owner_rwlck, LCK_RW_TYPE_EXCLUSIVE);
2894 semaphore_wait(sysctl_debug_test_stackshot_rwlck_sem);
2895 lck_rw_unlock(&sysctl_debug_test_stackshot_owner_rwlck, LCK_RW_TYPE_EXCLUSIVE);
2896 break;
2897 case SYSCTL_DEBUG_KRWLCK_SIGNAL:
2898 semaphore_signal(sysctl_debug_test_stackshot_rwlck_sem);
2899 break;
2900 case SYSCTL_DEBUG_KRWLCK_TEARDOWN:
2901 lck_mtx_lock(sysctl_debug_test_stackshot_owner_init_mtx);
2902
2903 lck_rw_destroy(&sysctl_debug_test_stackshot_owner_rwlck,
2904 sysctl_debug_test_stackshot_owner_grp);
2905 semaphore_destroy(kernel_task,
2906 sysctl_debug_test_stackshot_rwlck_sem);
2907 sysctl_debug_test_stackshot_rwlck_inited = 0;
2908
2909 lck_mtx_unlock(sysctl_debug_test_stackshot_owner_init_mtx);
2910 break;
2911 case -1: /* user just wanted to read the value, so do nothing */
2912 break;
2913 default:
2914 error = EINVAL;
2915 break;
2916 }
2917 }
2918 return error;
2919 }
2920
2921
2922 SYSCTL_PROC(_debug,
2923 OID_AUTO,
2924 test_RWLockOwnerCtl,
2925 CTLFLAG_MASKED | CTLFLAG_ANYBODY | CTLTYPE_QUAD | CTLFLAG_RW | CTLFLAG_LOCKED,
2926 0,
2927 0,
2928 sysctl_debug_test_stackshot_rwlck_owner,
2929 "-",
2930 "Testing rwlock owner in kernel");
2931 #endif /* !CONFIG_XNUPOST */
2932
2933 STATIC int
2934 sysctl_swapusage
2935 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
2936 {
2937 int error;
2938 uint64_t swap_total;
2939 uint64_t swap_avail;
2940 vm_size_t swap_pagesize;
2941 boolean_t swap_encrypted;
2942 struct xsw_usage xsu = {};
2943
2944 error = macx_swapinfo(&swap_total,
2945 &swap_avail,
2946 &swap_pagesize,
2947 &swap_encrypted);
2948 if (error)
2949 return error;
2950
2951 xsu.xsu_total = swap_total;
2952 xsu.xsu_avail = swap_avail;
2953 xsu.xsu_used = swap_total - swap_avail;
2954 xsu.xsu_pagesize = swap_pagesize;
2955 xsu.xsu_encrypted = swap_encrypted;
2956 return sysctl_io_opaque(req, &xsu, sizeof(xsu), NULL);
2957 }
2958
2959
2960
2961 SYSCTL_PROC(_vm, VM_SWAPUSAGE, swapusage,
2962 CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_LOCKED,
2963 0, 0, sysctl_swapusage, "S,xsw_usage", "");
2964
2965 #if CONFIG_FREEZE
2966 extern void vm_page_reactivate_all_throttled(void);
2967 extern void memorystatus_disable_freeze(void);
2968
2969 static int
2970 sysctl_freeze_enabled SYSCTL_HANDLER_ARGS
2971 {
2972 #pragma unused(arg1, arg2)
2973 int error, val = memorystatus_freeze_enabled ? 1 : 0;
2974 boolean_t disabled;
2975
2976 error = sysctl_handle_int(oidp, &val, 0, req);
2977 if (error || !req->newptr)
2978 return (error);
2979
2980 if (! VM_CONFIG_FREEZER_SWAP_IS_ACTIVE) {
2981 //assert(req->newptr);
2982 printf("Failed attempt to set vm.freeze_enabled sysctl\n");
2983 return EINVAL;
2984 }
2985
2986 /*
2987 * If freeze is being disabled, we need to move dirty pages out from the throttle to the active queue.
2988 */
2989 disabled = (!val && memorystatus_freeze_enabled);
2990
2991 memorystatus_freeze_enabled = val ? TRUE : FALSE;
2992
2993 if (disabled) {
2994 vm_page_reactivate_all_throttled();
2995 memorystatus_disable_freeze();
2996 }
2997
2998 return (0);
2999 }
3000
3001 SYSCTL_PROC(_vm, OID_AUTO, freeze_enabled, CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY, &memorystatus_freeze_enabled, 0, sysctl_freeze_enabled, "I", "");
3002 #endif /* CONFIG_FREEZE */
3003
3004 #if DEVELOPMENT || DEBUG
3005 extern int vm_num_swap_files_config;
3006 extern int vm_num_swap_files;
3007 extern lck_mtx_t vm_swap_data_lock;
3008 #define VM_MAX_SWAP_FILE_NUM 100
3009
3010 static int
3011 sysctl_vm_config_num_swap_files SYSCTL_HANDLER_ARGS
3012 {
3013 #pragma unused(arg1, arg2)
3014 int error = 0, val = vm_num_swap_files_config;
3015
3016 error = sysctl_handle_int(oidp, &val, 0, req);
3017 if (error || !req->newptr) {
3018 goto out;
3019 }
3020
3021 if (!VM_CONFIG_SWAP_IS_ACTIVE && !VM_CONFIG_FREEZER_SWAP_IS_ACTIVE) {
3022 printf("Swap is disabled\n");
3023 error = EINVAL;
3024 goto out;
3025 }
3026
3027 lck_mtx_lock(&vm_swap_data_lock);
3028
3029 if (val < vm_num_swap_files) {
3030 printf("Cannot configure fewer swap files than already exist.\n");
3031 error = EINVAL;
3032 lck_mtx_unlock(&vm_swap_data_lock);
3033 goto out;
3034 }
3035
3036 if (val > VM_MAX_SWAP_FILE_NUM) {
3037 printf("Capping number of swap files to upper bound.\n");
3038 val = VM_MAX_SWAP_FILE_NUM;
3039 }
3040
3041 vm_num_swap_files_config = val;
3042 lck_mtx_unlock(&vm_swap_data_lock);
3043 out:
3044
3045 return (0);
3046 }
3047
3048 SYSCTL_PROC(_debug, OID_AUTO, num_swap_files_configured, CTLFLAG_ANYBODY | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED, 0, 0, sysctl_vm_config_num_swap_files, "I", "");
3049 #endif /* DEVELOPMENT || DEBUG */
3050
3051 /* this kernel does NOT implement shared_region_make_private_np() */
3052 SYSCTL_INT(_kern, KERN_SHREG_PRIVATIZABLE, shreg_private,
3053 CTLFLAG_RD | CTLFLAG_LOCKED,
3054 (int *)NULL, 0, "");
3055
3056 STATIC int
3057 fetch_process_cputype(
3058 proc_t cur_proc,
3059 int *name,
3060 u_int namelen,
3061 cpu_type_t *cputype)
3062 {
3063 proc_t p = PROC_NULL;
3064 int refheld = 0;
3065 cpu_type_t ret = 0;
3066 int error = 0;
3067
3068 if (namelen == 0)
3069 p = cur_proc;
3070 else if (namelen == 1) {
3071 p = proc_find(name[0]);
3072 if (p == NULL)
3073 return (EINVAL);
3074 refheld = 1;
3075 } else {
3076 error = EINVAL;
3077 goto out;
3078 }
3079
3080 ret = cpu_type() & ~CPU_ARCH_MASK;
3081 if (IS_64BIT_PROCESS(p)) {
3082 ret |= CPU_ARCH_ABI64;
3083 }
3084
3085 *cputype = ret;
3086
3087 if (refheld != 0)
3088 proc_rele(p);
3089 out:
3090 return (error);
3091 }
3092
3093 STATIC int
3094 sysctl_sysctl_native(__unused struct sysctl_oid *oidp, void *arg1, int arg2,
3095 struct sysctl_req *req)
3096 {
3097 int error;
3098 cpu_type_t proc_cputype = 0;
3099 if ((error = fetch_process_cputype(req->p, (int *)arg1, arg2, &proc_cputype)) != 0)
3100 return error;
3101 int res = 1;
3102 if ((proc_cputype & ~CPU_ARCH_MASK) != (cpu_type() & ~CPU_ARCH_MASK))
3103 res = 0;
3104 return SYSCTL_OUT(req, &res, sizeof(res));
3105 }
3106 SYSCTL_PROC(_sysctl, OID_AUTO, proc_native, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED, 0, 0, sysctl_sysctl_native ,"I","proc_native");
3107
3108 STATIC int
3109 sysctl_sysctl_cputype(__unused struct sysctl_oid *oidp, void *arg1, int arg2,
3110 struct sysctl_req *req)
3111 {
3112 int error;
3113 cpu_type_t proc_cputype = 0;
3114 if ((error = fetch_process_cputype(req->p, (int *)arg1, arg2, &proc_cputype)) != 0)
3115 return error;
3116 return SYSCTL_OUT(req, &proc_cputype, sizeof(proc_cputype));
3117 }
3118 SYSCTL_PROC(_sysctl, OID_AUTO, proc_cputype, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED, 0, 0, sysctl_sysctl_cputype ,"I","proc_cputype");
3119
3120 STATIC int
3121 sysctl_safeboot
3122 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
3123 {
3124 return sysctl_io_number(req, boothowto & RB_SAFEBOOT ? 1 : 0, sizeof(int), NULL, NULL);
3125 }
3126
3127 SYSCTL_PROC(_kern, KERN_SAFEBOOT, safeboot,
3128 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
3129 0, 0, sysctl_safeboot, "I", "");
3130
3131 STATIC int
3132 sysctl_singleuser
3133 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
3134 {
3135 return sysctl_io_number(req, boothowto & RB_SINGLE ? 1 : 0, sizeof(int), NULL, NULL);
3136 }
3137
3138 SYSCTL_PROC(_kern, OID_AUTO, singleuser,
3139 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
3140 0, 0, sysctl_singleuser, "I", "");
3141
3142 STATIC int sysctl_minimalboot
3143 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
3144 {
3145 return sysctl_io_number(req, minimalboot, sizeof(int), NULL, NULL);
3146 }
3147
3148 SYSCTL_PROC(_kern, OID_AUTO, minimalboot,
3149 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
3150 0, 0, sysctl_minimalboot, "I", "");
3151
3152 /*
3153 * Controls for debugging affinity sets - see osfmk/kern/affinity.c
3154 */
3155 extern boolean_t affinity_sets_enabled;
3156 extern int affinity_sets_mapping;
3157
3158 SYSCTL_INT (_kern, OID_AUTO, affinity_sets_enabled,
3159 CTLFLAG_RW | CTLFLAG_LOCKED, (int *) &affinity_sets_enabled, 0, "hinting enabled");
3160 SYSCTL_INT (_kern, OID_AUTO, affinity_sets_mapping,
3161 CTLFLAG_RW | CTLFLAG_LOCKED, &affinity_sets_mapping, 0, "mapping policy");
3162
3163 /*
3164 * Boolean indicating if KASLR is active.
3165 */
3166 STATIC int
3167 sysctl_slide
3168 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
3169 {
3170 uint32_t slide;
3171
3172 slide = vm_kernel_slide ? 1 : 0;
3173
3174 return sysctl_io_number( req, slide, sizeof(int), NULL, NULL);
3175 }
3176
3177 SYSCTL_PROC(_kern, OID_AUTO, slide,
3178 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
3179 0, 0, sysctl_slide, "I", "");
3180
3181 /*
3182 * Limit on total memory users can wire.
3183 *
3184 * vm_global_user_wire_limit - system wide limit on wired memory from all processes combined.
3185 *
3186 * vm_user_wire_limit - per address space limit on wired memory. This puts a cap on the process's rlimit value.
3187 *
3188 * These values are initialized to reasonable defaults at boot time based on the available physical memory in
3189 * kmem_init().
3190 *
3191 * All values are in bytes.
3192 */
3193
3194 vm_map_size_t vm_global_no_user_wire_amount;
3195 vm_map_size_t vm_global_user_wire_limit;
3196 vm_map_size_t vm_user_wire_limit;
3197
3198 /*
3199 * There needs to be a more automatic/elegant way to do this
3200 */
3201 #if defined(__ARM__)
3202 SYSCTL_INT(_vm, OID_AUTO, global_no_user_wire_amount, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_global_no_user_wire_amount, 0, "");
3203 SYSCTL_INT(_vm, OID_AUTO, global_user_wire_limit, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_global_user_wire_limit, 0, "");
3204 SYSCTL_INT(_vm, OID_AUTO, user_wire_limit, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_user_wire_limit, 0, "");
3205 #else
3206 SYSCTL_QUAD(_vm, OID_AUTO, global_no_user_wire_amount, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_global_no_user_wire_amount, "");
3207 SYSCTL_QUAD(_vm, OID_AUTO, global_user_wire_limit, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_global_user_wire_limit, "");
3208 SYSCTL_QUAD(_vm, OID_AUTO, user_wire_limit, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_user_wire_limit, "");
3209 #endif
3210
3211 extern int vm_map_copy_overwrite_aligned_src_not_internal;
3212 extern int vm_map_copy_overwrite_aligned_src_not_symmetric;
3213 extern int vm_map_copy_overwrite_aligned_src_large;
3214 SYSCTL_INT(_vm, OID_AUTO, vm_copy_src_not_internal, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_map_copy_overwrite_aligned_src_not_internal, 0, "");
3215 SYSCTL_INT(_vm, OID_AUTO, vm_copy_src_not_symmetric, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_map_copy_overwrite_aligned_src_not_symmetric, 0, "");
3216 SYSCTL_INT(_vm, OID_AUTO, vm_copy_src_large, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_map_copy_overwrite_aligned_src_large, 0, "");
3217
3218
3219 extern uint32_t vm_page_external_count;
3220
3221 SYSCTL_INT(_vm, OID_AUTO, vm_page_external_count, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_external_count, 0, "");
3222
3223 SYSCTL_INT(_vm, OID_AUTO, vm_page_filecache_min, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_state.vm_page_filecache_min, 0, "");
3224 SYSCTL_INT(_vm, OID_AUTO, vm_page_xpmapped_min, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_state.vm_page_xpmapped_min, 0, "");
3225
3226 #if DEVELOPMENT || DEBUG
3227 SYSCTL_INT(_vm, OID_AUTO, vm_page_filecache_min_divisor, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_pageout_state.vm_page_filecache_min_divisor, 0, "");
3228 SYSCTL_INT(_vm, OID_AUTO, vm_page_xpmapped_min_divisor, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_pageout_state.vm_page_xpmapped_min_divisor, 0, "");
3229 #endif
3230
3231 extern int vm_compressor_mode;
3232 extern int vm_compressor_is_active;
3233 extern int vm_compressor_available;
3234 extern uint32_t vm_ripe_target_age;
3235 extern uint32_t swapout_target_age;
3236 extern int64_t compressor_bytes_used;
3237 extern int64_t c_segment_input_bytes;
3238 extern int64_t c_segment_compressed_bytes;
3239 extern uint32_t compressor_eval_period_in_msecs;
3240 extern uint32_t compressor_sample_min_in_msecs;
3241 extern uint32_t compressor_sample_max_in_msecs;
3242 extern uint32_t compressor_thrashing_threshold_per_10msecs;
3243 extern uint32_t compressor_thrashing_min_per_10msecs;
3244 extern uint32_t vm_compressor_time_thread;
3245
3246 #if DEVELOPMENT || DEBUG
3247 extern uint32_t vm_compressor_minorcompact_threshold_divisor;
3248 extern uint32_t vm_compressor_majorcompact_threshold_divisor;
3249 extern uint32_t vm_compressor_unthrottle_threshold_divisor;
3250 extern uint32_t vm_compressor_catchup_threshold_divisor;
3251
3252 extern uint32_t vm_compressor_minorcompact_threshold_divisor_overridden;
3253 extern uint32_t vm_compressor_majorcompact_threshold_divisor_overridden;
3254 extern uint32_t vm_compressor_unthrottle_threshold_divisor_overridden;
3255 extern uint32_t vm_compressor_catchup_threshold_divisor_overridden;
3256
3257 extern vmct_stats_t vmct_stats;
3258
3259
3260 STATIC int
3261 sysctl_minorcompact_threshold_divisor(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
3262 {
3263 int new_value, changed;
3264 int error = sysctl_io_number(req, vm_compressor_minorcompact_threshold_divisor, sizeof(int), &new_value, &changed);
3265
3266 if (changed) {
3267 vm_compressor_minorcompact_threshold_divisor = new_value;
3268 vm_compressor_minorcompact_threshold_divisor_overridden = 1;
3269 }
3270 return(error);
3271 }
3272
3273 SYSCTL_PROC(_vm, OID_AUTO, compressor_minorcompact_threshold_divisor,
3274 CTLTYPE_INT | CTLFLAG_LOCKED | CTLFLAG_RW,
3275 0, 0, sysctl_minorcompact_threshold_divisor, "I", "");
3276
3277
3278 STATIC int
3279 sysctl_majorcompact_threshold_divisor(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
3280 {
3281 int new_value, changed;
3282 int error = sysctl_io_number(req, vm_compressor_majorcompact_threshold_divisor, sizeof(int), &new_value, &changed);
3283
3284 if (changed) {
3285 vm_compressor_majorcompact_threshold_divisor = new_value;
3286 vm_compressor_majorcompact_threshold_divisor_overridden = 1;
3287 }
3288 return(error);
3289 }
3290
3291 SYSCTL_PROC(_vm, OID_AUTO, compressor_majorcompact_threshold_divisor,
3292 CTLTYPE_INT | CTLFLAG_LOCKED | CTLFLAG_RW,
3293 0, 0, sysctl_majorcompact_threshold_divisor, "I", "");
3294
3295
3296 STATIC int
3297 sysctl_unthrottle_threshold_divisor(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
3298 {
3299 int new_value, changed;
3300 int error = sysctl_io_number(req, vm_compressor_unthrottle_threshold_divisor, sizeof(int), &new_value, &changed);
3301
3302 if (changed) {
3303 vm_compressor_unthrottle_threshold_divisor = new_value;
3304 vm_compressor_unthrottle_threshold_divisor_overridden = 1;
3305 }
3306 return(error);
3307 }
3308
3309 SYSCTL_PROC(_vm, OID_AUTO, compressor_unthrottle_threshold_divisor,
3310 CTLTYPE_INT | CTLFLAG_LOCKED | CTLFLAG_RW,
3311 0, 0, sysctl_unthrottle_threshold_divisor, "I", "");
3312
3313
3314 STATIC int
3315 sysctl_catchup_threshold_divisor(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
3316 {
3317 int new_value, changed;
3318 int error = sysctl_io_number(req, vm_compressor_catchup_threshold_divisor, sizeof(int), &new_value, &changed);
3319
3320 if (changed) {
3321 vm_compressor_catchup_threshold_divisor = new_value;
3322 vm_compressor_catchup_threshold_divisor_overridden = 1;
3323 }
3324 return(error);
3325 }
3326
3327 SYSCTL_PROC(_vm, OID_AUTO, compressor_catchup_threshold_divisor,
3328 CTLTYPE_INT | CTLFLAG_LOCKED | CTLFLAG_RW,
3329 0, 0, sysctl_catchup_threshold_divisor, "I", "");
3330 #endif
3331
3332
3333 SYSCTL_QUAD(_vm, OID_AUTO, compressor_input_bytes, CTLFLAG_RD | CTLFLAG_LOCKED, &c_segment_input_bytes, "");
3334 SYSCTL_QUAD(_vm, OID_AUTO, compressor_compressed_bytes, CTLFLAG_RD | CTLFLAG_LOCKED, &c_segment_compressed_bytes, "");
3335 SYSCTL_QUAD(_vm, OID_AUTO, compressor_bytes_used, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_bytes_used, "");
3336
3337 SYSCTL_INT(_vm, OID_AUTO, compressor_mode, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_compressor_mode, 0, "");
3338 SYSCTL_INT(_vm, OID_AUTO, compressor_is_active, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_compressor_is_active, 0, "");
3339 SYSCTL_INT(_vm, OID_AUTO, compressor_swapout_target_age, CTLFLAG_RD | CTLFLAG_LOCKED, &swapout_target_age, 0, "");
3340 SYSCTL_INT(_vm, OID_AUTO, compressor_available, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_compressor_available, 0, "");
3341
3342 SYSCTL_INT(_vm, OID_AUTO, vm_ripe_target_age_in_secs, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_ripe_target_age, 0, "");
3343
3344 SYSCTL_INT(_vm, OID_AUTO, compressor_eval_period_in_msecs, CTLFLAG_RW | CTLFLAG_LOCKED, &compressor_eval_period_in_msecs, 0, "");
3345 SYSCTL_INT(_vm, OID_AUTO, compressor_sample_min_in_msecs, CTLFLAG_RW | CTLFLAG_LOCKED, &compressor_sample_min_in_msecs, 0, "");
3346 SYSCTL_INT(_vm, OID_AUTO, compressor_sample_max_in_msecs, CTLFLAG_RW | CTLFLAG_LOCKED, &compressor_sample_max_in_msecs, 0, "");
3347 SYSCTL_INT(_vm, OID_AUTO, compressor_thrashing_threshold_per_10msecs, CTLFLAG_RW | CTLFLAG_LOCKED, &compressor_thrashing_threshold_per_10msecs, 0, "");
3348 SYSCTL_INT(_vm, OID_AUTO, compressor_thrashing_min_per_10msecs, CTLFLAG_RW | CTLFLAG_LOCKED, &compressor_thrashing_min_per_10msecs, 0, "");
3349
3350 SYSCTL_STRING(_vm, OID_AUTO, swapfileprefix, CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED, swapfilename, sizeof(swapfilename) - SWAPFILENAME_INDEX_LEN, "");
3351
3352 SYSCTL_INT(_vm, OID_AUTO, compressor_timing_enabled, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_compressor_time_thread, 0, "");
3353
3354 #if DEVELOPMENT || DEBUG
3355 SYSCTL_QUAD(_vm, OID_AUTO, compressor_thread_runtime0, CTLFLAG_RD | CTLFLAG_LOCKED, &vmct_stats.vmct_runtimes[0], "");
3356 SYSCTL_QUAD(_vm, OID_AUTO, compressor_thread_runtime1, CTLFLAG_RD | CTLFLAG_LOCKED, &vmct_stats.vmct_runtimes[1], "");
3357
3358 SYSCTL_QUAD(_vm, OID_AUTO, compressor_threads_total, CTLFLAG_RD | CTLFLAG_LOCKED, &vmct_stats.vmct_cthreads_total, "");
3359
3360 SYSCTL_QUAD(_vm, OID_AUTO, compressor_thread_pages0, CTLFLAG_RD | CTLFLAG_LOCKED, &vmct_stats.vmct_pages[0], "");
3361 SYSCTL_QUAD(_vm, OID_AUTO, compressor_thread_pages1, CTLFLAG_RD | CTLFLAG_LOCKED, &vmct_stats.vmct_pages[1], "");
3362
3363 SYSCTL_QUAD(_vm, OID_AUTO, compressor_thread_iterations0, CTLFLAG_RD | CTLFLAG_LOCKED, &vmct_stats.vmct_iterations[0], "");
3364 SYSCTL_QUAD(_vm, OID_AUTO, compressor_thread_iterations1, CTLFLAG_RD | CTLFLAG_LOCKED, &vmct_stats.vmct_iterations[1], "");
3365
3366 SYSCTL_INT(_vm, OID_AUTO, compressor_thread_minpages0, CTLFLAG_RD | CTLFLAG_LOCKED, &vmct_stats.vmct_minpages[0], 0, "");
3367 SYSCTL_INT(_vm, OID_AUTO, compressor_thread_minpages1, CTLFLAG_RD | CTLFLAG_LOCKED, &vmct_stats.vmct_minpages[1], 0, "");
3368
3369 SYSCTL_INT(_vm, OID_AUTO, compressor_thread_maxpages0, CTLFLAG_RD | CTLFLAG_LOCKED, &vmct_stats.vmct_maxpages[0], 0, "");
3370 SYSCTL_INT(_vm, OID_AUTO, compressor_thread_maxpages1, CTLFLAG_RD | CTLFLAG_LOCKED, &vmct_stats.vmct_maxpages[1], 0, "");
3371
3372 #endif
3373
3374 SYSCTL_QUAD(_vm, OID_AUTO, lz4_compressions, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.lz4_compressions, "");
3375 SYSCTL_QUAD(_vm, OID_AUTO, lz4_compression_failures, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.lz4_compression_failures, "");
3376 SYSCTL_QUAD(_vm, OID_AUTO, lz4_compressed_bytes, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.lz4_compressed_bytes, "");
3377 SYSCTL_QUAD(_vm, OID_AUTO, lz4_wk_compression_delta, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.lz4_wk_compression_delta, "");
3378 SYSCTL_QUAD(_vm, OID_AUTO, lz4_wk_compression_negative_delta, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.lz4_wk_compression_negative_delta, "");
3379
3380 SYSCTL_QUAD(_vm, OID_AUTO, lz4_decompressions, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.lz4_decompressions, "");
3381 SYSCTL_QUAD(_vm, OID_AUTO, lz4_decompressed_bytes, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.lz4_decompressed_bytes, "");
3382
3383 SYSCTL_QUAD(_vm, OID_AUTO, uc_decompressions, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.uc_decompressions, "");
3384
3385 SYSCTL_QUAD(_vm, OID_AUTO, wk_compressions, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wk_compressions, "");
3386
3387 SYSCTL_QUAD(_vm, OID_AUTO, wk_catime, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wk_cabstime, "");
3388
3389 SYSCTL_QUAD(_vm, OID_AUTO, wkh_catime, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wkh_cabstime, "");
3390 SYSCTL_QUAD(_vm, OID_AUTO, wkh_compressions, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wkh_compressions, "");
3391
3392 SYSCTL_QUAD(_vm, OID_AUTO, wks_catime, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wks_cabstime, "");
3393 SYSCTL_QUAD(_vm, OID_AUTO, wks_compressions, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wks_compressions, "");
3394
3395 SYSCTL_QUAD(_vm, OID_AUTO, wk_compressions_exclusive, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wk_compressions_exclusive, "");
3396 SYSCTL_QUAD(_vm, OID_AUTO, wk_sv_compressions, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wk_sv_compressions, "");
3397 SYSCTL_QUAD(_vm, OID_AUTO, wk_mzv_compressions, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wk_mzv_compressions, "");
3398 SYSCTL_QUAD(_vm, OID_AUTO, wk_compression_failures, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wk_compression_failures, "");
3399 SYSCTL_QUAD(_vm, OID_AUTO, wk_compressed_bytes_exclusive, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wk_compressed_bytes_exclusive, "");
3400 SYSCTL_QUAD(_vm, OID_AUTO, wk_compressed_bytes_total, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wk_compressed_bytes_total, "");
3401
3402 SYSCTL_QUAD(_vm, OID_AUTO, wks_compressed_bytes, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wks_compressed_bytes, "");
3403 SYSCTL_QUAD(_vm, OID_AUTO, wks_compression_failures, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wks_compression_failures, "");
3404 SYSCTL_QUAD(_vm, OID_AUTO, wks_sv_compressions, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wks_sv_compressions, "");
3405
3406
3407 SYSCTL_QUAD(_vm, OID_AUTO, wk_decompressions, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wk_decompressions, "");
3408
3409 SYSCTL_QUAD(_vm, OID_AUTO, wk_datime, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wk_dabstime, "");
3410
3411 SYSCTL_QUAD(_vm, OID_AUTO, wkh_datime, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wkh_dabstime, "");
3412 SYSCTL_QUAD(_vm, OID_AUTO, wkh_decompressions, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wkh_decompressions, "");
3413
3414 SYSCTL_QUAD(_vm, OID_AUTO, wks_datime, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wks_dabstime, "");
3415 SYSCTL_QUAD(_vm, OID_AUTO, wks_decompressions, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wks_decompressions, "");
3416
3417 SYSCTL_QUAD(_vm, OID_AUTO, wk_decompressed_bytes, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wk_decompressed_bytes, "");
3418 SYSCTL_QUAD(_vm, OID_AUTO, wk_sv_decompressions, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_stats.wk_sv_decompressions, "");
3419
3420 SYSCTL_INT(_vm, OID_AUTO, lz4_threshold, CTLFLAG_RW | CTLFLAG_LOCKED, &vmctune.lz4_threshold, 0, "");
3421 SYSCTL_INT(_vm, OID_AUTO, wkdm_reeval_threshold, CTLFLAG_RW | CTLFLAG_LOCKED, &vmctune.wkdm_reeval_threshold, 0, "");
3422 SYSCTL_INT(_vm, OID_AUTO, lz4_max_failure_skips, CTLFLAG_RW | CTLFLAG_LOCKED, &vmctune.lz4_max_failure_skips, 0, "");
3423 SYSCTL_INT(_vm, OID_AUTO, lz4_max_failure_run_length, CTLFLAG_RW | CTLFLAG_LOCKED, &vmctune.lz4_max_failure_run_length, 0, "");
3424 SYSCTL_INT(_vm, OID_AUTO, lz4_max_preselects, CTLFLAG_RW | CTLFLAG_LOCKED, &vmctune.lz4_max_preselects, 0, "");
3425 SYSCTL_INT(_vm, OID_AUTO, lz4_run_preselection_threshold, CTLFLAG_RW | CTLFLAG_LOCKED, &vmctune.lz4_run_preselection_threshold, 0, "");
3426 SYSCTL_INT(_vm, OID_AUTO, lz4_run_continue_bytes, CTLFLAG_RW | CTLFLAG_LOCKED, &vmctune.lz4_run_continue_bytes, 0, "");
3427 SYSCTL_INT(_vm, OID_AUTO, lz4_profitable_bytes, CTLFLAG_RW | CTLFLAG_LOCKED, &vmctune.lz4_profitable_bytes, 0, "");
3428 #if DEVELOPMENT || DEBUG
3429 extern int vm_compressor_current_codec;
3430 extern int vm_compressor_test_seg_wp;
3431 extern boolean_t vm_compressor_force_sw_wkdm;
3432 SYSCTL_INT(_vm, OID_AUTO, compressor_codec, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_compressor_current_codec, 0, "");
3433 SYSCTL_INT(_vm, OID_AUTO, compressor_test_wp, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_compressor_test_seg_wp, 0, "");
3434
3435 SYSCTL_INT(_vm, OID_AUTO, wksw_force, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_compressor_force_sw_wkdm, 0, "");
3436 extern int precompy, wkswhw;
3437
3438 SYSCTL_INT(_vm, OID_AUTO, precompy, CTLFLAG_RW | CTLFLAG_LOCKED, &precompy, 0, "");
3439 SYSCTL_INT(_vm, OID_AUTO, wkswhw, CTLFLAG_RW | CTLFLAG_LOCKED, &wkswhw, 0, "");
3440 extern unsigned int vm_ktrace_enabled;
3441 SYSCTL_INT(_vm, OID_AUTO, vm_ktrace, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_ktrace_enabled, 0, "");
3442 #endif
3443
3444 #if CONFIG_PHANTOM_CACHE
3445 extern uint32_t phantom_cache_thrashing_threshold;
3446 extern uint32_t phantom_cache_eval_period_in_msecs;
3447 extern uint32_t phantom_cache_thrashing_threshold_ssd;
3448
3449
3450 SYSCTL_INT(_vm, OID_AUTO, phantom_cache_eval_period_in_msecs, CTLFLAG_RW | CTLFLAG_LOCKED, &phantom_cache_eval_period_in_msecs, 0, "");
3451 SYSCTL_INT(_vm, OID_AUTO, phantom_cache_thrashing_threshold, CTLFLAG_RW | CTLFLAG_LOCKED, &phantom_cache_thrashing_threshold, 0, "");
3452 SYSCTL_INT(_vm, OID_AUTO, phantom_cache_thrashing_threshold_ssd, CTLFLAG_RW | CTLFLAG_LOCKED, &phantom_cache_thrashing_threshold_ssd, 0, "");
3453 #endif
3454
3455 #if CONFIG_BACKGROUND_QUEUE
3456
3457 extern uint32_t vm_page_background_count;
3458 extern uint32_t vm_page_background_target;
3459 extern uint32_t vm_page_background_internal_count;
3460 extern uint32_t vm_page_background_external_count;
3461 extern uint32_t vm_page_background_mode;
3462 extern uint32_t vm_page_background_exclude_external;
3463 extern uint64_t vm_page_background_promoted_count;
3464 extern uint64_t vm_pageout_rejected_bq_internal;
3465 extern uint64_t vm_pageout_rejected_bq_external;
3466
3467 SYSCTL_INT(_vm, OID_AUTO, vm_page_background_mode, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_page_background_mode, 0, "");
3468 SYSCTL_INT(_vm, OID_AUTO, vm_page_background_exclude_external, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_page_background_exclude_external, 0, "");
3469 SYSCTL_INT(_vm, OID_AUTO, vm_page_background_target, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_page_background_target, 0, "");
3470 SYSCTL_INT(_vm, OID_AUTO, vm_page_background_count, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_background_count, 0, "");
3471 SYSCTL_INT(_vm, OID_AUTO, vm_page_background_internal_count, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_background_internal_count, 0, "");
3472 SYSCTL_INT(_vm, OID_AUTO, vm_page_background_external_count, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_background_external_count, 0, "");
3473
3474 SYSCTL_QUAD(_vm, OID_AUTO, vm_page_background_promoted_count, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_background_promoted_count, "");
3475 SYSCTL_QUAD(_vm, OID_AUTO, vm_pageout_considered_bq_internal, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_vminfo.vm_pageout_considered_bq_internal, "");
3476 SYSCTL_QUAD(_vm, OID_AUTO, vm_pageout_considered_bq_external, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_vminfo.vm_pageout_considered_bq_external, "");
3477 SYSCTL_QUAD(_vm, OID_AUTO, vm_pageout_rejected_bq_internal, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_rejected_bq_internal, "");
3478 SYSCTL_QUAD(_vm, OID_AUTO, vm_pageout_rejected_bq_external, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_pageout_rejected_bq_external, "");
3479
3480 #endif /* CONFIG_BACKGROUND_QUEUE */
3481
3482 extern void vm_update_darkwake_mode(boolean_t);
3483 extern boolean_t vm_darkwake_mode;
3484
3485 STATIC int
3486 sysctl_toggle_darkwake_mode(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
3487 {
3488 int new_value, changed;
3489 int error = sysctl_io_number(req, vm_darkwake_mode, sizeof(int), &new_value, &changed);
3490
3491 if ( !error && changed) {
3492
3493 if (new_value != 0 && new_value != 1) {
3494 printf("Error: Invalid value passed to darkwake sysctl. Acceptable: 0 or 1.\n");
3495 error = EINVAL;
3496 } else {
3497 vm_update_darkwake_mode((boolean_t) new_value);
3498 }
3499 }
3500
3501 return(error);
3502 }
3503
3504 SYSCTL_PROC(_vm, OID_AUTO, darkwake_mode,
3505 CTLTYPE_INT | CTLFLAG_LOCKED | CTLFLAG_RW,
3506 0, 0, sysctl_toggle_darkwake_mode, "I", "");
3507
3508 #if (DEVELOPMENT || DEBUG)
3509
3510 SYSCTL_UINT(_vm, OID_AUTO, vm_page_creation_throttled_hard,
3511 CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
3512 &vm_page_creation_throttled_hard, 0, "");
3513
3514 SYSCTL_UINT(_vm, OID_AUTO, vm_page_creation_throttled_soft,
3515 CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
3516 &vm_page_creation_throttled_soft, 0, "");
3517
3518 extern uint32_t vm_pageout_memorystatus_fb_factor_nr;
3519 extern uint32_t vm_pageout_memorystatus_fb_factor_dr;
3520 SYSCTL_INT(_vm, OID_AUTO, vm_pageout_memorystatus_fb_factor_nr, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_pageout_memorystatus_fb_factor_nr, 0, "");
3521 SYSCTL_INT(_vm, OID_AUTO, vm_pageout_memorystatus_fb_factor_dr, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_pageout_memorystatus_fb_factor_dr, 0, "");
3522
3523
3524 SYSCTL_INT(_vm, OID_AUTO, vm_grab_anon_overrides, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_pageout_debug.vm_grab_anon_overrides, 0, "");
3525 SYSCTL_INT(_vm, OID_AUTO, vm_grab_anon_nops, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_pageout_debug.vm_grab_anon_nops, 0, "");
3526
3527 /* log message counters for persistence mode */
3528 extern uint32_t oslog_p_total_msgcount;
3529 extern uint32_t oslog_p_metadata_saved_msgcount;
3530 extern uint32_t oslog_p_metadata_dropped_msgcount;
3531 extern uint32_t oslog_p_error_count;
3532 extern uint32_t oslog_p_saved_msgcount;
3533 extern uint32_t oslog_p_dropped_msgcount;
3534 extern uint32_t oslog_p_boot_dropped_msgcount;
3535
3536 /* log message counters for streaming mode */
3537 extern uint32_t oslog_s_total_msgcount;
3538 extern uint32_t oslog_s_metadata_msgcount;
3539 extern uint32_t oslog_s_error_count;
3540 extern uint32_t oslog_s_streamed_msgcount;
3541 extern uint32_t oslog_s_dropped_msgcount;
3542
3543 SYSCTL_UINT(_debug, OID_AUTO, oslog_p_total_msgcount, CTLFLAG_ANYBODY | CTLFLAG_RD | CTLFLAG_LOCKED, &oslog_p_total_msgcount, 0, "");
3544 SYSCTL_UINT(_debug, OID_AUTO, oslog_p_metadata_saved_msgcount, CTLFLAG_ANYBODY | CTLFLAG_RD | CTLFLAG_LOCKED, &oslog_p_metadata_saved_msgcount, 0, "");
3545 SYSCTL_UINT(_debug, OID_AUTO, oslog_p_metadata_dropped_msgcount, CTLFLAG_ANYBODY | CTLFLAG_RD | CTLFLAG_LOCKED, &oslog_p_metadata_dropped_msgcount, 0, "");
3546 SYSCTL_UINT(_debug, OID_AUTO, oslog_p_error_count, CTLFLAG_ANYBODY | CTLFLAG_RD | CTLFLAG_LOCKED, &oslog_p_error_count, 0, "");
3547 SYSCTL_UINT(_debug, OID_AUTO, oslog_p_saved_msgcount, CTLFLAG_ANYBODY | CTLFLAG_RD | CTLFLAG_LOCKED, &oslog_p_saved_msgcount, 0, "");
3548 SYSCTL_UINT(_debug, OID_AUTO, oslog_p_dropped_msgcount, CTLFLAG_ANYBODY | CTLFLAG_RD | CTLFLAG_LOCKED, &oslog_p_dropped_msgcount, 0, "");
3549 SYSCTL_UINT(_debug, OID_AUTO, oslog_p_boot_dropped_msgcount, CTLFLAG_ANYBODY | CTLFLAG_RD | CTLFLAG_LOCKED, &oslog_p_boot_dropped_msgcount, 0, "");
3550
3551 SYSCTL_UINT(_debug, OID_AUTO, oslog_s_total_msgcount, CTLFLAG_ANYBODY | CTLFLAG_RD | CTLFLAG_LOCKED, &oslog_s_total_msgcount, 0, "");
3552 SYSCTL_UINT(_debug, OID_AUTO, oslog_s_metadata_msgcount, CTLFLAG_ANYBODY | CTLFLAG_RD | CTLFLAG_LOCKED, &oslog_s_metadata_msgcount, 0, "");
3553 SYSCTL_UINT(_debug, OID_AUTO, oslog_s_error_count, CTLFLAG_ANYBODY | CTLFLAG_RD | CTLFLAG_LOCKED, &oslog_s_error_count, 0, "");
3554 SYSCTL_UINT(_debug, OID_AUTO, oslog_s_streamed_msgcount, CTLFLAG_ANYBODY | CTLFLAG_RD | CTLFLAG_LOCKED, &oslog_s_streamed_msgcount, 0, "");
3555 SYSCTL_UINT(_debug, OID_AUTO, oslog_s_dropped_msgcount, CTLFLAG_ANYBODY | CTLFLAG_RD | CTLFLAG_LOCKED, &oslog_s_dropped_msgcount, 0, "");
3556
3557
3558 #endif /* DEVELOPMENT || DEBUG */
3559
3560 /*
3561 * Enable tracing of voucher contents
3562 */
3563 extern uint32_t ipc_voucher_trace_contents;
3564
3565 SYSCTL_INT (_kern, OID_AUTO, ipc_voucher_trace_contents,
3566 CTLFLAG_RW | CTLFLAG_LOCKED, &ipc_voucher_trace_contents, 0, "Enable tracing voucher contents");
3567
3568 /*
3569 * Kernel stack size and depth
3570 */
3571 SYSCTL_INT (_kern, OID_AUTO, stack_size,
3572 CTLFLAG_RD | CTLFLAG_LOCKED, (int *) &kernel_stack_size, 0, "Kernel stack size");
3573 SYSCTL_INT (_kern, OID_AUTO, stack_depth_max,
3574 CTLFLAG_RD | CTLFLAG_LOCKED, (int *) &kernel_stack_depth_max, 0, "Max kernel stack depth at interrupt or context switch");
3575
3576 extern unsigned int kern_feature_overrides;
3577 SYSCTL_INT (_kern, OID_AUTO, kern_feature_overrides,
3578 CTLFLAG_RD | CTLFLAG_LOCKED, &kern_feature_overrides, 0, "Kernel feature override mask");
3579
3580 /*
3581 * enable back trace for port allocations
3582 */
3583 extern int ipc_portbt;
3584
3585 SYSCTL_INT(_kern, OID_AUTO, ipc_portbt,
3586 CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
3587 &ipc_portbt, 0, "");
3588
3589 /*
3590 * Scheduler sysctls
3591 */
3592
3593 SYSCTL_STRING(_kern, OID_AUTO, sched,
3594 CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
3595 sched_string, sizeof(sched_string),
3596 "Timeshare scheduler implementation");
3597
3598 #if CONFIG_QUIESCE_COUNTER
3599 static int
3600 sysctl_cpu_quiescent_counter_interval SYSCTL_HANDLER_ARGS
3601 {
3602 #pragma unused(arg1, arg2)
3603
3604 int error = sysctl_handle_int(oidp, &cpu_checkin_min_interval_us, 0, req);
3605 if (error || !req->newptr)
3606 return error;
3607
3608 cpu_quiescent_counter_set_min_interval_us(cpu_checkin_min_interval_us);
3609
3610 return 0;
3611 }
3612
3613 SYSCTL_PROC(_kern, OID_AUTO, cpu_checkin_interval,
3614 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
3615 0, 0,
3616 sysctl_cpu_quiescent_counter_interval, "I",
3617 "Quiescent CPU checkin interval (microseconds)");
3618 #endif /* CONFIG_QUIESCE_COUNTER */
3619
3620
3621 /*
3622 * Only support runtime modification on embedded platforms
3623 * with development config enabled
3624 */
3625 #if CONFIG_EMBEDDED
3626 #if !SECURE_KERNEL
3627 extern int precise_user_kernel_time;
3628 SYSCTL_INT(_kern, OID_AUTO, precise_user_kernel_time,
3629 CTLFLAG_RW | CTLFLAG_LOCKED,
3630 &precise_user_kernel_time, 0, "Precise accounting of kernel vs. user time");
3631 #endif
3632 #endif
3633
3634
3635 /* Parameters related to timer coalescing tuning, to be replaced
3636 * with a dedicated systemcall in the future.
3637 */
3638 /* Enable processing pending timers in the context of any other interrupt
3639 * Coalescing tuning parameters for various thread/task attributes */
3640 STATIC int
3641 sysctl_timer_user_us_kernel_abstime SYSCTL_HANDLER_ARGS
3642 {
3643 #pragma unused(oidp)
3644 int size = arg2; /* subcommand*/
3645 int error;
3646 int changed = 0;
3647 uint64_t old_value_ns;
3648 uint64_t new_value_ns;
3649 uint64_t value_abstime;
3650 if (size == sizeof(uint32_t))
3651 value_abstime = *((uint32_t *)arg1);
3652 else if (size == sizeof(uint64_t))
3653 value_abstime = *((uint64_t *)arg1);
3654 else return ENOTSUP;
3655
3656 absolutetime_to_nanoseconds(value_abstime, &old_value_ns);
3657 error = sysctl_io_number(req, old_value_ns, sizeof(old_value_ns), &new_value_ns, &changed);
3658 if ((error) || (!changed))
3659 return error;
3660
3661 nanoseconds_to_absolutetime(new_value_ns, &value_abstime);
3662 if (size == sizeof(uint32_t))
3663 *((uint32_t *)arg1) = (uint32_t)value_abstime;
3664 else
3665 *((uint64_t *)arg1) = value_abstime;
3666 return error;
3667 }
3668
3669 SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_bg_scale,
3670 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3671 &tcoal_prio_params.timer_coalesce_bg_shift, 0, "");
3672 SYSCTL_PROC(_kern, OID_AUTO, timer_resort_threshold_ns,
3673 CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3674 &tcoal_prio_params.timer_resort_threshold_abstime,
3675 sizeof(tcoal_prio_params.timer_resort_threshold_abstime),
3676 sysctl_timer_user_us_kernel_abstime,
3677 "Q", "");
3678 SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_bg_ns_max,
3679 CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3680 &tcoal_prio_params.timer_coalesce_bg_abstime_max,
3681 sizeof(tcoal_prio_params.timer_coalesce_bg_abstime_max),
3682 sysctl_timer_user_us_kernel_abstime,
3683 "Q", "");
3684
3685 SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_kt_scale,
3686 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3687 &tcoal_prio_params.timer_coalesce_kt_shift, 0, "");
3688
3689 SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_kt_ns_max,
3690 CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3691 &tcoal_prio_params.timer_coalesce_kt_abstime_max,
3692 sizeof(tcoal_prio_params.timer_coalesce_kt_abstime_max),
3693 sysctl_timer_user_us_kernel_abstime,
3694 "Q", "");
3695
3696 SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_fp_scale,
3697 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3698 &tcoal_prio_params.timer_coalesce_fp_shift, 0, "");
3699
3700 SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_fp_ns_max,
3701 CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3702 &tcoal_prio_params.timer_coalesce_fp_abstime_max,
3703 sizeof(tcoal_prio_params.timer_coalesce_fp_abstime_max),
3704 sysctl_timer_user_us_kernel_abstime,
3705 "Q", "");
3706
3707 SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_ts_scale,
3708 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3709 &tcoal_prio_params.timer_coalesce_ts_shift, 0, "");
3710
3711 SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_ts_ns_max,
3712 CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3713 &tcoal_prio_params.timer_coalesce_ts_abstime_max,
3714 sizeof(tcoal_prio_params.timer_coalesce_ts_abstime_max),
3715 sysctl_timer_user_us_kernel_abstime,
3716 "Q", "");
3717
3718 SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_tier0_scale,
3719 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3720 &tcoal_prio_params.latency_qos_scale[0], 0, "");
3721
3722 SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_tier0_ns_max,
3723 CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3724 &tcoal_prio_params.latency_qos_abstime_max[0],
3725 sizeof(tcoal_prio_params.latency_qos_abstime_max[0]),
3726 sysctl_timer_user_us_kernel_abstime,
3727 "Q", "");
3728
3729 SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_tier1_scale,
3730 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3731 &tcoal_prio_params.latency_qos_scale[1], 0, "");
3732
3733 SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_tier1_ns_max,
3734 CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3735 &tcoal_prio_params.latency_qos_abstime_max[1],
3736 sizeof(tcoal_prio_params.latency_qos_abstime_max[1]),
3737 sysctl_timer_user_us_kernel_abstime,
3738 "Q", "");
3739
3740 SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_tier2_scale,
3741 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3742 &tcoal_prio_params.latency_qos_scale[2], 0, "");
3743
3744 SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_tier2_ns_max,
3745 CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3746 &tcoal_prio_params.latency_qos_abstime_max[2],
3747 sizeof(tcoal_prio_params.latency_qos_abstime_max[2]),
3748 sysctl_timer_user_us_kernel_abstime,
3749 "Q", "");
3750
3751 SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_tier3_scale,
3752 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3753 &tcoal_prio_params.latency_qos_scale[3], 0, "");
3754
3755 SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_tier3_ns_max,
3756 CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3757 &tcoal_prio_params.latency_qos_abstime_max[3],
3758 sizeof(tcoal_prio_params.latency_qos_abstime_max[3]),
3759 sysctl_timer_user_us_kernel_abstime,
3760 "Q", "");
3761
3762 SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_tier4_scale,
3763 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3764 &tcoal_prio_params.latency_qos_scale[4], 0, "");
3765
3766 SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_tier4_ns_max,
3767 CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3768 &tcoal_prio_params.latency_qos_abstime_max[4],
3769 sizeof(tcoal_prio_params.latency_qos_abstime_max[4]),
3770 sysctl_timer_user_us_kernel_abstime,
3771 "Q", "");
3772
3773 SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_tier5_scale,
3774 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3775 &tcoal_prio_params.latency_qos_scale[5], 0, "");
3776
3777 SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_tier5_ns_max,
3778 CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
3779 &tcoal_prio_params.latency_qos_abstime_max[5],
3780 sizeof(tcoal_prio_params.latency_qos_abstime_max[5]),
3781 sysctl_timer_user_us_kernel_abstime,
3782 "Q", "");
3783
3784 /* Communicate the "user idle level" heuristic to the timer layer, and
3785 * potentially other layers in the future.
3786 */
3787
3788 static int
3789 timer_user_idle_level(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req) {
3790 int new_value = 0, old_value = 0, changed = 0, error;
3791
3792 old_value = timer_get_user_idle_level();
3793
3794 error = sysctl_io_number(req, old_value, sizeof(int), &new_value, &changed);
3795
3796 if (error == 0 && changed) {
3797 if (timer_set_user_idle_level(new_value) != KERN_SUCCESS)
3798 error = ERANGE;
3799 }
3800
3801 return error;
3802 }
3803
3804 SYSCTL_PROC(_machdep, OID_AUTO, user_idle_level,
3805 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
3806 0, 0,
3807 timer_user_idle_level, "I", "User idle level heuristic, 0-128");
3808
3809 #if HYPERVISOR
3810 SYSCTL_INT(_kern, OID_AUTO, hv_support,
3811 CTLFLAG_KERN | CTLFLAG_RD | CTLFLAG_LOCKED,
3812 &hv_support_available, 0, "");
3813 #endif
3814
3815 #if CONFIG_EMBEDDED
3816 STATIC int
3817 sysctl_darkboot SYSCTL_HANDLER_ARGS
3818 {
3819 int err = 0, value = 0;
3820 #pragma unused(oidp, arg1, arg2, err, value, req)
3821
3822 /*
3823 * Handle the sysctl request.
3824 *
3825 * If this is a read, the function will set the value to the current darkboot value. Otherwise,
3826 * we'll get the request identifier into "value" and then we can honor it.
3827 */
3828 if ((err = sysctl_io_number(req, darkboot, sizeof(int), &value, NULL)) != 0) {
3829 goto exit;
3830 }
3831
3832 /* writing requested, let's process the request */
3833 if (req->newptr) {
3834 /* writing is protected by an entitlement */
3835 if (priv_check_cred(kauth_cred_get(), PRIV_DARKBOOT, 0) != 0) {
3836 err = EPERM;
3837 goto exit;
3838 }
3839
3840 switch (value) {
3841 case MEMORY_MAINTENANCE_DARK_BOOT_UNSET:
3842 /*
3843 * If the darkboot sysctl is unset, the NVRAM variable
3844 * must be unset too. If that's not the case, it means
3845 * someone is doing something crazy and not supported.
3846 */
3847 if (darkboot != 0) {
3848 int ret = PERemoveNVRAMProperty(MEMORY_MAINTENANCE_DARK_BOOT_NVRAM_NAME);
3849 if (ret) {
3850 darkboot = 0;
3851 } else {
3852 err = EINVAL;
3853 }
3854 }
3855 break;
3856 case MEMORY_MAINTENANCE_DARK_BOOT_SET:
3857 darkboot = 1;
3858 break;
3859 case MEMORY_MAINTENANCE_DARK_BOOT_SET_PERSISTENT: {
3860 /*
3861 * Set the NVRAM and update 'darkboot' in case
3862 * of success. Otherwise, do not update
3863 * 'darkboot' and report the failure.
3864 */
3865 if (PEWriteNVRAMBooleanProperty(MEMORY_MAINTENANCE_DARK_BOOT_NVRAM_NAME, TRUE)) {
3866 darkboot = 1;
3867 } else {
3868 err = EINVAL;
3869 }
3870
3871 break;
3872 }
3873 default:
3874 err = EINVAL;
3875 }
3876 }
3877
3878 exit:
3879 return err;
3880 }
3881
3882 SYSCTL_PROC(_kern, OID_AUTO, darkboot,
3883 CTLFLAG_KERN | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED | CTLFLAG_ANYBODY,
3884 0, 0, sysctl_darkboot, "I", "");
3885 #endif
3886
3887 #if DEVELOPMENT || DEBUG
3888 #include <sys/sysent.h>
3889 /* This should result in a fatal exception, verifying that "sysent" is
3890 * write-protected.
3891 */
3892 static int
3893 kern_sysent_write(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req) {
3894 uint64_t new_value = 0, old_value = 0;
3895 int changed = 0, error;
3896
3897 error = sysctl_io_number(req, old_value, sizeof(uint64_t), &new_value, &changed);
3898 if ((error == 0) && changed) {
3899 volatile uint32_t *wraddr = (uint32_t *) &sysent[0];
3900 *wraddr = 0;
3901 printf("sysent[0] write succeeded\n");
3902 }
3903 return error;
3904 }
3905
3906 SYSCTL_PROC(_kern, OID_AUTO, sysent_const_check,
3907 CTLTYPE_QUAD | CTLFLAG_RW | CTLFLAG_LOCKED,
3908 0, 0,
3909 kern_sysent_write, "I", "Attempt sysent[0] write");
3910
3911 #endif
3912
3913 #if DEVELOPMENT || DEBUG
3914 SYSCTL_COMPAT_INT(_kern, OID_AUTO, development, CTLFLAG_RD | CTLFLAG_MASKED, NULL, 1, "");
3915 #else
3916 SYSCTL_COMPAT_INT(_kern, OID_AUTO, development, CTLFLAG_RD | CTLFLAG_MASKED, NULL, 0, "");
3917 #endif
3918
3919
3920 #if DEVELOPMENT || DEBUG
3921
3922 static int
3923 sysctl_panic_test SYSCTL_HANDLER_ARGS
3924 {
3925 #pragma unused(arg1, arg2)
3926 int rval = 0;
3927 char str[32] = "entry prelog postlog postcore";
3928
3929 rval = sysctl_handle_string(oidp, str, sizeof(str), req);
3930
3931 if (rval == 0 && req->newptr) {
3932 if (strncmp("entry", str, strlen("entry")) == 0) {
3933 panic_with_options(0, NULL, DEBUGGER_OPTION_RECURPANIC_ENTRY, "test recursive panic at entry");
3934 } else if (strncmp("prelog", str, strlen("prelog")) == 0) {
3935 panic_with_options(0, NULL, DEBUGGER_OPTION_RECURPANIC_PRELOG, "test recursive panic prior to writing a paniclog");
3936 } else if (strncmp("postlog", str, strlen("postlog")) == 0) {
3937 panic_with_options(0, NULL, DEBUGGER_OPTION_RECURPANIC_POSTLOG, "test recursive panic subsequent to paniclog");
3938 } else if (strncmp("postcore", str, strlen("postcore")) == 0) {
3939 panic_with_options(0, NULL, DEBUGGER_OPTION_RECURPANIC_POSTCORE, "test recursive panic subsequent to on-device core");
3940 }
3941 }
3942
3943 return rval;
3944 }
3945
3946 static int
3947 sysctl_debugger_test SYSCTL_HANDLER_ARGS
3948 {
3949 #pragma unused(arg1, arg2)
3950 int rval = 0;
3951 char str[32] = "entry prelog postlog postcore";
3952
3953 rval = sysctl_handle_string(oidp, str, sizeof(str), req);
3954
3955 if (rval == 0 && req->newptr) {
3956 if (strncmp("entry", str, strlen("entry")) == 0) {
3957 DebuggerWithContext(0, NULL, "test recursive panic via debugger at entry", DEBUGGER_OPTION_RECURPANIC_ENTRY);
3958 } else if (strncmp("prelog", str, strlen("prelog")) == 0) {
3959 DebuggerWithContext(0, NULL, "test recursive panic via debugger prior to writing a paniclog", DEBUGGER_OPTION_RECURPANIC_PRELOG);
3960 } else if (strncmp("postlog", str, strlen("postlog")) == 0) {
3961 DebuggerWithContext(0, NULL, "test recursive panic via debugger subsequent to paniclog", DEBUGGER_OPTION_RECURPANIC_POSTLOG);
3962 } else if (strncmp("postcore", str, strlen("postcore")) == 0) {
3963 DebuggerWithContext(0, NULL, "test recursive panic via debugger subsequent to on-device core", DEBUGGER_OPTION_RECURPANIC_POSTCORE);
3964 }
3965 }
3966
3967 return rval;
3968 }
3969
3970 decl_lck_spin_data(, spinlock_panic_test_lock)
3971
3972 __attribute__((noreturn))
3973 static void
3974 spinlock_panic_test_acquire_spinlock(void * arg __unused, wait_result_t wres __unused)
3975 {
3976 lck_spin_lock(&spinlock_panic_test_lock);
3977 while (1) { ; }
3978 }
3979
3980 static int
3981 sysctl_spinlock_panic_test SYSCTL_HANDLER_ARGS
3982 {
3983 #pragma unused(oidp, arg1, arg2)
3984 if (req->newlen == 0)
3985 return EINVAL;
3986
3987 thread_t panic_spinlock_thread;
3988 /* Initialize panic spinlock */
3989 lck_grp_t * panic_spinlock_grp;
3990 lck_grp_attr_t * panic_spinlock_grp_attr;
3991 lck_attr_t * panic_spinlock_attr;
3992
3993 panic_spinlock_grp_attr = lck_grp_attr_alloc_init();
3994 panic_spinlock_grp = lck_grp_alloc_init("panic_spinlock", panic_spinlock_grp_attr);
3995 panic_spinlock_attr = lck_attr_alloc_init();
3996
3997 lck_spin_init(&spinlock_panic_test_lock, panic_spinlock_grp, panic_spinlock_attr);
3998
3999
4000 /* Create thread to acquire spinlock */
4001 if (kernel_thread_start(spinlock_panic_test_acquire_spinlock, NULL, &panic_spinlock_thread) != KERN_SUCCESS) {
4002 return EBUSY;
4003 }
4004
4005 /* Try to acquire spinlock -- should panic eventually */
4006 lck_spin_lock(&spinlock_panic_test_lock);
4007 while(1) { ; }
4008 }
4009
4010 __attribute__((noreturn))
4011 static void
4012 simultaneous_panic_worker
4013 (void * arg, wait_result_t wres __unused)
4014 {
4015 atomic_int *start_panic = (atomic_int *)arg;
4016
4017 while (!atomic_load(start_panic)) { ; }
4018 panic("SIMULTANEOUS PANIC TEST: INITIATING PANIC FROM CPU %d", cpu_number());
4019 __builtin_unreachable();
4020 }
4021
4022 static int
4023 sysctl_simultaneous_panic_test SYSCTL_HANDLER_ARGS
4024 {
4025 #pragma unused(oidp, arg1, arg2)
4026 if (req->newlen == 0)
4027 return EINVAL;
4028
4029 int i = 0, threads_to_create = 2 * processor_count;
4030 atomic_int start_panic = 0;
4031 unsigned int threads_created = 0;
4032 thread_t new_panic_thread;
4033
4034 for (i = threads_to_create; i > 0; i--) {
4035 if (kernel_thread_start(simultaneous_panic_worker, (void *) &start_panic, &new_panic_thread) == KERN_SUCCESS) {
4036 threads_created++;
4037 }
4038 }
4039
4040 /* FAIL if we couldn't create at least processor_count threads */
4041 if (threads_created < processor_count) {
4042 panic("SIMULTANEOUS PANIC TEST: FAILED TO CREATE ENOUGH THREADS, ONLY CREATED %d (of %d)",
4043 threads_created, threads_to_create);
4044 }
4045
4046 atomic_exchange(&start_panic, 1);
4047 while (1) { ; }
4048 }
4049
4050 SYSCTL_PROC(_debug, OID_AUTO, panic_test, CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_MASKED, 0, 0, sysctl_panic_test, "A", "panic test");
4051 SYSCTL_PROC(_debug, OID_AUTO, debugger_test, CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_MASKED, 0, 0, sysctl_debugger_test, "A", "debugger test");
4052 SYSCTL_PROC(_debug, OID_AUTO, spinlock_panic_test, CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_MASKED, 0, 0, sysctl_spinlock_panic_test, "A", "spinlock panic test");
4053 SYSCTL_PROC(_debug, OID_AUTO, simultaneous_panic_test, CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_MASKED, 0, 0, sysctl_simultaneous_panic_test, "A", "simultaneous panic test");
4054
4055 extern int exc_resource_threads_enabled;
4056
4057 SYSCTL_INT(_kern, OID_AUTO, exc_resource_threads_enabled, CTLFLAG_RD | CTLFLAG_LOCKED, &exc_resource_threads_enabled, 0, "exc_resource thread limit enabled");
4058
4059
4060 #endif /* DEVELOPMENT || DEBUG */
4061
4062 const uint32_t thread_groups_supported = 0;
4063
4064 STATIC int
4065 sysctl_thread_groups_supported (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
4066 {
4067 int value = thread_groups_supported;
4068 return sysctl_io_number(req, value, sizeof(value), NULL, NULL);
4069 }
4070
4071 SYSCTL_PROC(_kern, OID_AUTO, thread_groups_supported, CTLFLAG_RD | CTLFLAG_LOCKED | CTLFLAG_KERN,
4072 0, 0, &sysctl_thread_groups_supported, "I", "thread groups supported");
4073
4074 static int
4075 sysctl_grade_cputype SYSCTL_HANDLER_ARGS
4076 {
4077 #pragma unused(arg1, arg2, oidp)
4078 int error = 0;
4079 int type_tuple[2] = {};
4080 int return_value = 0;
4081
4082 error = SYSCTL_IN(req, &type_tuple, sizeof(type_tuple));
4083
4084 if (error) {
4085 return error;
4086 }
4087
4088 return_value = grade_binary(type_tuple[0], type_tuple[1]);
4089
4090 error = SYSCTL_OUT(req, &return_value, sizeof(return_value));
4091
4092 if (error) {
4093 return error;
4094 }
4095
4096 return error;
4097 }
4098
4099 SYSCTL_PROC(_kern, OID_AUTO, grade_cputype,
4100 CTLFLAG_RW|CTLFLAG_ANYBODY|CTLFLAG_MASKED|CTLFLAG_LOCKED|CTLTYPE_OPAQUE,
4101 0, 0, &sysctl_grade_cputype, "S",
4102 "grade value of cpu_type_t+cpu_sub_type_t");
4103
4104
4105 #if DEVELOPMENT || DEBUG
4106
4107 static atomic_int wedge_thread_should_wake = 0;
4108
4109 static int
4110 unwedge_thread SYSCTL_HANDLER_ARGS
4111 {
4112 #pragma unused(arg1, arg2)
4113 int error, val = 0;
4114 error = sysctl_handle_int(oidp, &val, 0, req);
4115 if (error || val == 0) {
4116 return error;
4117 }
4118
4119 atomic_store(&wedge_thread_should_wake, 1);
4120 return 0;
4121 }
4122
4123 SYSCTL_PROC(_kern, OID_AUTO, unwedge_thread, CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_LOCKED, 0, 0, unwedge_thread, "I", "unwedge the thread wedged by kern.wedge_thread");
4124
4125 extern uintptr_t phys_carveout_pa;
4126 SYSCTL_LONG(_kern, OID_AUTO, phys_carveout_pa, CTLFLAG_RD | CTLFLAG_LOCKED,
4127 &phys_carveout_pa,
4128 "base physical address of the phys_carveout_mb boot-arg region");
4129 extern size_t phys_carveout_size;
4130 SYSCTL_LONG(_kern, OID_AUTO, phys_carveout_size, CTLFLAG_RD | CTLFLAG_LOCKED,
4131 &phys_carveout_size,
4132 "size in bytes of the phys_carveout_mb boot-arg region");
4133
4134 static int
4135 wedge_thread SYSCTL_HANDLER_ARGS
4136 {
4137 #pragma unused(arg1, arg2)
4138
4139 int error, val = 0;
4140 error = sysctl_handle_int(oidp, &val, 0, req);
4141 if (error || val == 0) {
4142 return error;
4143 }
4144
4145 uint64_t interval = 1;
4146 nanoseconds_to_absolutetime(1000 * 1000 * 50, &interval);
4147
4148 atomic_store(&wedge_thread_should_wake, 0);
4149 while (!atomic_load(&wedge_thread_should_wake)) {
4150 tsleep1(NULL, 0, "wedge_thread", mach_absolute_time()+interval, NULL);
4151 }
4152
4153 return 0;
4154 }
4155
4156 SYSCTL_PROC(_kern, OID_AUTO, wedge_thread, CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_LOCKED, 0, 0, wedge_thread, "I", "wedge this thread so it cannot be cleaned up");
4157
4158 static int
4159 sysctl_turnstile_test_prim_lock SYSCTL_HANDLER_ARGS;
4160 static int
4161 sysctl_turnstile_test_prim_unlock SYSCTL_HANDLER_ARGS;
4162 int
4163 tstile_test_prim_lock(boolean_t use_hashtable);
4164 int
4165 tstile_test_prim_unlock(boolean_t use_hashtable);
4166
4167 #define SYSCTL_TURNSTILE_TEST_DEFAULT 1
4168 #define SYSCTL_TURNSTILE_TEST_GLOBAL_HASHTABLE 2
4169
4170 static int
4171 sysctl_turnstile_test_prim_lock SYSCTL_HANDLER_ARGS
4172 {
4173 #pragma unused(arg1, arg2)
4174 int error, val = 0;
4175 error = sysctl_handle_int(oidp, &val, 0, req);
4176 if (error || val == 0) {
4177 return error;
4178 }
4179 boolean_t use_hashtable = (val == SYSCTL_TURNSTILE_TEST_GLOBAL_HASHTABLE) ? true : false;
4180 return tstile_test_prim_lock(use_hashtable);
4181 }
4182
4183 static int
4184 sysctl_turnstile_test_prim_unlock SYSCTL_HANDLER_ARGS
4185 {
4186 #pragma unused(arg1, arg2)
4187 int error, val = 0;
4188 error = sysctl_handle_int(oidp, &val, 0, req);
4189 if (error || val == 0) {
4190 return error;
4191 }
4192 boolean_t use_hashtable = (val == SYSCTL_TURNSTILE_TEST_GLOBAL_HASHTABLE) ? true : false;
4193 return tstile_test_prim_unlock(use_hashtable);
4194 }
4195
4196 SYSCTL_PROC(_kern, OID_AUTO, turnstiles_test_lock, CTLFLAG_WR | CTLFLAG_ANYBODY | CTLFLAG_KERN | CTLFLAG_LOCKED,
4197 0, 0, sysctl_turnstile_test_prim_lock, "I", "turnstiles test lock");
4198
4199 SYSCTL_PROC(_kern, OID_AUTO, turnstiles_test_unlock, CTLFLAG_WR | CTLFLAG_ANYBODY | CTLFLAG_KERN | CTLFLAG_LOCKED,
4200 0, 0, sysctl_turnstile_test_prim_unlock, "I", "turnstiles test unlock");
4201
4202 int
4203 turnstile_get_boost_stats_sysctl(void *req);
4204 int
4205 turnstile_get_unboost_stats_sysctl(void *req);
4206 static int
4207 sysctl_turnstile_boost_stats SYSCTL_HANDLER_ARGS;
4208 static int
4209 sysctl_turnstile_unboost_stats SYSCTL_HANDLER_ARGS;
4210 extern uint64_t thread_block_on_turnstile_count;
4211 extern uint64_t thread_block_on_regular_waitq_count;
4212
4213 static int
4214 sysctl_turnstile_boost_stats SYSCTL_HANDLER_ARGS
4215 {
4216 #pragma unused(arg1, arg2, oidp)
4217 return turnstile_get_boost_stats_sysctl(req);
4218 }
4219
4220 static int
4221 sysctl_turnstile_unboost_stats SYSCTL_HANDLER_ARGS
4222 {
4223 #pragma unused(arg1, arg2, oidp)
4224 return turnstile_get_unboost_stats_sysctl(req);
4225 }
4226
4227 SYSCTL_PROC(_kern, OID_AUTO, turnstile_boost_stats, CTLFLAG_RD | CTLFLAG_ANYBODY | CTLFLAG_KERN | CTLFLAG_LOCKED | CTLTYPE_STRUCT,
4228 0, 0, sysctl_turnstile_boost_stats, "S", "turnstiles boost stats");
4229 SYSCTL_PROC(_kern, OID_AUTO, turnstile_unboost_stats, CTLFLAG_RD | CTLFLAG_ANYBODY | CTLFLAG_KERN | CTLFLAG_LOCKED | CTLTYPE_STRUCT,
4230 0, 0, sysctl_turnstile_unboost_stats, "S", "turnstiles unboost stats");
4231 SYSCTL_QUAD(_kern, OID_AUTO, thread_block_count_on_turnstile,
4232 CTLFLAG_RD | CTLFLAG_ANYBODY | CTLFLAG_KERN | CTLFLAG_LOCKED,
4233 &thread_block_on_turnstile_count, "thread blocked on turnstile count");
4234 SYSCTL_QUAD(_kern, OID_AUTO, thread_block_count_on_reg_waitq,
4235 CTLFLAG_RD | CTLFLAG_ANYBODY | CTLFLAG_KERN | CTLFLAG_LOCKED,
4236 &thread_block_on_regular_waitq_count, "thread blocked on regular waitq count");
4237
4238 static int
4239 sysctl_lck_mtx_test_lock SYSCTL_HANDLER_ARGS
4240 {
4241 #pragma unused(arg1, arg2)
4242 int error, val = 0;
4243 error = sysctl_handle_int(oidp, &val, 0, req);
4244 if (error || val == 0) {
4245 return error;
4246 }
4247
4248 if (val == 1) {
4249 lck_mtx_test_init();
4250 lck_mtx_test_lock();
4251 }
4252
4253 return 0;
4254 }
4255
4256 static int
4257 sysctl_lck_mtx_test_unlock SYSCTL_HANDLER_ARGS
4258 {
4259 #pragma unused(arg1, arg2)
4260 int error, val = 0;
4261 error = sysctl_handle_int(oidp, &val, 0, req);
4262 if (error || val == 0) {
4263 return error;
4264 }
4265
4266 if (val == 1) {
4267 lck_mtx_test_init();
4268 lck_mtx_test_unlock();
4269 }
4270
4271 return 0;
4272 }
4273
4274 static int
4275 sysctl_erase_all_test_mtx_stats SYSCTL_HANDLER_ARGS
4276 {
4277 #pragma unused(arg1, arg2)
4278 int error, val = 0;
4279 error = sysctl_handle_int(oidp, &val, 0, req);
4280 if (error || val == 0) {
4281 return error;
4282 }
4283
4284 if (val == 1) {
4285 lck_mtx_test_init();
4286 erase_all_test_mtx_stats();
4287 }
4288
4289 return 0;
4290 }
4291
4292 static int
4293 sysctl_get_test_mtx_stats SYSCTL_HANDLER_ARGS
4294 {
4295 #pragma unused(oidp, arg1, arg2)
4296 char* buffer;
4297 int size, buffer_size, error;
4298
4299 buffer_size = 1000;
4300 buffer = kalloc(buffer_size);
4301 if (!buffer)
4302 panic("Impossible to allocate memory for %s\n", __func__);
4303
4304 lck_mtx_test_init();
4305
4306 size = get_test_mtx_stats_string(buffer, buffer_size);
4307
4308 error = sysctl_io_string(req, buffer, size, 0, NULL);
4309
4310 kfree(buffer, buffer_size);
4311
4312 return error;
4313 }
4314
4315 static int
4316 sysctl_test_mtx_uncontended SYSCTL_HANDLER_ARGS
4317 {
4318 #pragma unused(oidp, arg1, arg2)
4319 char* buffer;
4320 int buffer_size, offset, error, iter;
4321 char input_val[40];
4322
4323 if (!req->newptr) {
4324 return 0;
4325 }
4326
4327 if (!req->oldptr) {
4328 return EINVAL;
4329 }
4330
4331 if (req->newlen >= sizeof(input_val)) {
4332 return EINVAL;
4333 }
4334
4335 error = SYSCTL_IN(req, input_val, req->newlen);
4336 if (error) {
4337 return error;
4338 }
4339 input_val[req->newlen] = '\0';
4340
4341 sscanf(input_val, "%d", &iter);
4342
4343 if (iter <= 0) {
4344 printf("%s requested %d iterations, not starting the test\n", __func__, iter);
4345 return EINVAL;
4346 }
4347
4348 lck_mtx_test_init();
4349
4350 buffer_size = 2000;
4351 offset = 0;
4352 buffer = kalloc(buffer_size);
4353 if (!buffer)
4354 panic("Impossible to allocate memory for %s\n", __func__);
4355 memset(buffer, 0, buffer_size);
4356
4357 printf("%s starting uncontended mutex test with %d iterations\n", __func__, iter);
4358
4359 offset = snprintf(buffer, buffer_size, "STATS INNER LOOP");
4360 offset += lck_mtx_test_mtx_uncontended(iter, &buffer[offset], buffer_size - offset);
4361
4362 offset += snprintf(&buffer[offset], buffer_size - offset, "\nSTATS OUTER LOOP");
4363 offset += lck_mtx_test_mtx_uncontended_loop_time(iter, &buffer[offset], buffer_size - offset);
4364
4365 error = SYSCTL_OUT(req, buffer, offset);
4366
4367 kfree(buffer, buffer_size);
4368 return error;
4369 }
4370
4371 static int
4372 sysctl_test_mtx_contended SYSCTL_HANDLER_ARGS
4373 {
4374 #pragma unused(oidp, arg1, arg2)
4375 char* buffer;
4376 int buffer_size, offset, error, iter;
4377 char input_val[40];
4378
4379 printf("%s called\n", __func__);
4380
4381 if (!req->newptr) {
4382 return 0;
4383 }
4384
4385 if (!req->oldptr) {
4386 return EINVAL;
4387 }
4388
4389 if (req->newlen >= sizeof(input_val)) {
4390 return EINVAL;
4391 }
4392
4393 error = SYSCTL_IN(req, input_val, req->newlen);
4394 if (error) {
4395 return error;
4396 }
4397 input_val[req->newlen] = '\0';
4398
4399 sscanf(input_val, "%d", &iter);
4400
4401 if (iter <= 0) {
4402 printf("%s requested %d iterations, not starting the test\n", __func__, iter);
4403 return EINVAL;
4404 }
4405
4406 lck_mtx_test_init();
4407
4408 erase_all_test_mtx_stats();
4409
4410 buffer_size = 1000;
4411 offset = 0;
4412 buffer = kalloc(buffer_size);
4413 if (!buffer)
4414 panic("Impossible to allocate memory for %s\n", __func__);
4415 memset(buffer, 0, buffer_size);
4416
4417 printf("%s starting contended mutex test with %d iterations\n", __func__, iter);
4418
4419 offset = snprintf(buffer, buffer_size, "STATS INNER LOOP");
4420 offset += lck_mtx_test_mtx_contended(iter, &buffer[offset], buffer_size - offset);
4421
4422 printf("%s starting contended mutex loop test with %d iterations\n", __func__, iter);
4423
4424 offset += snprintf(&buffer[offset], buffer_size - offset, "\nSTATS OUTER LOOP");
4425 offset += lck_mtx_test_mtx_contended_loop_time(iter, &buffer[offset], buffer_size - offset);
4426
4427 error = SYSCTL_OUT(req, buffer, offset);
4428
4429 kfree(buffer, buffer_size);
4430
4431 return error;
4432 }
4433
4434 SYSCTL_PROC(_kern, OID_AUTO, lck_mtx_test_lock, CTLFLAG_WR | CTLFLAG_MASKED | CTLFLAG_ANYBODY | CTLFLAG_KERN | CTLFLAG_LOCKED,
4435 0, 0, sysctl_lck_mtx_test_lock, "I", "lck mtx test lock");
4436
4437 SYSCTL_PROC(_kern, OID_AUTO, lck_mtx_test_unlock, CTLFLAG_WR | CTLFLAG_MASKED |CTLFLAG_ANYBODY | CTLFLAG_KERN | CTLFLAG_LOCKED,
4438 0, 0, sysctl_lck_mtx_test_unlock, "I", "lck mtx test unlock");
4439
4440 SYSCTL_PROC(_kern, OID_AUTO, erase_all_test_mtx_stats, CTLFLAG_WR | CTLFLAG_MASKED |CTLFLAG_ANYBODY | CTLFLAG_KERN | CTLFLAG_LOCKED,
4441 0, 0, sysctl_erase_all_test_mtx_stats, "I", "erase test_mtx statistics");
4442
4443 SYSCTL_PROC(_kern, OID_AUTO, get_test_mtx_stats, CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MASKED| CTLFLAG_KERN | CTLFLAG_LOCKED,
4444 0, 0, sysctl_get_test_mtx_stats, "A", "get test_mtx statistics");
4445
4446 SYSCTL_PROC(_kern, OID_AUTO, test_mtx_contended, CTLTYPE_STRING | CTLFLAG_MASKED | CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
4447 0, 0, sysctl_test_mtx_contended, "A", "get statistics for contended mtx test");
4448
4449 SYSCTL_PROC(_kern, OID_AUTO, test_mtx_uncontended, CTLTYPE_STRING | CTLFLAG_MASKED | CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
4450 0, 0, sysctl_test_mtx_uncontended, "A", "get statistics for uncontended mtx test");
4451
4452 #if defined (__x86_64__)
4453
4454 semaphore_t sysctl_test_panic_with_thread_sem;
4455
4456 #pragma clang diagnostic push
4457 #pragma clang diagnostic ignored "-Winfinite-recursion" /* rdar://38801963 */
4458 __attribute__((noreturn))
4459 static void
4460 panic_thread_test_child_spin(void * arg, wait_result_t wres)
4461 {
4462 static int panic_thread_recurse_count = 5;
4463
4464 if (panic_thread_recurse_count > 0) {
4465 panic_thread_recurse_count--;
4466 panic_thread_test_child_spin(arg, wres);
4467 }
4468
4469 semaphore_signal(sysctl_test_panic_with_thread_sem);
4470 while (1) { ; }
4471 }
4472 #pragma clang diagnostic pop
4473
4474 static void
4475 panic_thread_test_child_park(void * arg __unused, wait_result_t wres __unused)
4476 {
4477 int event;
4478
4479 assert_wait(&event, THREAD_UNINT);
4480 semaphore_signal(sysctl_test_panic_with_thread_sem);
4481 thread_block(panic_thread_test_child_park);
4482 }
4483
4484 static int
4485 sysctl_test_panic_with_thread SYSCTL_HANDLER_ARGS
4486 {
4487 #pragma unused(arg1, arg2)
4488 int rval = 0;
4489 char str[16] = { '\0' };
4490 thread_t child_thread = THREAD_NULL;
4491
4492 rval = sysctl_handle_string(oidp, str, sizeof(str), req);
4493 if (rval != 0 || !req->newptr) {
4494 return EINVAL;
4495 }
4496
4497 semaphore_create(kernel_task, &sysctl_test_panic_with_thread_sem, SYNC_POLICY_FIFO, 0);
4498
4499 /* Create thread to spin or park in continuation */
4500 if (strncmp("spin", str, strlen("spin")) == 0) {
4501 if (kernel_thread_start(panic_thread_test_child_spin, NULL, &child_thread) != KERN_SUCCESS) {
4502 semaphore_destroy(kernel_task, sysctl_test_panic_with_thread_sem);
4503 return EBUSY;
4504 }
4505 } else if (strncmp("continuation", str, strlen("continuation")) == 0) {
4506 if (kernel_thread_start(panic_thread_test_child_park, NULL, &child_thread) != KERN_SUCCESS) {
4507 semaphore_destroy(kernel_task, sysctl_test_panic_with_thread_sem);
4508 return EBUSY;
4509 }
4510 } else {
4511 semaphore_destroy(kernel_task, sysctl_test_panic_with_thread_sem);
4512 return EINVAL;
4513 }
4514
4515 semaphore_wait(sysctl_test_panic_with_thread_sem);
4516
4517 panic_with_thread_context(0, NULL, 0, child_thread, "testing panic_with_thread_context for thread %p", child_thread);
4518
4519 /* Not reached */
4520 return EINVAL;
4521 }
4522
4523 SYSCTL_PROC(_kern, OID_AUTO, test_panic_with_thread, CTLFLAG_MASKED | CTLFLAG_KERN | CTLFLAG_LOCKED | CTLFLAG_WR | CTLTYPE_STRING,
4524 0, 0, sysctl_test_panic_with_thread, "A", "test panic flow for backtracing a different thread");
4525 #endif /* defined (__x86_64__) */
4526 #endif /* DEVELOPMENT || DEBUG */
mirror of XNU