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


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