1 /*
2 * Copyright (c) 2003-2020 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
29 #include <string.h>
30 #include <sys/param.h>
31 #include <sys/kernel.h>
32 #include <sys/sysctl.h>
33 #include <i386/cpuid.h>
34 #include <i386/tsc.h>
35 #include <i386/rtclock_protos.h>
36 #include <i386/machine_routines.h>
37 #include <i386/pal_routines.h>
38 #include <i386/ucode.h>
39 #include <kern/clock.h>
40 #include <libkern/libkern.h>
41 #include <i386/lapic.h>
42 #include <i386/mp.h>
43 #include <kern/hvg_hypercall.h>
44 #include <kern/kalloc.h>
45 #include <i386/pmap.h>
46
47
48 static int
49 _i386_cpu_info SYSCTL_HANDLER_ARGS
50 {
51 __unused struct sysctl_oid *unused_oidp = oidp;
52 void *ptr = arg1;
53 int value;
54
55 if (arg2 == -1) {
56 ptr = *(void **)ptr;
57 arg2 = 0;
58 }
59
60 if (arg2 == 0 && ((char *)ptr)[0] == '\0') {
61 return ENOENT;
62 }
63
64 if (arg2 == sizeof(uint8_t)) {
65 value = (uint32_t) *(uint8_t *)ptr;
66 ptr = &value;
67 arg2 = sizeof(uint32_t);
68 }
69 return SYSCTL_OUT(req, ptr, arg2 ? (size_t) arg2 : strlen((char *)ptr) + 1);
70 }
71
72 static int
73 i386_cpu_info SYSCTL_HANDLER_ARGS
74 {
75 void *ptr = (uint8_t *)cpuid_info() + (uintptr_t)arg1;
76 return _i386_cpu_info(oidp, ptr, arg2, req);
77 }
78
79 static int
80 i386_cpu_info_nonzero SYSCTL_HANDLER_ARGS
81 {
82 void *ptr = (uint8_t *)cpuid_info() + (uintptr_t)arg1;
83 int value = *(uint32_t *)ptr;
84
85 if (value == 0) {
86 return ENOENT;
87 }
88
89 return _i386_cpu_info(oidp, ptr, arg2, req);
90 }
91 static int
92 cpu_mwait SYSCTL_HANDLER_ARGS
93 {
94 i386_cpu_info_t *cpu_info = cpuid_info();
95 void *ptr = (uint8_t *)cpu_info->cpuid_mwait_leafp + (uintptr_t)arg1;
96 if (cpu_info->cpuid_mwait_leafp == NULL) {
97 return ENOENT;
98 }
99 return _i386_cpu_info(oidp, ptr, arg2, req);
100 }
101
102 static int
103 cpu_thermal SYSCTL_HANDLER_ARGS
104 {
105 i386_cpu_info_t *cpu_info = cpuid_info();
106 void *ptr = (uint8_t *)cpu_info->cpuid_thermal_leafp + (uintptr_t)arg1;
107 if (cpu_info->cpuid_thermal_leafp == NULL) {
108 return ENOENT;
109 }
110 return _i386_cpu_info(oidp, ptr, arg2, req);
111 }
112
113 static int
114 cpu_arch_perf SYSCTL_HANDLER_ARGS
115 {
116 i386_cpu_info_t *cpu_info = cpuid_info();
117 void *ptr = (uint8_t *)cpu_info->cpuid_arch_perf_leafp + (uintptr_t)arg1;
118 if (cpu_info->cpuid_arch_perf_leafp == NULL) {
119 return ENOENT;
120 }
121 return _i386_cpu_info(oidp, ptr, arg2, req);
122 }
123
124 static int
125 cpu_xsave SYSCTL_HANDLER_ARGS
126 {
127 i386_cpu_info_t *cpu_info = cpuid_info();
128 void *ptr = (uint8_t *)cpu_info->cpuid_xsave_leafp + (uintptr_t)arg1;
129 if (cpu_info->cpuid_xsave_leafp == NULL) {
130 return ENOENT;
131 }
132 return _i386_cpu_info(oidp, ptr, arg2, req);
133 }
134
135
136 static int
137 cpu_features SYSCTL_HANDLER_ARGS
138 {
139 __unused struct sysctl_oid *unused_oidp = oidp;
140 __unused void *unused_arg1 = arg1;
141 __unused int unused_arg2 = arg2;
142 char buf[512];
143
144 buf[0] = '\0';
145 cpuid_get_feature_names(cpuid_features(), buf, sizeof(buf));
146
147 return SYSCTL_OUT(req, buf, strlen(buf) + 1);
148 }
149
150 static int
151 cpu_extfeatures SYSCTL_HANDLER_ARGS
152 {
153 __unused struct sysctl_oid *unused_oidp = oidp;
154 __unused void *unused_arg1 = arg1;
155 __unused int unused_arg2 = arg2;
156 char buf[512];
157
158 buf[0] = '\0';
159 cpuid_get_extfeature_names(cpuid_extfeatures(), buf, sizeof(buf));
160
161 return SYSCTL_OUT(req, buf, strlen(buf) + 1);
162 }
163
164 static int
165 cpu_leaf7_features SYSCTL_HANDLER_ARGS
166 {
167 __unused struct sysctl_oid *unused_oidp = oidp;
168 __unused void *unused_arg1 = arg1;
169 __unused int unused_arg2 = arg2;
170 char buf[512];
171
172 uint64_t leaf7_features = cpuid_info()->cpuid_leaf7_features;
173 uint64_t leaf7_extfeatures = cpuid_info()->cpuid_leaf7_extfeatures;
174 if (leaf7_features == 0 && leaf7_extfeatures == 0) {
175 return ENOENT;
176 }
177
178 buf[0] = '\0';
179 cpuid_get_leaf7_feature_names(leaf7_features, buf, sizeof(buf));
180 if (leaf7_extfeatures != 0) {
181 strlcat(buf, " ", sizeof(buf));
182 cpuid_get_leaf7_extfeature_names(leaf7_extfeatures, buf + strlen(buf),
183 (unsigned int)(sizeof(buf) - strlen(buf)));
184 }
185
186 return SYSCTL_OUT(req, buf, strlen(buf) + 1);
187 }
188
189 static int
190 cpu_logical_per_package SYSCTL_HANDLER_ARGS
191 {
192 __unused struct sysctl_oid *unused_oidp = oidp;
193 __unused void *unused_arg1 = arg1;
194 __unused int unused_arg2 = arg2;
195 i386_cpu_info_t *cpu_info = cpuid_info();
196
197 if (!(cpuid_features() & CPUID_FEATURE_HTT)) {
198 return ENOENT;
199 }
200
201 return SYSCTL_OUT(req, &cpu_info->cpuid_logical_per_package,
202 sizeof(cpu_info->cpuid_logical_per_package));
203 }
204
205 static int
206 cpu_flex_ratio_desired SYSCTL_HANDLER_ARGS
207 {
208 __unused struct sysctl_oid *unused_oidp = oidp;
209 __unused void *unused_arg1 = arg1;
210 __unused int unused_arg2 = arg2;
211 i386_cpu_info_t *cpu_info = cpuid_info();
212
213 if (cpu_info->cpuid_model != 26) {
214 return ENOENT;
215 }
216
217 return SYSCTL_OUT(req, &flex_ratio, sizeof(flex_ratio));
218 }
219
220 static int
221 cpu_flex_ratio_min SYSCTL_HANDLER_ARGS
222 {
223 __unused struct sysctl_oid *unused_oidp = oidp;
224 __unused void *unused_arg1 = arg1;
225 __unused int unused_arg2 = arg2;
226 i386_cpu_info_t *cpu_info = cpuid_info();
227
228 if (cpu_info->cpuid_model != 26) {
229 return ENOENT;
230 }
231
232 return SYSCTL_OUT(req, &flex_ratio_min, sizeof(flex_ratio_min));
233 }
234
235 static int
236 cpu_flex_ratio_max SYSCTL_HANDLER_ARGS
237 {
238 __unused struct sysctl_oid *unused_oidp = oidp;
239 __unused void *unused_arg1 = arg1;
240 __unused int unused_arg2 = arg2;
241 i386_cpu_info_t *cpu_info = cpuid_info();
242
243 if (cpu_info->cpuid_model != 26) {
244 return ENOENT;
245 }
246
247 return SYSCTL_OUT(req, &flex_ratio_max, sizeof(flex_ratio_max));
248 }
249
250 static int
251 cpu_ucode_update SYSCTL_HANDLER_ARGS
252 {
253 #pragma unused(oidp, arg1, arg2)
254 uint64_t addr;
255 int error;
256
257 /* Can't update microcode from within a VM. */
258
259 if (cpuid_features() & CPUID_FEATURE_VMM) {
260 return ENODEV;
261 }
262
263 if (req->newptr == USER_ADDR_NULL) {
264 return EINVAL;
265 }
266
267 error = SYSCTL_IN(req, &addr, sizeof(addr));
268 if (error) {
269 return error;
270 }
271
272 return ucode_interface(addr);
273 }
274
275 extern uint64_t panic_restart_timeout;
276 static int
panic_set_restart_timeout(__unused struct sysctl_oid * oidp,__unused void * arg1,__unused int arg2,struct sysctl_req * req)277 panic_set_restart_timeout(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
278 {
279 int new_value = 0, old_value = 0, changed = 0, error;
280 uint64_t nstime;
281
282 if (panic_restart_timeout) {
283 absolutetime_to_nanoseconds(panic_restart_timeout, &nstime);
284 old_value = (int)MIN(nstime / NSEC_PER_SEC, INT_MAX);
285 }
286
287 error = sysctl_io_number(req, old_value, sizeof(old_value), &new_value, &changed);
288 if (error == 0 && changed) {
289 if (new_value >= 0) {
290 nanoseconds_to_absolutetime(((uint64_t)new_value) * NSEC_PER_SEC, &panic_restart_timeout);
291 } else {
292 error = EDOM;
293 }
294 }
295 return error;
296 }
297
298 /*
299 * Populates the {CPU, vector, latency} triple for the maximum observed primary
300 * interrupt latency
301 */
302 static int
misc_interrupt_latency_max(__unused struct sysctl_oid * oidp,__unused void * arg1,__unused int arg2,struct sysctl_req * req)303 misc_interrupt_latency_max(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
304 {
305 int changed = 0, error;
306 char buf[128];
307 buf[0] = '\0';
308
309 interrupt_populate_latency_stats(buf, sizeof(buf));
310
311 error = sysctl_io_string(req, buf, sizeof(buf), 0, &changed);
312
313 if (error == 0 && changed) {
314 interrupt_reset_latency_stats();
315 }
316
317 return error;
318 }
319
320 #if DEVELOPMENT || DEBUG
321 /*
322 * Populates a string with each CPU's tsc synch delta.
323 */
324 static int
x86_cpu_tsc_deltas(__unused struct sysctl_oid * oidp,__unused void * arg1,__unused int arg2,struct sysctl_req * req)325 x86_cpu_tsc_deltas(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
326 {
327 int err;
328 uint32_t ncpus = ml_wait_max_cpus();
329 uint32_t buflen = (2 /* hex digits */ * sizeof(uint64_t) + 3 /* for "0x" + " " */) * ncpus + 1;
330 char *buf = (char *)kalloc_data(buflen, Z_WAITOK);
331
332 cpu_data_tsc_sync_deltas_string(buf, buflen, 0, ncpus - 1);
333
334 err = sysctl_io_string(req, buf, buflen, 0, 0);
335
336 kfree_data(buf, buflen);
337
338 return err;
339 }
340
341 /*
342 * Triggers a machine-check exception - for a suitably configured kernel only.
343 */
344 extern void mca_exception_panic(void);
345 static int
misc_machine_check_panic(__unused struct sysctl_oid * oidp,__unused void * arg1,__unused int arg2,struct sysctl_req * req)346 misc_machine_check_panic(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
347 {
348 int changed = 0, error;
349 char buf[128];
350 buf[0] = '\0';
351
352 error = sysctl_io_string(req, buf, sizeof(buf), 0, &changed);
353
354 if (error == 0 && changed) {
355 mca_exception_panic();
356 }
357 return error;
358 }
359
360 /*
361 * Triggers a non-responsive processor timeout panic - for a suitably configured kernel only.
362 */
363 static uint64_t kernel_timeout_spin = 0;
364 static int
misc_kernel_timeout_spin(__unused struct sysctl_oid * oidp,__unused void * arg1,__unused int arg2,struct sysctl_req * req)365 misc_kernel_timeout_spin(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
366 {
367 uint64_t old_value;
368 uint64_t new_value;
369 int changed = 0, error;
370 char buf[128];
371 buf[0] = '\0';
372
373 absolutetime_to_nanoseconds(kernel_timeout_spin, &old_value);
374
375 error = sysctl_io_number(req, old_value, sizeof(uint64_t), &new_value, &changed);
376 if (error == 0 && changed) {
377 nanoseconds_to_absolutetime(((uint64_t)new_value), &kernel_timeout_spin);
378 kernel_spin(kernel_timeout_spin);
379 }
380 return error;
381 }
382 #endif /* DEVELOPMENT || DEBUG */
383
384
385 SYSCTL_NODE(_machdep, OID_AUTO, cpu, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
386 "CPU info");
387
388 SYSCTL_PROC(_machdep_cpu, OID_AUTO, max_basic, CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
389 (void *)offsetof(i386_cpu_info_t, cpuid_max_basic), sizeof(uint32_t),
390 i386_cpu_info, "IU", "Max Basic Information value");
391
392 SYSCTL_PROC(_machdep_cpu, OID_AUTO, max_ext, CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
393 (void *)offsetof(i386_cpu_info_t, cpuid_max_ext), sizeof(uint32_t),
394 i386_cpu_info, "IU", "Max Extended Function Information value");
395
396 SYSCTL_PROC(_machdep_cpu, OID_AUTO, vendor, CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_LOCKED,
397 (void *)offsetof(i386_cpu_info_t, cpuid_vendor), 0,
398 i386_cpu_info, "A", "CPU vendor");
399
400 SYSCTL_PROC(_machdep_cpu, OID_AUTO, brand_string, CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_LOCKED,
401 (void *)offsetof(i386_cpu_info_t, cpuid_brand_string), 0,
402 i386_cpu_info, "A", "CPU brand string");
403
404 SYSCTL_PROC(_machdep_cpu, OID_AUTO, family, CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
405 (void *)offsetof(i386_cpu_info_t, cpuid_family), sizeof(uint8_t),
406 i386_cpu_info, "I", "CPU family");
407
408 SYSCTL_PROC(_machdep_cpu, OID_AUTO, model, CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
409 (void *)offsetof(i386_cpu_info_t, cpuid_model), sizeof(uint8_t),
410 i386_cpu_info, "I", "CPU model");
411
412 SYSCTL_PROC(_machdep_cpu, OID_AUTO, extmodel, CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
413 (void *)offsetof(i386_cpu_info_t, cpuid_extmodel), sizeof(uint8_t),
414 i386_cpu_info, "I", "CPU extended model");
415
416 SYSCTL_PROC(_machdep_cpu, OID_AUTO, extfamily, CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
417 (void *)offsetof(i386_cpu_info_t, cpuid_extfamily), sizeof(uint8_t),
418 i386_cpu_info, "I", "CPU extended family");
419
420 SYSCTL_PROC(_machdep_cpu, OID_AUTO, stepping, CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
421 (void *)offsetof(i386_cpu_info_t, cpuid_stepping), sizeof(uint8_t),
422 i386_cpu_info, "I", "CPU stepping");
423
424 SYSCTL_PROC(_machdep_cpu, OID_AUTO, feature_bits, CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
425 (void *)offsetof(i386_cpu_info_t, cpuid_features), sizeof(uint64_t),
426 i386_cpu_info, "IU", "CPU features");
427
428 SYSCTL_PROC(_machdep_cpu, OID_AUTO, leaf7_feature_bits,
429 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
430 (void *)offsetof(i386_cpu_info_t, cpuid_leaf7_features),
431 sizeof(uint64_t),
432 i386_cpu_info_nonzero, "IU", "CPU Leaf7 features [EBX ECX]");
433
434 SYSCTL_PROC(_machdep_cpu, OID_AUTO, leaf7_feature_bits_edx,
435 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
436 (void *)offsetof(i386_cpu_info_t, cpuid_leaf7_extfeatures),
437 sizeof(uint32_t),
438 i386_cpu_info_nonzero, "IU", "CPU Leaf7 features [EDX]");
439
440 SYSCTL_PROC(_machdep_cpu, OID_AUTO, extfeature_bits, CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
441 (void *)offsetof(i386_cpu_info_t, cpuid_extfeatures), sizeof(uint64_t),
442 i386_cpu_info, "IU", "CPU extended features");
443
444 SYSCTL_PROC(_machdep_cpu, OID_AUTO, signature, CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
445 (void *)offsetof(i386_cpu_info_t, cpuid_signature), sizeof(uint32_t),
446 i386_cpu_info, "I", "CPU signature");
447
448 SYSCTL_PROC(_machdep_cpu, OID_AUTO, brand, CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
449 (void *)offsetof(i386_cpu_info_t, cpuid_brand), sizeof(uint8_t),
450 i386_cpu_info, "I", "CPU brand");
451
452 SYSCTL_PROC(_machdep_cpu, OID_AUTO, features, CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_LOCKED,
453 0, 0,
454 cpu_features, "A", "CPU feature names");
455
456 SYSCTL_PROC(_machdep_cpu, OID_AUTO, leaf7_features,
457 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_LOCKED,
458 0, 0,
459 cpu_leaf7_features, "A", "CPU Leaf7 feature names");
460
461 SYSCTL_PROC(_machdep_cpu, OID_AUTO, extfeatures, CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_LOCKED,
462 0, 0,
463 cpu_extfeatures, "A", "CPU extended feature names");
464
465 SYSCTL_PROC(_machdep_cpu, OID_AUTO, logical_per_package,
466 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
467 0, 0,
468 cpu_logical_per_package, "I", "CPU logical cpus per package");
469
470 SYSCTL_PROC(_machdep_cpu, OID_AUTO, cores_per_package,
471 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
472 (void *)offsetof(i386_cpu_info_t, cpuid_cores_per_package),
473 sizeof(uint32_t),
474 i386_cpu_info, "I", "CPU cores per package");
475
476 SYSCTL_PROC(_machdep_cpu, OID_AUTO, microcode_version,
477 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
478 (void *)offsetof(i386_cpu_info_t, cpuid_microcode_version),
479 sizeof(uint32_t),
480 i386_cpu_info, "I", "Microcode version number");
481
482 SYSCTL_PROC(_machdep_cpu, OID_AUTO, processor_flag,
483 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
484 (void *)offsetof(i386_cpu_info_t, cpuid_processor_flag),
485 sizeof(uint32_t),
486 i386_cpu_info, "I", "CPU processor flag");
487
488
489 SYSCTL_NODE(_machdep_cpu, OID_AUTO, mwait, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
490 "mwait");
491
492 SYSCTL_PROC(_machdep_cpu_mwait, OID_AUTO, linesize_min,
493 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
494 (void *)offsetof(cpuid_mwait_leaf_t, linesize_min),
495 sizeof(uint32_t),
496 cpu_mwait, "I", "Monitor/mwait minimum line size");
497
498 SYSCTL_PROC(_machdep_cpu_mwait, OID_AUTO, linesize_max,
499 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
500 (void *)offsetof(cpuid_mwait_leaf_t, linesize_max),
501 sizeof(uint32_t),
502 cpu_mwait, "I", "Monitor/mwait maximum line size");
503
504 SYSCTL_PROC(_machdep_cpu_mwait, OID_AUTO, extensions,
505 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
506 (void *)offsetof(cpuid_mwait_leaf_t, extensions),
507 sizeof(uint32_t),
508 cpu_mwait, "I", "Monitor/mwait extensions");
509
510 SYSCTL_PROC(_machdep_cpu_mwait, OID_AUTO, sub_Cstates,
511 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
512 (void *)offsetof(cpuid_mwait_leaf_t, sub_Cstates),
513 sizeof(uint32_t),
514 cpu_mwait, "I", "Monitor/mwait sub C-states");
515
516
517 SYSCTL_NODE(_machdep_cpu, OID_AUTO, thermal, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
518 "thermal");
519
520 SYSCTL_PROC(_machdep_cpu_thermal, OID_AUTO, sensor,
521 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
522 (void *)offsetof(cpuid_thermal_leaf_t, sensor),
523 sizeof(boolean_t),
524 cpu_thermal, "I", "Thermal sensor present");
525
526 SYSCTL_PROC(_machdep_cpu_thermal, OID_AUTO, dynamic_acceleration,
527 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
528 (void *)offsetof(cpuid_thermal_leaf_t, dynamic_acceleration),
529 sizeof(boolean_t),
530 cpu_thermal, "I", "Dynamic Acceleration Technology (Turbo Mode)");
531
532 SYSCTL_PROC(_machdep_cpu_thermal, OID_AUTO, invariant_APIC_timer,
533 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
534 (void *)offsetof(cpuid_thermal_leaf_t, invariant_APIC_timer),
535 sizeof(boolean_t),
536 cpu_thermal, "I", "Invariant APIC Timer");
537
538 SYSCTL_PROC(_machdep_cpu_thermal, OID_AUTO, thresholds,
539 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
540 (void *)offsetof(cpuid_thermal_leaf_t, thresholds),
541 sizeof(uint32_t),
542 cpu_thermal, "I", "Number of interrupt thresholds");
543
544 SYSCTL_PROC(_machdep_cpu_thermal, OID_AUTO, ACNT_MCNT,
545 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
546 (void *)offsetof(cpuid_thermal_leaf_t, ACNT_MCNT),
547 sizeof(boolean_t),
548 cpu_thermal, "I", "ACNT_MCNT capability");
549
550 SYSCTL_PROC(_machdep_cpu_thermal, OID_AUTO, core_power_limits,
551 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
552 (void *)offsetof(cpuid_thermal_leaf_t, core_power_limits),
553 sizeof(boolean_t),
554 cpu_thermal, "I", "Power Limit Notifications at a Core Level");
555
556 SYSCTL_PROC(_machdep_cpu_thermal, OID_AUTO, fine_grain_clock_mod,
557 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
558 (void *)offsetof(cpuid_thermal_leaf_t, fine_grain_clock_mod),
559 sizeof(boolean_t),
560 cpu_thermal, "I", "Fine Grain Clock Modulation");
561
562 SYSCTL_PROC(_machdep_cpu_thermal, OID_AUTO, package_thermal_intr,
563 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
564 (void *)offsetof(cpuid_thermal_leaf_t, package_thermal_intr),
565 sizeof(boolean_t),
566 cpu_thermal, "I", "Package Thermal interrupt and Status");
567
568 SYSCTL_PROC(_machdep_cpu_thermal, OID_AUTO, hardware_feedback,
569 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
570 (void *)offsetof(cpuid_thermal_leaf_t, hardware_feedback),
571 sizeof(boolean_t),
572 cpu_thermal, "I", "Hardware Coordination Feedback");
573
574 SYSCTL_PROC(_machdep_cpu_thermal, OID_AUTO, energy_policy,
575 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
576 (void *)offsetof(cpuid_thermal_leaf_t, energy_policy),
577 sizeof(boolean_t),
578 cpu_thermal, "I", "Energy Efficient Policy Support");
579
580 SYSCTL_NODE(_machdep_cpu, OID_AUTO, xsave, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
581 "xsave");
582
583 SYSCTL_PROC(_machdep_cpu_xsave, OID_AUTO, extended_state,
584 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
585 (void *) 0,
586 sizeof(cpuid_xsave_leaf_t),
587 cpu_xsave, "IU", "XSAVE Extended State Main Leaf");
588
589 SYSCTL_PROC(_machdep_cpu_xsave, OID_AUTO, extended_state1,
590 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
591 (void *) sizeof(cpuid_xsave_leaf_t),
592 sizeof(cpuid_xsave_leaf_t),
593 cpu_xsave, "IU", "XSAVE Extended State Sub-leaf 1");
594
595
596 SYSCTL_NODE(_machdep_cpu, OID_AUTO, arch_perf, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
597 "arch_perf");
598
599 SYSCTL_PROC(_machdep_cpu_arch_perf, OID_AUTO, version,
600 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
601 (void *)offsetof(cpuid_arch_perf_leaf_t, version),
602 sizeof(uint8_t),
603 cpu_arch_perf, "I", "Architectural Performance Version Number");
604
605 SYSCTL_PROC(_machdep_cpu_arch_perf, OID_AUTO, number,
606 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
607 (void *)offsetof(cpuid_arch_perf_leaf_t, number),
608 sizeof(uint8_t),
609 cpu_arch_perf, "I", "Number of counters per logical cpu");
610
611 SYSCTL_PROC(_machdep_cpu_arch_perf, OID_AUTO, width,
612 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
613 (void *)offsetof(cpuid_arch_perf_leaf_t, width),
614 sizeof(uint8_t),
615 cpu_arch_perf, "I", "Bit width of counters");
616
617 SYSCTL_PROC(_machdep_cpu_arch_perf, OID_AUTO, events_number,
618 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
619 (void *)offsetof(cpuid_arch_perf_leaf_t, events_number),
620 sizeof(uint8_t),
621 cpu_arch_perf, "I", "Number of monitoring events");
622
623 SYSCTL_PROC(_machdep_cpu_arch_perf, OID_AUTO, events,
624 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
625 (void *)offsetof(cpuid_arch_perf_leaf_t, events),
626 sizeof(uint32_t),
627 cpu_arch_perf, "I", "Bit vector of events");
628
629 SYSCTL_PROC(_machdep_cpu_arch_perf, OID_AUTO, fixed_number,
630 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
631 (void *)offsetof(cpuid_arch_perf_leaf_t, fixed_number),
632 sizeof(uint8_t),
633 cpu_arch_perf, "I", "Number of fixed-function counters");
634
635 SYSCTL_PROC(_machdep_cpu_arch_perf, OID_AUTO, fixed_width,
636 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
637 (void *)offsetof(cpuid_arch_perf_leaf_t, fixed_width),
638 sizeof(uint8_t),
639 cpu_arch_perf, "I", "Bit-width of fixed-function counters");
640
641
642 SYSCTL_NODE(_machdep_cpu, OID_AUTO, cache, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
643 "cache");
644
645 SYSCTL_PROC(_machdep_cpu_cache, OID_AUTO, linesize,
646 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
647 (void *)offsetof(i386_cpu_info_t, cpuid_cache_linesize),
648 sizeof(uint32_t),
649 i386_cpu_info, "I", "Cacheline size");
650
651 SYSCTL_PROC(_machdep_cpu_cache, OID_AUTO, L2_associativity,
652 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
653 (void *)offsetof(i386_cpu_info_t, cpuid_cache_L2_associativity),
654 sizeof(uint32_t),
655 i386_cpu_info, "I", "L2 cache associativity");
656
657 SYSCTL_PROC(_machdep_cpu_cache, OID_AUTO, size,
658 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
659 (void *)offsetof(i386_cpu_info_t, cpuid_cache_size),
660 sizeof(uint32_t),
661 i386_cpu_info, "I", "Cache size (in Kbytes)");
662
663
664 SYSCTL_NODE(_machdep_cpu, OID_AUTO, tlb, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
665 "tlb");
666 SYSCTL_NODE(_machdep_cpu_tlb, OID_AUTO, inst, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
667 "inst");
668 SYSCTL_NODE(_machdep_cpu_tlb, OID_AUTO, data, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
669 "data");
670
671 SYSCTL_PROC(_machdep_cpu_tlb_inst, OID_AUTO, small,
672 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
673 (void *)offsetof(i386_cpu_info_t,
674 cpuid_tlb[TLB_INST][TLB_SMALL][0]),
675 sizeof(uint32_t),
676 i386_cpu_info_nonzero, "I",
677 "Number of small page instruction TLBs");
678
679 SYSCTL_PROC(_machdep_cpu_tlb_data, OID_AUTO, small,
680 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
681 (void *)offsetof(i386_cpu_info_t,
682 cpuid_tlb[TLB_DATA][TLB_SMALL][0]),
683 sizeof(uint32_t),
684 i386_cpu_info_nonzero, "I",
685 "Number of small page data TLBs (1st level)");
686
687 SYSCTL_PROC(_machdep_cpu_tlb_data, OID_AUTO, small_level1,
688 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
689 (void *)offsetof(i386_cpu_info_t,
690 cpuid_tlb[TLB_DATA][TLB_SMALL][1]),
691 sizeof(uint32_t),
692 i386_cpu_info_nonzero, "I",
693 "Number of small page data TLBs (2nd level)");
694
695 SYSCTL_PROC(_machdep_cpu_tlb_inst, OID_AUTO, large,
696 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
697 (void *)offsetof(i386_cpu_info_t,
698 cpuid_tlb[TLB_INST][TLB_LARGE][0]),
699 sizeof(uint32_t),
700 i386_cpu_info_nonzero, "I",
701 "Number of large page instruction TLBs");
702
703 SYSCTL_PROC(_machdep_cpu_tlb_data, OID_AUTO, large,
704 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
705 (void *)offsetof(i386_cpu_info_t,
706 cpuid_tlb[TLB_DATA][TLB_LARGE][0]),
707 sizeof(uint32_t),
708 i386_cpu_info_nonzero, "I",
709 "Number of large page data TLBs (1st level)");
710
711 SYSCTL_PROC(_machdep_cpu_tlb_data, OID_AUTO, large_level1,
712 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
713 (void *)offsetof(i386_cpu_info_t,
714 cpuid_tlb[TLB_DATA][TLB_LARGE][1]),
715 sizeof(uint32_t),
716 i386_cpu_info_nonzero, "I",
717 "Number of large page data TLBs (2nd level)");
718
719 SYSCTL_PROC(_machdep_cpu_tlb, OID_AUTO, shared,
720 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
721 (void *)offsetof(i386_cpu_info_t, cpuid_stlb),
722 sizeof(uint32_t),
723 i386_cpu_info_nonzero, "I",
724 "Number of shared TLBs");
725
726
727 SYSCTL_NODE(_machdep_cpu, OID_AUTO, address_bits, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
728 "address_bits");
729
730 SYSCTL_PROC(_machdep_cpu_address_bits, OID_AUTO, physical,
731 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
732 (void *)offsetof(i386_cpu_info_t, cpuid_address_bits_physical),
733 sizeof(uint32_t),
734 i386_cpu_info, "I", "Number of physical address bits");
735
736 SYSCTL_PROC(_machdep_cpu_address_bits, OID_AUTO, virtual,
737 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
738 (void *)offsetof(i386_cpu_info_t, cpuid_address_bits_virtual),
739 sizeof(uint32_t),
740 i386_cpu_info, "I", "Number of virtual address bits");
741
742
743 SYSCTL_PROC(_machdep_cpu, OID_AUTO, core_count,
744 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
745 (void *)offsetof(i386_cpu_info_t, core_count),
746 sizeof(uint32_t),
747 i386_cpu_info, "I", "Number of enabled cores per package");
748
749 SYSCTL_PROC(_machdep_cpu, OID_AUTO, thread_count,
750 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
751 (void *)offsetof(i386_cpu_info_t, thread_count),
752 sizeof(uint32_t),
753 i386_cpu_info, "I", "Number of enabled threads per package");
754
755 SYSCTL_NODE(_machdep_cpu, OID_AUTO, flex_ratio, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
756 "Flex ratio");
757
758 SYSCTL_PROC(_machdep_cpu_flex_ratio, OID_AUTO, desired,
759 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
760 0, 0,
761 cpu_flex_ratio_desired, "I", "Flex ratio desired (0 disabled)");
762
763 SYSCTL_PROC(_machdep_cpu_flex_ratio, OID_AUTO, min,
764 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
765 0, 0,
766 cpu_flex_ratio_min, "I", "Flex ratio min (efficiency)");
767
768 SYSCTL_PROC(_machdep_cpu_flex_ratio, OID_AUTO, max,
769 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
770 0, 0,
771 cpu_flex_ratio_max, "I", "Flex ratio max (non-turbo)");
772
773 SYSCTL_PROC(_machdep_cpu, OID_AUTO, ucupdate,
774 CTLTYPE_INT | CTLFLAG_WR | CTLFLAG_LOCKED, 0, 0,
775 cpu_ucode_update, "S", "Microcode update interface");
776
777 SYSCTL_NODE(_machdep_cpu, OID_AUTO, tsc_ccc, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
778 "TSC/CCC frequency information");
779
780 SYSCTL_PROC(_machdep_cpu_tsc_ccc, OID_AUTO, numerator,
781 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
782 (void *)offsetof(i386_cpu_info_t, cpuid_tsc_leaf.numerator),
783 sizeof(uint32_t),
784 i386_cpu_info, "I", "Numerator of TSC/CCC ratio");
785
786 SYSCTL_PROC(_machdep_cpu_tsc_ccc, OID_AUTO, denominator,
787 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
788 (void *)offsetof(i386_cpu_info_t, cpuid_tsc_leaf.denominator),
789 sizeof(uint32_t),
790 i386_cpu_info, "I", "Denominator of TSC/CCC ratio");
791
792 static const uint32_t apic_timer_vector = (LAPIC_DEFAULT_INTERRUPT_BASE + LAPIC_TIMER_INTERRUPT);
793 static const uint32_t apic_IPI_vector = (LAPIC_DEFAULT_INTERRUPT_BASE + LAPIC_INTERPROCESSOR_INTERRUPT);
794
795 SYSCTL_NODE(_machdep, OID_AUTO, vectors, CTLFLAG_RD | CTLFLAG_LOCKED, 0,
796 "Interrupt vector assignments");
797
798 SYSCTL_UINT(_machdep_vectors, OID_AUTO, timer, CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED, __DECONST(uint32_t *, &apic_timer_vector), 0, "");
799 SYSCTL_UINT(_machdep_vectors, OID_AUTO, IPI, CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED, __DECONST(uint32_t *, &apic_IPI_vector), 0, "");
800
801 uint64_t pmap_pv_hashlist_walks;
802 uint64_t pmap_pv_hashlist_cnts;
803 uint32_t pmap_pv_hashlist_max;
804 uint32_t pmap_kernel_text_ps = PAGE_SIZE;
805 extern uint32_t pv_hashed_kern_low_water_mark;
806
807 /*extern struct sysctl_oid_list sysctl__machdep_pmap_children;*/
808
809 SYSCTL_NODE(_machdep, OID_AUTO, pmap, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
810 "PMAP info");
811
812 SYSCTL_QUAD(_machdep_pmap, OID_AUTO, hashwalks, CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED, &pmap_pv_hashlist_walks, "");
813 SYSCTL_QUAD(_machdep_pmap, OID_AUTO, hashcnts, CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED, &pmap_pv_hashlist_cnts, "");
814 SYSCTL_INT(_machdep_pmap, OID_AUTO, hashmax, CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED, &pmap_pv_hashlist_max, 0, "");
815 SYSCTL_INT(_machdep_pmap, OID_AUTO, kernel_text_ps, CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED, &pmap_kernel_text_ps, 0, "");
816 SYSCTL_INT(_machdep_pmap, OID_AUTO, kern_pv_reserve, CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED, &pv_hashed_kern_low_water_mark, 0, "");
817
818 SYSCTL_NODE(_machdep, OID_AUTO, memmap, CTLFLAG_RD | CTLFLAG_LOCKED, NULL, "physical memory map");
819
820 uint64_t firmware_Conventional_bytes = 0;
821 uint64_t firmware_RuntimeServices_bytes = 0;
822 uint64_t firmware_ACPIReclaim_bytes = 0;
823 uint64_t firmware_ACPINVS_bytes = 0;
824 uint64_t firmware_PalCode_bytes = 0;
825 uint64_t firmware_Reserved_bytes = 0;
826 uint64_t firmware_Unusable_bytes = 0;
827 uint64_t firmware_other_bytes = 0;
828
829 SYSCTL_QUAD(_machdep_memmap, OID_AUTO, Conventional, CTLFLAG_RD | CTLFLAG_LOCKED, &firmware_Conventional_bytes, "");
830 SYSCTL_QUAD(_machdep_memmap, OID_AUTO, RuntimeServices, CTLFLAG_RD | CTLFLAG_LOCKED, &firmware_RuntimeServices_bytes, "");
831 SYSCTL_QUAD(_machdep_memmap, OID_AUTO, ACPIReclaim, CTLFLAG_RD | CTLFLAG_LOCKED, &firmware_ACPIReclaim_bytes, "");
832 SYSCTL_QUAD(_machdep_memmap, OID_AUTO, ACPINVS, CTLFLAG_RD | CTLFLAG_LOCKED, &firmware_ACPINVS_bytes, "");
833 SYSCTL_QUAD(_machdep_memmap, OID_AUTO, PalCode, CTLFLAG_RD | CTLFLAG_LOCKED, &firmware_PalCode_bytes, "");
834 SYSCTL_QUAD(_machdep_memmap, OID_AUTO, Reserved, CTLFLAG_RD | CTLFLAG_LOCKED, &firmware_Reserved_bytes, "");
835 SYSCTL_QUAD(_machdep_memmap, OID_AUTO, Unusable, CTLFLAG_RD | CTLFLAG_LOCKED, &firmware_Unusable_bytes, "");
836 SYSCTL_QUAD(_machdep_memmap, OID_AUTO, Other, CTLFLAG_RD | CTLFLAG_LOCKED, &firmware_other_bytes, "");
837
838 SYSCTL_NODE(_machdep, OID_AUTO, tsc, CTLFLAG_RD | CTLFLAG_LOCKED, NULL, "Timestamp counter parameters");
839
840 SYSCTL_QUAD(_machdep_tsc, OID_AUTO, frequency,
841 CTLFLAG_RD | CTLFLAG_LOCKED, &tscFreq, "");
842
843 extern uint32_t deep_idle_rebase;
844 SYSCTL_UINT(_machdep_tsc, OID_AUTO, deep_idle_rebase,
845 CTLFLAG_RD | CTLFLAG_LOCKED, &deep_idle_rebase, 0, "");
846 SYSCTL_QUAD(_machdep_tsc, OID_AUTO, at_boot,
847 CTLFLAG_RD | CTLFLAG_LOCKED, &tsc_at_boot, "");
848 SYSCTL_QUAD(_machdep_tsc, OID_AUTO, rebase_abs_time,
849 CTLFLAG_RD | CTLFLAG_LOCKED, &tsc_rebase_abs_time, "");
850 #if DEVELOPMENT || DEBUG
851 SYSCTL_PROC(_machdep_tsc, OID_AUTO, synch_deltas,
852 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_LOCKED,
853 0, 0, x86_cpu_tsc_deltas, "A", "TSC synch deltas");
854 #endif
855
856 SYSCTL_NODE(_machdep_tsc, OID_AUTO, nanotime,
857 CTLFLAG_RD | CTLFLAG_LOCKED, NULL, "TSC to ns conversion");
858 SYSCTL_QUAD(_machdep_tsc_nanotime, OID_AUTO, tsc_base,
859 CTLFLAG_RD | CTLFLAG_LOCKED,
860 __DECONST(uint64_t *, &pal_rtc_nanotime_info.tsc_base), "");
861 SYSCTL_QUAD(_machdep_tsc_nanotime, OID_AUTO, ns_base,
862 CTLFLAG_RD | CTLFLAG_LOCKED,
863 __DECONST(uint64_t *, &pal_rtc_nanotime_info.ns_base), "");
864 SYSCTL_UINT(_machdep_tsc_nanotime, OID_AUTO, scale,
865 CTLFLAG_RD | CTLFLAG_LOCKED,
866 __DECONST(uint32_t *, &pal_rtc_nanotime_info.scale), 0, "");
867 SYSCTL_UINT(_machdep_tsc_nanotime, OID_AUTO, shift,
868 CTLFLAG_RD | CTLFLAG_LOCKED,
869 __DECONST(uint32_t *, &pal_rtc_nanotime_info.shift), 0, "");
870 SYSCTL_UINT(_machdep_tsc_nanotime, OID_AUTO, generation,
871 CTLFLAG_RD | CTLFLAG_LOCKED,
872 __DECONST(uint32_t *, &pal_rtc_nanotime_info.generation), 0, "");
873
874 SYSCTL_NODE(_machdep, OID_AUTO, misc, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
875 "Miscellaneous x86 kernel parameters");
876
877 #if (DEVELOPMENT || DEBUG)
878 extern uint32_t mp_interrupt_watchdog_events;
879 SYSCTL_UINT(_machdep_misc, OID_AUTO, interrupt_watchdog_events,
880 CTLFLAG_RW | CTLFLAG_LOCKED, &mp_interrupt_watchdog_events, 0, "");
881
882 extern int insnstream_force_cacheline_mismatch;
883 SYSCTL_INT(_machdep_misc, OID_AUTO, insnstream_force_clmismatch,
884 CTLFLAG_RW | CTLFLAG_LOCKED, &insnstream_force_cacheline_mismatch, 0, "");
885 #endif
886
887
888 SYSCTL_PROC(_machdep_misc, OID_AUTO, panic_restart_timeout,
889 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
890 0, 0,
891 panic_set_restart_timeout, "I", "Panic restart timeout in seconds");
892
893 SYSCTL_PROC(_machdep_misc, OID_AUTO, interrupt_latency_max,
894 CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_LOCKED,
895 0, 0,
896 misc_interrupt_latency_max, "A", "Maximum Interrupt latency");
897
898 extern boolean_t is_x2apic;
899 SYSCTL_INT(_machdep, OID_AUTO, x2apic_enabled,
900 CTLFLAG_KERN | CTLFLAG_RD | CTLFLAG_LOCKED,
901 &is_x2apic, 0, "");
902
903 #if DEVELOPMENT || DEBUG
904 SYSCTL_PROC(_machdep_misc, OID_AUTO, machine_check_panic,
905 CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_LOCKED,
906 0, 0,
907 misc_machine_check_panic, "A", "Machine-check exception test");
908
909 SYSCTL_PROC(_machdep_misc, OID_AUTO, kernel_timeout_spin,
910 CTLTYPE_QUAD | CTLFLAG_RW | CTLFLAG_LOCKED,
911 0, sizeof(kernel_timeout_spin),
912 misc_kernel_timeout_spin, "Q", "Kernel timeout panic test");
913
914 SYSCTL_QUAD(_machdep, OID_AUTO, reportphyreadabs,
915 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
916 &report_phy_read_delay, "");
917 SYSCTL_QUAD(_machdep, OID_AUTO, reportphywriteabs,
918 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
919 &report_phy_write_delay, "");
920 SYSCTL_QUAD(_machdep, OID_AUTO, tracephyreadabs,
921 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
922 &trace_phy_read_delay, "");
923 SYSCTL_QUAD(_machdep, OID_AUTO, tracephywriteabs,
924 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
925 &trace_phy_write_delay, "");
926 SYSCTL_INT(_machdep, OID_AUTO, reportphyreadosbt,
927 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
928 &report_phy_read_osbt, 0, "");
929 SYSCTL_INT(_machdep, OID_AUTO, reportphywriteosbt,
930 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
931 &report_phy_write_osbt, 0, "");
932 SYSCTL_INT(_machdep, OID_AUTO, phyreaddelaypanic,
933 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
934 &phy_read_panic, 0, "");
935 SYSCTL_INT(_machdep, OID_AUTO, phywritedelaypanic,
936 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
937 &phy_write_panic, 0, "");
938 #if DEVELOPMENT || DEBUG
939 extern uint64_t simulate_stretched_io;
940 SYSCTL_QUAD(_machdep, OID_AUTO, sim_stretched_io_ns,
941 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
942 &simulate_stretched_io, "");
943 #endif
944
945 extern int pmap_pagezero_mitigation;
946 extern int pmap_asserts_enabled, pmap_asserts_traced;
947 /* On DEV/DEBUG kernels, clear this to disable the SMAP emulation
948 * (address space disconnect) for pagezero-less processes.
949 */
950 SYSCTL_INT(_machdep, OID_AUTO, pmap_pagezero_mitigation,
951 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
952 &pmap_pagezero_mitigation, 0, "");
953 /* Toggle pmap assertions */
954 SYSCTL_INT(_machdep, OID_AUTO, pmap_asserts,
955 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
956 &pmap_asserts_enabled, 0, "");
957 /* Transform pmap assertions into kernel trace terminations */
958 SYSCTL_INT(_machdep, OID_AUTO, pmap_asserts_traced,
959 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
960 &pmap_asserts_traced, 0, "");
961
962 static int
misc_svisor_read(__unused struct sysctl_oid * oidp,__unused void * arg1,__unused int arg2,struct sysctl_req * req)963 misc_svisor_read(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
964 {
965 uint64_t new_value = 0, old_value = 0;
966 int changed = 0, error;
967
968 error = sysctl_io_number(req, old_value, sizeof(uint64_t), &new_value, &changed);
969 if ((error == 0) && changed) {
970 volatile uint32_t *raddr = (uint32_t *) new_value;
971 printf("Supervisor: value at 0x%llx is 0x%x\n", new_value, *raddr);
972 }
973 return error;
974 }
975
976 SYSCTL_PROC(_machdep_misc, OID_AUTO, misc_svisor_read,
977 CTLTYPE_QUAD | CTLFLAG_RW | CTLFLAG_LOCKED,
978 0, 0,
979 misc_svisor_read, "I", "supervisor mode read");
980
981 #endif /* DEVELOPMENT || DEBUG */
982
983 extern void timer_queue_trace_cpu(int);
984 static int
misc_timer_queue_trace(__unused struct sysctl_oid * oidp,__unused void * arg1,__unused int arg2,struct sysctl_req * req)985 misc_timer_queue_trace(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
986 {
987 int changed = 0, error;
988 char buf[128];
989 buf[0] = '\0';
990
991 error = sysctl_io_string(req, buf, sizeof(buf), 0, &changed);
992
993 if (error == 0 && changed) {
994 timer_queue_trace_cpu(0);
995 }
996 return error;
997 }
998
999 SYSCTL_PROC(_machdep_misc, OID_AUTO, timer_queue_trace,
1000 CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_LOCKED,
1001 0, 0,
1002 misc_timer_queue_trace, "A", "Cut timer queue tracepoint");
1003
1004 extern long NMI_count;
1005 extern void NMI_cpus(void);
1006 static int
misc_nmis(__unused struct sysctl_oid * oidp,__unused void * arg1,__unused int arg2,struct sysctl_req * req)1007 misc_nmis(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
1008 {
1009 int new = 0, old = 0, changed = 0, error;
1010
1011 old = (int)MIN(NMI_count, INT_MAX);
1012
1013 error = sysctl_io_number(req, old, sizeof(int), &new, &changed);
1014 if (error == 0 && changed) {
1015 NMI_cpus();
1016 }
1017
1018 return error;
1019 }
1020
1021 SYSCTL_PROC(_machdep_misc, OID_AUTO, nmis,
1022 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
1023 0, 0,
1024 misc_nmis, "I", "Report/increment NMI count");
1025
1026 /* Parameters related to timer coalescing tuning, to be replaced
1027 * with a dedicated systemcall in the future.
1028 */
1029 /* Enable processing pending timers in the context of any other interrupt */
1030 SYSCTL_INT(_kern, OID_AUTO, interrupt_timer_coalescing_enabled,
1031 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
1032 &interrupt_timer_coalescing_enabled, 0, "");
1033 /* Upon entering idle, process pending timers with HW deadlines
1034 * this far in the future.
1035 */
1036 SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_idle_entry_hard_deadline_max,
1037 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
1038 &idle_entry_timer_processing_hdeadline_threshold, 0, "");
1039
1040 /* Track potentially expensive eager timer evaluations on QoS tier
1041 * switches.
1042 */
1043 extern uint32_t ml_timer_eager_evaluations;
1044
1045 SYSCTL_INT(_machdep, OID_AUTO, eager_timer_evaluations,
1046 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
1047 &ml_timer_eager_evaluations, 0, "");
1048
1049 extern uint64_t ml_timer_eager_evaluation_max;
1050
1051 SYSCTL_QUAD(_machdep, OID_AUTO, eager_timer_evaluation_max,
1052 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
1053 &ml_timer_eager_evaluation_max, "");
1054 extern uint64_t x86_isr_fp_simd_use;
1055 SYSCTL_QUAD(_machdep, OID_AUTO, x86_fp_simd_isr_uses,
1056 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
1057 &x86_isr_fp_simd_use, "");
1058
1059 static int
1060 sysctl_kern_insn_copy_optout_task SYSCTL_HANDLER_ARGS
1061 {
1062 #pragma unused(oidp, arg1, arg2)
1063 uint32_t soflags = 0;
1064 uint32_t old_value = curtask_get_insn_copy_optout() ? 1 : 0;
1065
1066 int error = SYSCTL_IN(req, &soflags, sizeof(soflags));
1067 if (error) {
1068 return error;
1069 }
1070
1071 if (soflags) {
1072 curtask_set_insn_copy_optout();
1073 }
1074
1075 return SYSCTL_OUT(req, &old_value, sizeof(old_value));
1076 }
1077 SYSCTL_PROC(_machdep, OID_AUTO, insn_copy_optout_task,
1078 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED | CTLFLAG_MASKED | CTLFLAG_ANYBODY,
1079 0, 0, sysctl_kern_insn_copy_optout_task, "I", "");
1080
1081
1082 #if DEVELOPMENT || DEBUG
1083
1084 extern int plctrace_enabled;
1085
1086 SYSCTL_INT(_machdep, OID_AUTO, pltrace,
1087 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
1088 &plctrace_enabled, 0, "");
1089
1090 /* Intentionally not declared as volatile here: */
1091 extern int mmiotrace_enabled;
1092
1093 SYSCTL_INT(_machdep, OID_AUTO, MMIOtrace,
1094 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
1095 &mmiotrace_enabled, 0, "");
1096
1097 extern int fpsimd_fault_popc;
1098 SYSCTL_INT(_machdep, OID_AUTO, fpsimd_fault_popc,
1099 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
1100 &fpsimd_fault_popc, 0, "");
1101
1102 volatile int stop_spinning;
1103 static int
spin_in_the_kernel(__unused struct sysctl_oid * oidp,__unused void * arg1,__unused int arg2,struct sysctl_req * req)1104 spin_in_the_kernel(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
1105 {
1106 int new = 0, old = 0, changed = 0, error;
1107
1108 error = sysctl_io_number(req, old, sizeof(int), &new, &changed);
1109 if (error == 0 && changed) {
1110 stop_spinning = FALSE;
1111 while (stop_spinning == FALSE) {
1112 __builtin_ia32_pause();
1113 }
1114 } else if (error == 0) {
1115 stop_spinning = TRUE;
1116 }
1117
1118 return error;
1119 }
1120
1121 SYSCTL_PROC(_machdep_misc, OID_AUTO, spin_forever,
1122 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED | CTLFLAG_MASKED,
1123 0, 0,
1124 spin_in_the_kernel, "I", "Spin forever");
1125
1126 SYSCTL_INT(_machdep_misc, OID_AUTO, fake_pte_corruption,
1127 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
1128 &pmap_inject_pte_corruption, 0,
1129 "Fake a PTE corruption event (induces NMI IPIs and panics the system)");
1130
1131 extern int traptrace_enabled;
1132 SYSCTL_INT(_machdep_misc, OID_AUTO, traptrace_enabled,
1133 CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
1134 &traptrace_enabled, 0, "Enabled/disable trap trace");
1135
1136 #endif /* DEVELOPMENT || DEBUG */
1137
1138 /*
1139 * Trigger a guest kernel core dump (macOS VM only)
1140 * Usage: sysctl kern.trigger_kernel_coredump = 1
1141 * (option selector must be 1, other values reserved)
1142 */
1143
1144 static int
sysctl_trigger_kernel_coredump(struct sysctl_oid * oidp __unused,void * arg1,int arg2,struct sysctl_req * req)1145 sysctl_trigger_kernel_coredump(struct sysctl_oid *oidp __unused, void *arg1, int arg2, struct sysctl_req *req)
1146 {
1147 int error = 0;
1148 hvg_hcall_return_t hv_ret;
1149 char buf[3]; // 1 digit for dump option + 1 '\0' from userspace sysctl + 1 '\0'
1150
1151 if (req->newptr) {
1152 // Write request
1153 // single digit (1 byte) + 1 terminating byte added by system_cmd sysctl
1154 if (req->newlen > 2) {
1155 return EINVAL;
1156 }
1157 error = SYSCTL_IN(req, buf, req->newlen);
1158 buf[req->newlen] = '\0';
1159 if (!error) {
1160 if (strcmp(buf, "1") != 0) {
1161 return EINVAL;
1162 }
1163 /* Issue hypercall to trigger a dump */
1164 hv_ret = hvg_hcall_trigger_dump(arg1, HVG_HCALL_DUMP_OPTION_REGULAR);
1165
1166 /* Translate hypercall error code to syscall error code */
1167 switch (hv_ret) {
1168 case HVG_HCALL_SUCCESS:
1169 error = SYSCTL_OUT(req, arg1, 41);
1170 break;
1171 case HVG_HCALL_ACCESS_DENIED:
1172 error = EPERM;
1173 break;
1174 case HVG_HCALL_INVALID_CODE:
1175 case HVG_HCALL_INVALID_PARAMETER:
1176 error = EINVAL;
1177 break;
1178 case HVG_HCALL_IO_FAILED:
1179 error = EIO;
1180 break;
1181 case HVG_HCALL_FEAT_DISABLED:
1182 case HVG_HCALL_UNSUPPORTED:
1183 error = ENOTSUP;
1184 break;
1185 default:
1186 error = ENODEV;
1187 }
1188 }
1189 } else {
1190 // Read request
1191 error = SYSCTL_OUT(req, arg1, arg2);
1192 }
1193 return error;
1194 }
1195
1196
1197 static hvg_hcall_vmcore_file_t sysctl_vmcore;
1198
1199 void
hvg_bsd_init(void)1200 hvg_bsd_init(void)
1201 {
1202 if (!cpuid_vmm_present()) {
1203 return;
1204 }
1205
1206 if ((cpuid_vmm_get_applepv_features() & CPUID_LEAF_FEATURE_COREDUMP) != 0) {
1207 /* Register an OID in the sysctl MIB tree for kern.trigger_kernel_coredump */
1208 struct sysctl_oid *hcall_trigger_dump_oid = zalloc_permanent(sizeof(struct sysctl_oid), ZALIGN(struct sysctl_oid));
1209 struct sysctl_oid oid = SYSCTL_STRUCT_INIT(_kern,
1210 OID_AUTO,
1211 trigger_kernel_coredump,
1212 CTLTYPE_STRING | CTLFLAG_RW,
1213 &sysctl_vmcore, sizeof(sysctl_vmcore),
1214 sysctl_trigger_kernel_coredump,
1215 "A", "Request that the hypervisor take a live kernel dump");
1216 *hcall_trigger_dump_oid = oid;
1217 sysctl_register_oid(hcall_trigger_dump_oid);
1218 }
1219 }
1220