/*
* Copyright (c) 2021 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. The rights granted to you under the License
* may not be used to create, or enable the creation or redistribution of,
* unlawful or unlicensed copies of an Apple operating system, or to
* circumvent, violate, or enable the circumvention or violation of, any
* terms of an Apple operating system software license agreement.
*
* Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
*/
#include <sys/sysctl.h>
#include <libkern/libkern.h>
#include <kern/hvg_hypercall.h>
#include <stdbool.h>
/* Translate hypercall error code to syscall error code */
static int
hv_ret_to_errno(hvg_hcall_return_t ret)
{
switch (ret) {
case HVG_HCALL_ACCESS_DENIED:
return EPERM;
case HVG_HCALL_INVALID_CODE:
case HVG_HCALL_INVALID_PARAMETER:
return EINVAL;
case HVG_HCALL_IO_FAILED:
return EIO;
case HVG_HCALL_FEAT_DISABLED:
case HVG_HCALL_UNSUPPORTED:
return ENOTSUP;
default:
return ENODEV;
}
}
/*
* Trigger a guest kernel core dump (Intel macOS VM only)
* Usage: sysctl kern.hvg.trigger_kernel_coredump = 1
* (option selector must be 1, other values reserved).
*/
static int
sysctl_trigger_kernel_coredump(__unused struct sysctl_oid *oidp,
__unused void *arg1, __unused int arg2, __unused struct sysctl_req *req)
{
/*
* Static because it retains the filename of the last core dump
* (returned when the sysctl is read).
*/
static hvg_hcall_vmcore_file_t sysctl_vmcore;
int error = 0;
hvg_hcall_return_t hv_ret;
char buf[3]; // 1 digit for dump option + 1 '\0' from userspace sysctl + 1 '\0'
if (req->newptr) {
// Write request
// single digit (1 byte) + 1 terminating byte added by system_cmd sysctl
if (req->newlen > 2) {
return EINVAL;
}
error = SYSCTL_IN(req, buf, req->newlen);
buf[req->newlen] = '\0';
if (!error) {
if (strcmp(buf, "1") != 0) {
return EINVAL;
}
/* Issue hypercall to trigger a dump */
hv_ret = hvg_hcall_trigger_dump(&sysctl_vmcore, HVG_HCALL_DUMP_OPTION_REGULAR);
if (hv_ret == HVG_HCALL_SUCCESS) {
error = SYSCTL_OUT(req, &sysctl_vmcore, sizeof(sysctl_vmcore));
} else {
error = hv_ret_to_errno(hv_ret);
}
}
} else {
// Read request
error = SYSCTL_OUT(req, &sysctl_vmcore, sizeof(sysctl_vmcore));
}
return error;
}
/*
* Get offset from the host's mach_absolute_time.
*/
static int
sysctl_get_mabs_offset(__unused struct sysctl_oid *oidp, __unused void *arg1,
__unused int arg2, struct sysctl_req *req)
{
uint64_t offset = 0;
const hvg_hcall_return_t ret = hvg_hcall_get_mabs_offset(&offset);
if (ret != HVG_HCALL_SUCCESS) {
return hv_ret_to_errno(ret);
}
return SYSCTL_OUT(req, &offset, sizeof(offset));
}
/*
* Get the host's boot session UUID.
*/
static int
sysctl_get_bootsessionuuid(__unused struct sysctl_oid *oidp,
__unused void *arg1, __unused int arg2, struct sysctl_req *req)
{
uuid_string_t uuid = {0};
const hvg_hcall_return_t ret = hvg_hcall_get_bootsessionuuid(uuid);
if (ret != HVG_HCALL_SUCCESS) {
return hv_ret_to_errno(ret);
}
return SYSCTL_OUT(req, &uuid, sizeof(uuid));
}
static int
sysctl_vmm_present(__unused struct sysctl_oid *oidp,
__unused void *arg1, __unused int arg2, struct sysctl_req *req)
{
int vmm_present = 0;
#if defined(__arm64__)
extern int IODTGetDefault(const char *key, void *infoAddr, unsigned int infoSize );
(void) IODTGetDefault("vmm-present", &vmm_present, sizeof(vmm_present));
#elif defined(__x86_64__)
extern boolean_t cpuid_vmm_present(void);
vmm_present = cpuid_vmm_present();
#endif
vmm_present = !!vmm_present;
return SYSCTL_OUT(req, &vmm_present, sizeof(vmm_present));
}
static SYSCTL_NODE(_kern, OID_AUTO, hvg,
CTLFLAG_RW | CTLFLAG_LOCKED | CTLFLAG_ANYBODY, 0,
"hypervisor guest");
static SYSCTL_PROC(_kern_hvg, OID_AUTO, trigger_kernel_coredump,
CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NOAUTO,
NULL, 0,
sysctl_trigger_kernel_coredump, "A",
"Request that the hypervisor take a live kernel dump");
static SYSCTL_PROC(_kern_hvg, OID_AUTO, mabs_offset,
CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_NOAUTO | CTLFLAG_LOCKED,
NULL, 0,
sysctl_get_mabs_offset, "Q",
"host time offset");
static SYSCTL_PROC(_kern_hvg, OID_AUTO, host_bootsessionuuid,
CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NOAUTO | CTLFLAG_LOCKED,
NULL, 0,
sysctl_get_bootsessionuuid, "A",
"host boot session UUID");
/* Not dynamic, no need to manually register. */
static SYSCTL_PROC(_kern, OID_AUTO, hv_vmm_present,
CTLTYPE_INT | CTLFLAG_ANYBODY | CTLFLAG_KERN | CTLFLAG_LOCKED,
NULL, 0,
sysctl_vmm_present, "I",
"running on a vmm");
__startup_func
static void
hvg_sysctl_init(void)
{
struct {
hvg_hcall_code_t hcall;
struct sysctl_oid *oid;
} hvg_sysctl[] = {
{
.hcall = HVG_HCALL_TRIGGER_DUMP,
.oid = &sysctl__kern_hvg_trigger_kernel_coredump,
},
{
.hcall = HVG_HCALL_GET_MABS_OFFSET,
.oid = &sysctl__kern_hvg_mabs_offset,
},
{
.hcall = HVG_HCALL_GET_BOOTSESSIONUUID,
.oid = &sysctl__kern_hvg_host_bootsessionuuid,
},
};
#define countof(x) (sizeof(x) / sizeof(x[0]))
for (int i = 0; i < countof(hvg_sysctl); i++) {
if (hvg_is_hcall_available(hvg_sysctl[i].hcall)) {
sysctl_register_oid_early(hvg_sysctl[i].oid);
}
}
}
STARTUP(SYSCTL, STARTUP_RANK_MIDDLE, hvg_sysctl_init);