| 1 |
/* SPDX-License-Identifier: LGPL-2.1-or-later */ |
| 2 |
|
| 3 |
#if defined(__i386__) || defined(__x86_64__) |
| 4 |
#include <cpuid.h> |
| 5 |
#endif |
| 6 |
#include <stdlib.h> |
| 7 |
#include <threads.h> |
| 8 |
#include <unistd.h> |
| 9 |
|
| 10 |
#include "alloc-util.h" |
| 11 |
#include "dirent-util.h" /* IWYU pragma: keep */ |
| 12 |
#include "env-util.h" |
| 13 |
#include "extract-word.h" |
| 14 |
#include "fd-util.h" |
| 15 |
#include "fileio.h" |
| 16 |
#include "log.h" |
| 17 |
#include "namespace-util.h" |
| 18 |
#include "parse-util.h" |
| 19 |
#include "process-util.h" |
| 20 |
#include "stat-util.h" |
| 21 |
#include "string-table.h" |
| 22 |
#include "string-util.h" |
| 23 |
#include "strv.h" |
| 24 |
#include "virt.h" |
| 25 |
|
| 26 |
enum { |
| 27 |
SMBIOS_VM_BIT_SET, |
| 28 |
SMBIOS_VM_BIT_UNSET, |
| 29 |
SMBIOS_VM_BIT_UNKNOWN, |
| 30 |
}; |
| 31 |
|
| 32 |
static Virtualization detect_vm_cpuid(void) { |
| 33 |
|
| 34 |
/* CPUID is an x86 specific interface. */ |
| 35 |
#if defined(__i386__) || defined(__x86_64__) |
| 36 |
|
| 37 |
static const struct { |
| 38 |
const char sig[13]; |
| 39 |
Virtualization id; |
| 40 |
} vm_table[] = { |
| 41 |
{ "XenVMMXenVMM", VIRTUALIZATION_XEN }, |
| 42 |
{ "KVMKVMKVM", VIRTUALIZATION_KVM }, /* qemu with KVM */ |
| 43 |
{ "Linux KVM Hv", VIRTUALIZATION_KVM }, /* qemu with KVM + HyperV Enlightenments */ |
| 44 |
{ "TCGTCGTCGTCG", VIRTUALIZATION_QEMU }, /* qemu without KVM */ |
| 45 |
/* http://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1009458 */ |
| 46 |
{ "VMwareVMware", VIRTUALIZATION_VMWARE }, |
| 47 |
/* https://docs.microsoft.com/en-us/virtualization/hyper-v-on-windows/reference/tlfs */ |
| 48 |
{ "Microsoft Hv", VIRTUALIZATION_MICROSOFT }, |
| 49 |
/* https://wiki.freebsd.org/bhyve */ |
| 50 |
{ "bhyve bhyve ", VIRTUALIZATION_BHYVE }, |
| 51 |
{ "QNXQVMBSQG", VIRTUALIZATION_QNX }, |
| 52 |
/* https://projectacrn.org */ |
| 53 |
{ "ACRNACRNACRN", VIRTUALIZATION_ACRN }, |
| 54 |
/* https://www.lockheedmartin.com/en-us/products/Hardened-Security-for-Intel-Processors.html */ |
| 55 |
{ "SRESRESRESRE", VIRTUALIZATION_SRE }, |
| 56 |
{ "Apple VZ", VIRTUALIZATION_APPLE }, |
| 57 |
}; |
| 58 |
|
| 59 |
uint32_t eax, ebx, ecx, edx; |
| 60 |
bool hypervisor; |
| 61 |
|
| 62 |
/* http://lwn.net/Articles/301888/ */ |
| 63 |
|
| 64 |
/* First detect whether there is a hypervisor */ |
| 65 |
if (__get_cpuid(1, &eax, &ebx, &ecx, &edx) == 0) |
| 66 |
return VIRTUALIZATION_NONE; |
| 67 |
|
| 68 |
hypervisor = ecx & 0x80000000U; |
| 69 |
|
| 70 |
if (hypervisor) { |
| 71 |
union { |
| 72 |
uint32_t sig32[3]; |
| 73 |
char text[13]; |
| 74 |
} sig = {}; |
| 75 |
|
| 76 |
/* There is a hypervisor, see what it is */ |
| 77 |
__cpuid(0x40000000U, eax, ebx, ecx, edx); |
| 78 |
|
| 79 |
sig.sig32[0] = ebx; |
| 80 |
sig.sig32[1] = ecx; |
| 81 |
sig.sig32[2] = edx; |
| 82 |
|
| 83 |
log_debug("Virtualization found, CPUID=%s", sig.text); |
| 84 |
|
| 85 |
FOREACH_ELEMENT(vm, vm_table) |
| 86 |
if (memcmp_nn(sig.text, sizeof(sig.text), |
| 87 |
vm->sig, sizeof(vm->sig)) == 0) |
| 88 |
return vm->id; |
| 89 |
|
| 90 |
log_debug("Unknown virtualization with CPUID=%s. Add to vm_table[]?", sig.text); |
| 91 |
return VIRTUALIZATION_VM_OTHER; |
| 92 |
} |
| 93 |
#endif |
| 94 |
log_debug("No virtualization found in CPUID"); |
| 95 |
|
| 96 |
return VIRTUALIZATION_NONE; |
| 97 |
} |
| 98 |
|
| 99 |
static Virtualization detect_vm_device_tree(void) { |
| 100 |
#if defined(__arm__) || defined(__aarch64__) || defined(__powerpc__) || defined(__powerpc64__) || defined(__riscv) |
| 101 |
_cleanup_free_ char *hvtype = NULL; |
| 102 |
int r; |
| 103 |
|
| 104 |
r = read_one_line_file("/proc/device-tree/hypervisor/compatible", &hvtype); |
| 105 |
if (r == -ENOENT) { |
| 106 |
if (access("/proc/device-tree/ibm,partition-name", F_OK) == 0 && |
| 107 |
access("/proc/device-tree/hmc-managed?", F_OK) == 0 && |
| 108 |
access("/proc/device-tree/chosen/qemu,graphic-width", F_OK) != 0) |
| 109 |
return VIRTUALIZATION_POWERVM; |
| 110 |
|
| 111 |
_cleanup_closedir_ DIR *dir = opendir("/proc/device-tree"); |
| 112 |
if (!dir) { |
| 113 |
if (errno == ENOENT) { |
| 114 |
log_debug_errno(errno, "/proc/device-tree/ does not exist"); |
| 115 |
return VIRTUALIZATION_NONE; |
| 116 |
} |
| 117 |
return log_debug_errno(errno, "Opening /proc/device-tree/ failed: %m"); |
| 118 |
} |
| 119 |
|
| 120 |
FOREACH_DIRENT(de, dir, return log_debug_errno(errno, "Failed to enumerate /proc/device-tree/ contents: %m")) |
| 121 |
if (strstr(de->d_name, "fw-cfg")) { |
| 122 |
log_debug("Virtualization QEMU: \"fw-cfg\" present in /proc/device-tree/%s", de->d_name); |
| 123 |
return VIRTUALIZATION_QEMU; |
| 124 |
} |
| 125 |
|
| 126 |
_cleanup_free_ char *compat = NULL; |
| 127 |
r = read_one_line_file("/proc/device-tree/compatible", &compat); |
| 128 |
if (r < 0 && r != -ENOENT) |
| 129 |
return log_debug_errno(r, "Failed to read /proc/device-tree/compatible: %m"); |
| 130 |
if (r >= 0) { |
| 131 |
if (streq(compat, "qemu,pseries")) { |
| 132 |
log_debug("Virtualization %s found in /proc/device-tree/compatible", compat); |
| 133 |
return VIRTUALIZATION_QEMU; |
| 134 |
} |
| 135 |
if (streq(compat, "linux,dummy-virt")) { |
| 136 |
/* https://www.kernel.org/doc/Documentation/devicetree/bindings/arm/linux%2Cdummy-virt.yaml */ |
| 137 |
log_debug("Generic virtualization %s found in /proc/device-tree/compatible", compat); |
| 138 |
return VIRTUALIZATION_VM_OTHER; |
| 139 |
} |
| 140 |
} |
| 141 |
|
| 142 |
log_debug("No virtualization found in /proc/device-tree/*"); |
| 143 |
return VIRTUALIZATION_NONE; |
| 144 |
} else if (r < 0) |
| 145 |
return r; |
| 146 |
|
| 147 |
log_debug("Virtualization %s found in /proc/device-tree/hypervisor/compatible", hvtype); |
| 148 |
if (streq(hvtype, "linux,kvm")) |
| 149 |
return VIRTUALIZATION_KVM; |
| 150 |
else if (strstr(hvtype, "xen")) |
| 151 |
return VIRTUALIZATION_XEN; |
| 152 |
else if (strstr(hvtype, "vmware")) |
| 153 |
return VIRTUALIZATION_VMWARE; |
| 154 |
else |
| 155 |
return VIRTUALIZATION_VM_OTHER; |
| 156 |
#else |
| 157 |
log_debug("This platform does not support /proc/device-tree"); |
| 158 |
return VIRTUALIZATION_NONE; |
| 159 |
#endif |
| 160 |
} |
| 161 |
|
| 162 |
#if defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__aarch64__) || defined(__loongarch_lp64) || defined(__riscv) |
| 163 |
static Virtualization detect_vm_dmi_vendor(void) { |
| 164 |
static const char* const dmi_vendors[] = { |
| 165 |
"/sys/class/dmi/id/product_name", /* Test this before sys_vendor to detect KVM over QEMU */ |
| 166 |
"/sys/class/dmi/id/sys_vendor", |
| 167 |
"/sys/class/dmi/id/board_vendor", |
| 168 |
"/sys/class/dmi/id/bios_vendor", |
| 169 |
"/sys/class/dmi/id/product_version", /* For Hyper-V VMs test */ |
| 170 |
NULL |
| 171 |
}; |
| 172 |
|
| 173 |
static const struct { |
| 174 |
const char *vendor; |
| 175 |
Virtualization id; |
| 176 |
} dmi_vendor_table[] = { |
| 177 |
{ "KVM", VIRTUALIZATION_KVM }, |
| 178 |
{ "OpenStack", VIRTUALIZATION_KVM }, /* Detect OpenStack instance as KVM in non x86 architecture */ |
| 179 |
{ "KubeVirt", VIRTUALIZATION_KVM }, /* Detect KubeVirt instance as KVM in non x86 architecture */ |
| 180 |
{ "Amazon EC2", VIRTUALIZATION_AMAZON }, |
| 181 |
{ "QEMU", VIRTUALIZATION_QEMU }, |
| 182 |
{ "VMware", VIRTUALIZATION_VMWARE }, /* https://kb.vmware.com/s/article/1009458 */ |
| 183 |
{ "VMW", VIRTUALIZATION_VMWARE }, |
| 184 |
{ "innotek GmbH", VIRTUALIZATION_ORACLE }, |
| 185 |
{ "VirtualBox", VIRTUALIZATION_ORACLE }, |
| 186 |
{ "Oracle Corporation", VIRTUALIZATION_ORACLE }, /* Detect VirtualBox on some proprietary systems via the board_vendor */ |
| 187 |
{ "Xen", VIRTUALIZATION_XEN }, |
| 188 |
{ "Bochs", VIRTUALIZATION_BOCHS }, |
| 189 |
{ "Parallels", VIRTUALIZATION_PARALLELS }, |
| 190 |
/* https://wiki.freebsd.org/bhyve */ |
| 191 |
{ "BHYVE", VIRTUALIZATION_BHYVE }, |
| 192 |
{ "Hyper-V", VIRTUALIZATION_MICROSOFT }, |
| 193 |
{ "Apple Virtualization", VIRTUALIZATION_APPLE }, |
| 194 |
{ "Google Compute Engine", VIRTUALIZATION_GOOGLE }, /* https://cloud.google.com/run/docs/container-contract#sandbox */ |
| 195 |
}; |
| 196 |
int r; |
| 197 |
|
| 198 |
STRV_FOREACH(vendor, dmi_vendors) { |
| 199 |
_cleanup_free_ char *s = NULL; |
| 200 |
|
| 201 |
r = read_one_line_file(*vendor, &s); |
| 202 |
if (r == -ENOENT) |
| 203 |
continue; |
| 204 |
if (r < 0) |
| 205 |
return r; |
| 206 |
|
| 207 |
FOREACH_ELEMENT(dmi_vendor, dmi_vendor_table) |
| 208 |
if (startswith(s, dmi_vendor->vendor)) { |
| 209 |
log_debug("Virtualization %s found in DMI (%s)", s, *vendor); |
| 210 |
return dmi_vendor->id; |
| 211 |
} |
| 212 |
} |
| 213 |
log_debug("No virtualization found in DMI vendor table."); |
| 214 |
return VIRTUALIZATION_NONE; |
| 215 |
} |
| 216 |
|
| 217 |
static int detect_vm_smbios(void) { |
| 218 |
/* The SMBIOS BIOS Characteristics Extension Byte 2 (Section 2.1.2.2 of |
| 219 |
* https://www.dmtf.org/sites/default/files/standards/documents/DSP0134_3.4.0.pdf), specifies that |
| 220 |
* the 4th bit being set indicates a VM. The BIOS Characteristics table is exposed via the kernel in |
| 221 |
* /sys/firmware/dmi/entries/0-0. Note that in the general case, this bit being unset should not |
| 222 |
* imply that the system is running on bare-metal. For example, QEMU 3.1.0 (with or without KVM) |
| 223 |
* with SeaBIOS does not set this bit. */ |
| 224 |
_cleanup_free_ char *s = NULL; |
| 225 |
size_t readsize; |
| 226 |
int r; |
| 227 |
|
| 228 |
r = read_full_virtual_file("/sys/firmware/dmi/entries/0-0/raw", &s, &readsize); |
| 229 |
if (r < 0) { |
| 230 |
log_debug_errno(r, "Unable to read /sys/firmware/dmi/entries/0-0/raw, " |
| 231 |
"using the virtualization information found in DMI vendor table, ignoring: %m"); |
| 232 |
return SMBIOS_VM_BIT_UNKNOWN; |
| 233 |
} |
| 234 |
if (readsize < 20 || s[1] < 20) { |
| 235 |
/* The spec indicates that byte 1 contains the size of the table, 0x12 + the number of |
| 236 |
* extension bytes. The data we're interested in is in extension byte 2, which would be at |
| 237 |
* 0x13. If we didn't read that much data, or if the BIOS indicates that we don't have that |
| 238 |
* much data, we don't infer anything from the SMBIOS. */ |
| 239 |
log_debug("Only read %zu bytes from /sys/firmware/dmi/entries/0-0/raw (expected 20). " |
| 240 |
"Using the virtualization information found in DMI vendor table.", readsize); |
| 241 |
return SMBIOS_VM_BIT_UNKNOWN; |
| 242 |
} |
| 243 |
|
| 244 |
uint8_t byte = (uint8_t) s[19]; |
| 245 |
if (byte & (1U<<4)) { |
| 246 |
log_debug("DMI BIOS Extension table indicates virtualization."); |
| 247 |
return SMBIOS_VM_BIT_SET; |
| 248 |
} |
| 249 |
log_debug("DMI BIOS Extension table does not indicate virtualization."); |
| 250 |
return SMBIOS_VM_BIT_UNSET; |
| 251 |
} |
| 252 |
#endif /* defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__aarch64__) || defined(__loongarch_lp64) */ |
| 253 |
|
| 254 |
static Virtualization detect_vm_dmi(void) { |
| 255 |
#if defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__aarch64__) || defined(__loongarch_lp64) || defined(__riscv) |
| 256 |
|
| 257 |
int r; |
| 258 |
r = detect_vm_dmi_vendor(); |
| 259 |
|
| 260 |
/* The DMI vendor tables in /sys/class/dmi/id don't help us distinguish between Amazon EC2 |
| 261 |
* virtual machines and bare-metal instances, so we need to look at SMBIOS. */ |
| 262 |
if (r == VIRTUALIZATION_AMAZON) { |
| 263 |
switch (detect_vm_smbios()) { |
| 264 |
case SMBIOS_VM_BIT_SET: |
| 265 |
return VIRTUALIZATION_AMAZON; |
| 266 |
case SMBIOS_VM_BIT_UNSET: |
| 267 |
return VIRTUALIZATION_NONE; |
| 268 |
case SMBIOS_VM_BIT_UNKNOWN: { |
| 269 |
/* The DMI information we are after is only accessible to the root user, |
| 270 |
* so we fallback to using the product name which is less restricted |
| 271 |
* to distinguish metal systems from virtualized instances */ |
| 272 |
_cleanup_free_ char *s = NULL; |
| 273 |
const char *e; |
| 274 |
|
| 275 |
r = read_full_virtual_file("/sys/class/dmi/id/product_name", &s, NULL); |
| 276 |
/* In EC2, virtualized is much more common than metal, so if for some reason |
| 277 |
* we fail to read the DMI data, assume we are virtualized. */ |
| 278 |
if (r < 0) { |
| 279 |
log_debug_errno(r, "Can't read /sys/class/dmi/id/product_name," |
| 280 |
" assuming virtualized: %m"); |
| 281 |
return VIRTUALIZATION_AMAZON; |
| 282 |
} |
| 283 |
e = strstrafter(truncate_nl(s), ".metal"); |
| 284 |
if (e && IN_SET(*e, 0, '-')) { |
| 285 |
log_debug("DMI product name has '.metal', assuming no virtualization"); |
| 286 |
return VIRTUALIZATION_NONE; |
| 287 |
} else |
| 288 |
return VIRTUALIZATION_AMAZON; |
| 289 |
} |
| 290 |
default: |
| 291 |
assert_not_reached(); |
| 292 |
} |
| 293 |
} |
| 294 |
|
| 295 |
/* If we haven't identified a VM, but the firmware indicates that there is one, indicate as much. We |
| 296 |
* have no further information about what it is. */ |
| 297 |
if (r == VIRTUALIZATION_NONE && detect_vm_smbios() == SMBIOS_VM_BIT_SET) |
| 298 |
return VIRTUALIZATION_VM_OTHER; |
| 299 |
return r; |
| 300 |
#else |
| 301 |
return VIRTUALIZATION_NONE; |
| 302 |
#endif |
| 303 |
} |
| 304 |
|
| 305 |
#define XENFEAT_dom0 11 /* xen/include/public/features.h */ |
| 306 |
#define PATH_FEATURES "/sys/hypervisor/properties/features" |
| 307 |
/* Returns -errno, or 0 for domU, or 1 for dom0 */ |
| 308 |
static int detect_vm_xen_dom0(void) { |
| 309 |
_cleanup_free_ char *domcap = NULL; |
| 310 |
int r; |
| 311 |
|
| 312 |
r = read_one_line_file(PATH_FEATURES, &domcap); |
| 313 |
if (r < 0 && r != -ENOENT) |
| 314 |
return r; |
| 315 |
if (r >= 0) { |
| 316 |
unsigned long features; |
| 317 |
|
| 318 |
/* Here, we need to use sscanf() instead of safe_atoul() |
| 319 |
* as the string lacks the leading "0x". */ |
| 320 |
r = sscanf(domcap, "%lx", &features); |
| 321 |
if (r == 1) { |
| 322 |
r = !!(features & (1U << XENFEAT_dom0)); |
| 323 |
log_debug("Virtualization XEN, found %s with value %08lx, " |
| 324 |
"XENFEAT_dom0 (indicating the 'hardware domain') is%s set.", |
| 325 |
PATH_FEATURES, features, r ? "" : " not"); |
| 326 |
return r; |
| 327 |
} |
| 328 |
log_debug("Virtualization XEN, found %s, unhandled content '%s'", |
| 329 |
PATH_FEATURES, domcap); |
| 330 |
} |
| 331 |
|
| 332 |
r = read_one_line_file("/proc/xen/capabilities", &domcap); |
| 333 |
if (r == -ENOENT) { |
| 334 |
log_debug("Virtualization XEN because /proc/xen/capabilities does not exist"); |
| 335 |
return 0; |
| 336 |
} |
| 337 |
if (r < 0) |
| 338 |
return r; |
| 339 |
|
| 340 |
for (const char *i = domcap;;) { |
| 341 |
_cleanup_free_ char *cap = NULL; |
| 342 |
|
| 343 |
r = extract_first_word(&i, &cap, ",", 0); |
| 344 |
if (r < 0) |
| 345 |
return r; |
| 346 |
if (r == 0) { |
| 347 |
log_debug("Virtualization XEN DomU found (/proc/xen/capabilities)"); |
| 348 |
return 0; |
| 349 |
} |
| 350 |
|
| 351 |
if (streq(cap, "control_d")) { |
| 352 |
log_debug("Virtualization XEN Dom0 ignored (/proc/xen/capabilities)"); |
| 353 |
return 1; |
| 354 |
} |
| 355 |
} |
| 356 |
} |
| 357 |
|
| 358 |
static Virtualization detect_vm_xen(void) { |
| 359 |
/* The presence of /proc/xen indicates some form of a Xen domain |
| 360 |
The check for Dom0 is handled outside this function */ |
| 361 |
if (access("/proc/xen", F_OK) < 0) { |
| 362 |
log_debug("Virtualization XEN not found, /proc/xen does not exist"); |
| 363 |
return VIRTUALIZATION_NONE; |
| 364 |
} |
| 365 |
log_debug("Virtualization XEN found (/proc/xen exists)"); |
| 366 |
return VIRTUALIZATION_XEN; |
| 367 |
} |
| 368 |
|
| 369 |
static Virtualization detect_vm_hypervisor(void) { |
| 370 |
_cleanup_free_ char *hvtype = NULL; |
| 371 |
int r; |
| 372 |
|
| 373 |
r = read_one_line_file("/sys/hypervisor/type", &hvtype); |
| 374 |
if (r == -ENOENT) |
| 375 |
return VIRTUALIZATION_NONE; |
| 376 |
if (r < 0) |
| 377 |
return r; |
| 378 |
|
| 379 |
log_debug("Virtualization %s found in /sys/hypervisor/type", hvtype); |
| 380 |
|
| 381 |
if (streq(hvtype, "xen")) |
| 382 |
return VIRTUALIZATION_XEN; |
| 383 |
else |
| 384 |
return VIRTUALIZATION_VM_OTHER; |
| 385 |
} |
| 386 |
|
| 387 |
static Virtualization detect_vm_uml(void) { |
| 388 |
_cleanup_fclose_ FILE *f = NULL; |
| 389 |
int r; |
| 390 |
|
| 391 |
/* Detect User-Mode Linux by reading /proc/cpuinfo */ |
| 392 |
f = fopen("/proc/cpuinfo", "re"); |
| 393 |
if (!f) { |
| 394 |
if (errno == ENOENT) { |
| 395 |
log_debug("/proc/cpuinfo not found, assuming no UML virtualization."); |
| 396 |
return VIRTUALIZATION_NONE; |
| 397 |
} |
| 398 |
return -errno; |
| 399 |
} |
| 400 |
|
| 401 |
for (;;) { |
| 402 |
_cleanup_free_ char *line = NULL; |
| 403 |
const char *t; |
| 404 |
|
| 405 |
r = read_line(f, LONG_LINE_MAX, &line); |
| 406 |
if (r < 0) |
| 407 |
return r; |
| 408 |
if (r == 0) |
| 409 |
break; |
| 410 |
|
| 411 |
t = startswith(line, "vendor_id\t: "); |
| 412 |
if (t) { |
| 413 |
if (startswith(t, "User Mode Linux")) { |
| 414 |
log_debug("UML virtualization found in /proc/cpuinfo"); |
| 415 |
return VIRTUALIZATION_UML; |
| 416 |
} |
| 417 |
|
| 418 |
break; |
| 419 |
} |
| 420 |
} |
| 421 |
|
| 422 |
log_debug("UML virtualization not found in /proc/cpuinfo."); |
| 423 |
return VIRTUALIZATION_NONE; |
| 424 |
} |
| 425 |
|
| 426 |
static Virtualization detect_vm_zvm(void) { |
| 427 |
|
| 428 |
#if defined(__s390__) |
| 429 |
_cleanup_free_ char *t = NULL; |
| 430 |
int r; |
| 431 |
|
| 432 |
r = get_proc_field("/proc/sysinfo", "VM00 Control Program", &t); |
| 433 |
if (IN_SET(r, -ENOENT, -ENODATA)) |
| 434 |
return VIRTUALIZATION_NONE; |
| 435 |
if (r < 0) |
| 436 |
return r; |
| 437 |
|
| 438 |
log_debug("Virtualization %s found in /proc/sysinfo", t); |
| 439 |
if (streq(t, "z/VM")) |
| 440 |
return VIRTUALIZATION_ZVM; |
| 441 |
else |
| 442 |
return VIRTUALIZATION_KVM; |
| 443 |
#else |
| 444 |
log_debug("This platform does not support /proc/sysinfo"); |
| 445 |
return VIRTUALIZATION_NONE; |
| 446 |
#endif |
| 447 |
} |
| 448 |
|
| 449 |
/* Returns a short identifier for the various VM implementations */ |
| 450 |
Virtualization detect_vm(void) { |
| 451 |
static thread_local Virtualization cached_found = _VIRTUALIZATION_INVALID; |
| 452 |
bool other = false, hyperv = false; |
| 453 |
int xen_dom0 = 0; |
| 454 |
Virtualization v, dmi; |
| 455 |
|
| 456 |
if (cached_found >= 0) |
| 457 |
return cached_found; |
| 458 |
|
| 459 |
/* We have to use the correct order here: |
| 460 |
* |
| 461 |
* → First, try to detect Oracle Virtualbox, Amazon EC2 Nitro, Parallels, and Google Compute Engine, |
| 462 |
* even if they use KVM, as well as Xen, even if it cloaks as Microsoft Hyper-V. Attempt to detect |
| 463 |
* UML at this stage too, since it runs as a user-process nested inside other VMs. Also check for |
| 464 |
* Xen now, because Xen PV mode does not override CPUID when nested inside another hypervisor. |
| 465 |
* |
| 466 |
* → Second, try to detect from CPUID. This will report KVM for whatever software is used even if |
| 467 |
* info in DMI is overwritten. |
| 468 |
* |
| 469 |
* → Third, try to detect from DMI. */ |
| 470 |
|
| 471 |
dmi = detect_vm_dmi(); |
| 472 |
if (IN_SET(dmi, |
| 473 |
VIRTUALIZATION_ORACLE, |
| 474 |
VIRTUALIZATION_XEN, |
| 475 |
VIRTUALIZATION_AMAZON, |
| 476 |
/* Unable to distinguish a GCE machine from a VM to bare-metal |
| 477 |
* for non-x86 architectures due to its necessity for cpuid |
| 478 |
* detection, which functions solely on x86 platforms. Report |
| 479 |
* as a VM for other architectures. */ |
| 480 |
#if !defined(__i386__) && !defined(__x86_64__) |
| 481 |
VIRTUALIZATION_GOOGLE, |
| 482 |
#endif |
| 483 |
VIRTUALIZATION_PARALLELS)) { |
| 484 |
v = dmi; |
| 485 |
goto finish; |
| 486 |
} |
| 487 |
|
| 488 |
/* Detect UML */ |
| 489 |
v = detect_vm_uml(); |
| 490 |
if (v < 0) |
| 491 |
return v; |
| 492 |
if (v != VIRTUALIZATION_NONE) |
| 493 |
goto finish; |
| 494 |
|
| 495 |
/* Detect Xen */ |
| 496 |
v = detect_vm_xen(); |
| 497 |
if (v < 0) |
| 498 |
return v; |
| 499 |
if (v == VIRTUALIZATION_XEN) { |
| 500 |
/* If we are Dom0, then we expect to not report as a VM. However, as we might be nested |
| 501 |
* inside another hypervisor which can be detected via the CPUID check, wait to report this |
| 502 |
* until after the CPUID check. */ |
| 503 |
xen_dom0 = detect_vm_xen_dom0(); |
| 504 |
if (xen_dom0 < 0) |
| 505 |
return xen_dom0; |
| 506 |
if (xen_dom0 == 0) |
| 507 |
goto finish; |
| 508 |
} else if (v != VIRTUALIZATION_NONE) |
| 509 |
assert_not_reached(); |
| 510 |
|
| 511 |
/* Detect from CPUID */ |
| 512 |
v = detect_vm_cpuid(); |
| 513 |
if (v < 0) |
| 514 |
return v; |
| 515 |
if (v == VIRTUALIZATION_MICROSOFT) |
| 516 |
/* QEMU sets the CPUID string to hyperv's, in case it provides hyperv enlightenments. Let's |
| 517 |
* hence not return Microsoft here but just use the other mechanisms first to make a better |
| 518 |
* decision. */ |
| 519 |
hyperv = true; |
| 520 |
else if (v == VIRTUALIZATION_VM_OTHER) |
| 521 |
other = true; |
| 522 |
else if (v == VIRTUALIZATION_KVM && dmi == VIRTUALIZATION_GOOGLE) |
| 523 |
/* The DMI vendor tables in /sys/class/dmi/id don't help us distinguish between GCE |
| 524 |
* virtual machines and bare-metal instances, so we need to look at hypervisor. */ |
| 525 |
return VIRTUALIZATION_GOOGLE; |
| 526 |
else if (v != VIRTUALIZATION_NONE) |
| 527 |
goto finish; |
| 528 |
|
| 529 |
/* If we are in Dom0 and have not yet finished, finish with the result of detect_vm_cpuid */ |
| 530 |
if (xen_dom0 > 0) |
| 531 |
goto finish; |
| 532 |
|
| 533 |
/* Now, let's get back to DMI */ |
| 534 |
if (dmi < 0) |
| 535 |
return dmi; |
| 536 |
if (dmi == VIRTUALIZATION_VM_OTHER) |
| 537 |
other = true; |
| 538 |
else if (!IN_SET(dmi, VIRTUALIZATION_NONE, VIRTUALIZATION_GOOGLE)) { |
| 539 |
/* At this point if GCE has been detected in dmi, do not report as a VM. It should |
| 540 |
* be a bare-metal machine */ |
| 541 |
v = dmi; |
| 542 |
goto finish; |
| 543 |
} |
| 544 |
|
| 545 |
/* Check high-level hypervisor sysfs file */ |
| 546 |
v = detect_vm_hypervisor(); |
| 547 |
if (v < 0) |
| 548 |
return v; |
| 549 |
if (v == VIRTUALIZATION_VM_OTHER) |
| 550 |
other = true; |
| 551 |
else if (v != VIRTUALIZATION_NONE) |
| 552 |
goto finish; |
| 553 |
|
| 554 |
v = detect_vm_device_tree(); |
| 555 |
if (v < 0) |
| 556 |
return v; |
| 557 |
if (v == VIRTUALIZATION_VM_OTHER) |
| 558 |
other = true; |
| 559 |
else if (v != VIRTUALIZATION_NONE) |
| 560 |
goto finish; |
| 561 |
|
| 562 |
v = detect_vm_zvm(); |
| 563 |
if (v < 0) |
| 564 |
return v; |
| 565 |
|
| 566 |
finish: |
| 567 |
/* None of the checks above gave us a clear answer, hence let's now use fallback logic: if hyperv |
| 568 |
* enlightenments are available but the VMM wasn't recognized as anything yet, it's probably |
| 569 |
* Microsoft. */ |
| 570 |
if (v == VIRTUALIZATION_NONE) { |
| 571 |
if (hyperv) |
| 572 |
v = VIRTUALIZATION_MICROSOFT; |
| 573 |
else if (other) |
| 574 |
v = VIRTUALIZATION_VM_OTHER; |
| 575 |
} |
| 576 |
|
| 577 |
cached_found = v; |
| 578 |
log_debug("Found VM virtualization %s", virtualization_to_string(v)); |
| 579 |
return v; |
| 580 |
} |
| 581 |
|
| 582 |
static const char *const container_table[_VIRTUALIZATION_MAX] = { |
| 583 |
[VIRTUALIZATION_LXC] = "lxc", |
| 584 |
[VIRTUALIZATION_LXC_LIBVIRT] = "lxc-libvirt", |
| 585 |
[VIRTUALIZATION_SYSTEMD_NSPAWN] = "systemd-nspawn", |
| 586 |
[VIRTUALIZATION_DOCKER] = "docker", |
| 587 |
[VIRTUALIZATION_PODMAN] = "podman", |
| 588 |
[VIRTUALIZATION_RKT] = "rkt", |
| 589 |
[VIRTUALIZATION_WSL] = "wsl", |
| 590 |
[VIRTUALIZATION_PROOT] = "proot", |
| 591 |
[VIRTUALIZATION_POUCH] = "pouch", |
| 592 |
}; |
| 593 |
|
| 594 |
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(container, int); |
| 595 |
|
| 596 |
static int running_in_pidns(void) { |
| 597 |
int r; |
| 598 |
|
| 599 |
r = namespace_is_init(NAMESPACE_PID); |
| 600 |
if (r < 0) |
| 601 |
return log_debug_errno(r, "Failed to test if in root PID namespace, ignoring: %m"); |
| 602 |
|
| 603 |
return !r; |
| 604 |
} |
| 605 |
|
| 606 |
static Virtualization detect_container_files(void) { |
| 607 |
static const struct { |
| 608 |
const char *file_path; |
| 609 |
Virtualization id; |
| 610 |
} container_file_table[] = { |
| 611 |
/* https://github.com/containers/podman/issues/6192 */ |
| 612 |
/* https://github.com/containers/podman/issues/3586#issuecomment-661918679 */ |
| 613 |
{ "/run/.containerenv", VIRTUALIZATION_PODMAN }, |
| 614 |
/* https://github.com/moby/moby/issues/18355 */ |
| 615 |
/* Docker must be the last in this table, see below. */ |
| 616 |
{ "/.dockerenv", VIRTUALIZATION_DOCKER }, |
| 617 |
}; |
| 618 |
|
| 619 |
FOREACH_ELEMENT(file, container_file_table) { |
| 620 |
if (access(file->file_path, F_OK) >= 0) |
| 621 |
return file->id; |
| 622 |
|
| 623 |
if (errno != ENOENT) |
| 624 |
log_debug_errno(errno, |
| 625 |
"Checking if %s exists failed, ignoring: %m", |
| 626 |
file->file_path); |
| 627 |
} |
| 628 |
|
| 629 |
return VIRTUALIZATION_NONE; |
| 630 |
} |
| 631 |
|
| 632 |
Virtualization detect_container(void) { |
| 633 |
static thread_local Virtualization cached_found = _VIRTUALIZATION_INVALID; |
| 634 |
_cleanup_free_ char *m = NULL, *o = NULL, *p = NULL; |
| 635 |
const char *e = NULL; |
| 636 |
Virtualization v; |
| 637 |
int r; |
| 638 |
|
| 639 |
if (cached_found >= 0) |
| 640 |
return cached_found; |
| 641 |
|
| 642 |
/* /proc/vz exists in container and outside of the container, /proc/bc only outside of the container. */ |
| 643 |
if (access("/proc/vz", F_OK) < 0) { |
| 644 |
if (errno != ENOENT) |
| 645 |
log_debug_errno(errno, "Failed to check if /proc/vz exists, ignoring: %m"); |
| 646 |
} else if (access("/proc/bc", F_OK) < 0) { |
| 647 |
if (errno == ENOENT) { |
| 648 |
v = VIRTUALIZATION_OPENVZ; |
| 649 |
goto finish; |
| 650 |
} |
| 651 |
|
| 652 |
log_debug_errno(errno, "Failed to check if /proc/bc exists, ignoring: %m"); |
| 653 |
} |
| 654 |
|
| 655 |
/* "Official" way of detecting WSL https://github.com/Microsoft/WSL/issues/423#issuecomment-221627364 */ |
| 656 |
r = read_one_line_file("/proc/sys/kernel/osrelease", &o); |
| 657 |
if (r < 0) |
| 658 |
log_debug_errno(r, "Failed to read /proc/sys/kernel/osrelease, ignoring: %m"); |
| 659 |
else if (strstr(o, "Microsoft") || strstr(o, "WSL")) { |
| 660 |
v = VIRTUALIZATION_WSL; |
| 661 |
goto finish; |
| 662 |
} |
| 663 |
|
| 664 |
/* proot doesn't use PID namespacing, so we can just check if we have a matching tracer for this |
| 665 |
* invocation without worrying about it being elsewhere. |
| 666 |
*/ |
| 667 |
r = get_proc_field("/proc/self/status", "TracerPid", &p); |
| 668 |
if (r < 0) |
| 669 |
log_debug_errno(r, "Failed to read our own trace PID, ignoring: %m"); |
| 670 |
else if (!streq(p, "0")) { |
| 671 |
pid_t ptrace_pid; |
| 672 |
|
| 673 |
r = parse_pid(p, &ptrace_pid); |
| 674 |
if (r < 0) |
| 675 |
log_debug_errno(r, "Failed to parse our own tracer PID, ignoring: %m"); |
| 676 |
else { |
| 677 |
_cleanup_free_ char *ptrace_comm = NULL; |
| 678 |
const char *pf; |
| 679 |
|
| 680 |
pf = procfs_file_alloca(ptrace_pid, "comm"); |
| 681 |
r = read_one_line_file(pf, &ptrace_comm); |
| 682 |
if (r < 0) |
| 683 |
log_debug_errno(r, "Failed to read %s, ignoring: %m", pf); |
| 684 |
else if (startswith(ptrace_comm, "proot")) { |
| 685 |
v = VIRTUALIZATION_PROOT; |
| 686 |
goto finish; |
| 687 |
} |
| 688 |
} |
| 689 |
} |
| 690 |
|
| 691 |
/* The container manager might have placed this in the /run/host/ hierarchy for us, which is best |
| 692 |
* because we can be consumed just like that, without special privileges. */ |
| 693 |
r = read_one_line_file("/run/host/container-manager", &m); |
| 694 |
if (r > 0) { |
| 695 |
e = m; |
| 696 |
goto translate_name; |
| 697 |
} |
| 698 |
if (!IN_SET(r, -ENOENT, 0)) |
| 699 |
return log_debug_errno(r, "Failed to read /run/host/container-manager: %m"); |
| 700 |
|
| 701 |
if (getpid_cached() == 1) { |
| 702 |
/* If we are PID 1 we can just check our own environment variable, and that's authoritative. |
| 703 |
* We distinguish three cases: |
| 704 |
* - the variable is not defined → we jump to other checks |
| 705 |
* - the variable is defined to an empty value → we are not in a container |
| 706 |
* - anything else → some container, either one of the known ones or "container-other" |
| 707 |
*/ |
| 708 |
e = getenv("container"); |
| 709 |
if (!e) |
| 710 |
goto check_files; |
| 711 |
if (isempty(e)) { |
| 712 |
v = VIRTUALIZATION_NONE; |
| 713 |
goto finish; |
| 714 |
} |
| 715 |
|
| 716 |
goto translate_name; |
| 717 |
} |
| 718 |
|
| 719 |
/* Otherwise, PID 1 might have dropped this information into a file in /run. This is better than accessing |
| 720 |
* /proc/1/environ, since we don't need CAP_SYS_PTRACE for that. */ |
| 721 |
r = read_one_line_file("/run/systemd/container", &m); |
| 722 |
if (r > 0) { |
| 723 |
e = m; |
| 724 |
goto translate_name; |
| 725 |
} |
| 726 |
if (!IN_SET(r, -ENOENT, 0)) |
| 727 |
return log_debug_errno(r, "Failed to read /run/systemd/container: %m"); |
| 728 |
|
| 729 |
/* Fallback for cases where PID 1 was not systemd (for example, cases where init=/bin/sh is used. */ |
| 730 |
r = getenv_for_pid(1, "container", &m); |
| 731 |
if (r > 0) { |
| 732 |
e = m; |
| 733 |
goto translate_name; |
| 734 |
} |
| 735 |
if (r < 0) /* This only works if we have CAP_SYS_PTRACE, hence let's better ignore failures here */ |
| 736 |
log_debug_errno(r, "Failed to read $container of PID 1, ignoring: %m"); |
| 737 |
|
| 738 |
check_files: |
| 739 |
/* Check for existence of some well-known files. We only do this after checking |
| 740 |
* for other specific container managers, otherwise we risk mistaking another |
| 741 |
* container manager for Docker: the /.dockerenv file could inadvertently end up |
| 742 |
* in a file system image. */ |
| 743 |
v = detect_container_files(); |
| 744 |
if (v < 0) |
| 745 |
return v; |
| 746 |
if (v != VIRTUALIZATION_NONE) |
| 747 |
goto finish; |
| 748 |
|
| 749 |
/* Finally, the root pid namespace has an hardcoded inode number of 0xEFFFFFFC since kernel 3.8, so |
| 750 |
* if all else fails we can check the inode number of our pid namespace and compare it. */ |
| 751 |
if (running_in_pidns() > 0) { |
| 752 |
log_debug("Running in a pid namespace, assuming unknown container manager."); |
| 753 |
v = VIRTUALIZATION_CONTAINER_OTHER; |
| 754 |
goto finish; |
| 755 |
} |
| 756 |
|
| 757 |
/* If none of that worked, give up, assume no container manager. */ |
| 758 |
v = VIRTUALIZATION_NONE; |
| 759 |
goto finish; |
| 760 |
|
| 761 |
translate_name: |
| 762 |
if (streq(e, "oci")) { |
| 763 |
/* Some images hardcode container=oci, but OCI is not a specific container manager. |
| 764 |
* Try to detect one based on well-known files. */ |
| 765 |
v = detect_container_files(); |
| 766 |
if (v == VIRTUALIZATION_NONE) |
| 767 |
v = VIRTUALIZATION_CONTAINER_OTHER; |
| 768 |
goto finish; |
| 769 |
} |
| 770 |
v = container_from_string(e); |
| 771 |
if (v < 0) |
| 772 |
v = VIRTUALIZATION_CONTAINER_OTHER; |
| 773 |
|
| 774 |
finish: |
| 775 |
log_debug("Found container virtualization %s.", virtualization_to_string(v)); |
| 776 |
cached_found = v; |
| 777 |
return v; |
| 778 |
} |
| 779 |
|
| 780 |
Virtualization detect_virtualization(void) { |
| 781 |
int v; |
| 782 |
|
| 783 |
v = detect_container(); |
| 784 |
if (v != VIRTUALIZATION_NONE) |
| 785 |
return v; |
| 786 |
|
| 787 |
return detect_vm(); |
| 788 |
} |
| 789 |
|
| 790 |
int running_in_userns(void) { |
| 791 |
int r; |
| 792 |
|
| 793 |
r = namespace_is_init(NAMESPACE_USER); |
| 794 |
if (r < 0) |
| 795 |
return log_debug_errno(r, "Failed to test if in root user namespace, ignoring: %m"); |
| 796 |
|
| 797 |
return !r; |
| 798 |
} |
| 799 |
|
| 800 |
int running_in_chroot(void) { |
| 801 |
int r; |
| 802 |
|
| 803 |
/* If we're PID1, /proc may not be mounted (and most likely we're not in a chroot). But PID1 will |
| 804 |
* mount /proc, so all other programs can assume that if /proc is *not* available, we're in some |
| 805 |
* chroot. */ |
| 806 |
|
| 807 |
r = getenv_bool("SYSTEMD_IN_CHROOT"); |
| 808 |
if (r >= 0) |
| 809 |
return r > 0; |
| 810 |
if (r != -ENXIO) |
| 811 |
log_debug_errno(r, "Failed to parse $SYSTEMD_IN_CHROOT, ignoring: %m"); |
| 812 |
|
| 813 |
/* Deprecated but kept for backwards compatibility. */ |
| 814 |
if (getenv_bool("SYSTEMD_IGNORE_CHROOT") > 0) |
| 815 |
return 0; |
| 816 |
|
| 817 |
r = inode_same("/proc/1/root", "/", /* flags= */ 0); |
| 818 |
if (r == -ENOENT) { |
| 819 |
r = proc_mounted(); |
| 820 |
if (r == 0) { |
| 821 |
if (getpid_cached() == 1) |
| 822 |
return false; /* We will mount /proc, assuming we're not in a chroot. */ |
| 823 |
|
| 824 |
log_debug("/proc/ is not mounted, assuming we're in a chroot."); |
| 825 |
return true; |
| 826 |
} |
| 827 |
if (r > 0) /* If we have fake /proc/, we can't do the check properly. */ |
| 828 |
return -ENOSYS; |
| 829 |
} |
| 830 |
if (r < 0) |
| 831 |
return log_debug_errno(r, "Failed to check if /proc/1/root and / are the same inode: %m"); |
| 832 |
|
| 833 |
return r == 0; |
| 834 |
} |
| 835 |
|
| 836 |
#if defined(__i386__) || defined(__x86_64__) |
| 837 |
struct cpuid_table_entry { |
| 838 |
uint32_t flag_bit; |
| 839 |
const char *name; |
| 840 |
}; |
| 841 |
|
| 842 |
static const struct cpuid_table_entry leaf1_edx[] = { |
| 843 |
{ 0, "fpu" }, |
| 844 |
{ 1, "vme" }, |
| 845 |
{ 2, "de" }, |
| 846 |
{ 3, "pse" }, |
| 847 |
{ 4, "tsc" }, |
| 848 |
{ 5, "msr" }, |
| 849 |
{ 6, "pae" }, |
| 850 |
{ 7, "mce" }, |
| 851 |
{ 8, "cx8" }, |
| 852 |
{ 9, "apic" }, |
| 853 |
{ 11, "sep" }, |
| 854 |
{ 12, "mtrr" }, |
| 855 |
{ 13, "pge" }, |
| 856 |
{ 14, "mca" }, |
| 857 |
{ 15, "cmov" }, |
| 858 |
{ 16, "pat" }, |
| 859 |
{ 17, "pse36" }, |
| 860 |
{ 19, "clflush" }, |
| 861 |
{ 23, "mmx" }, |
| 862 |
{ 24, "fxsr" }, |
| 863 |
{ 25, "sse" }, |
| 864 |
{ 26, "sse2" }, |
| 865 |
{ 28, "ht" }, |
| 866 |
}; |
| 867 |
|
| 868 |
static const struct cpuid_table_entry leaf1_ecx[] = { |
| 869 |
{ 0, "pni" }, |
| 870 |
{ 1, "pclmul" }, |
| 871 |
{ 3, "monitor" }, |
| 872 |
{ 9, "ssse3" }, |
| 873 |
{ 12, "fma3" }, |
| 874 |
{ 13, "cx16" }, |
| 875 |
{ 19, "sse4_1" }, |
| 876 |
{ 20, "sse4_2" }, |
| 877 |
{ 22, "movbe" }, |
| 878 |
{ 23, "popcnt" }, |
| 879 |
{ 25, "aes" }, |
| 880 |
{ 26, "xsave" }, |
| 881 |
{ 27, "osxsave" }, |
| 882 |
{ 28, "avx" }, |
| 883 |
{ 29, "f16c" }, |
| 884 |
{ 30, "rdrand" }, |
| 885 |
}; |
| 886 |
|
| 887 |
static const struct cpuid_table_entry leaf7_ebx[] = { |
| 888 |
{ 3, "bmi1" }, |
| 889 |
{ 5, "avx2" }, |
| 890 |
{ 8, "bmi2" }, |
| 891 |
{ 18, "rdseed" }, |
| 892 |
{ 19, "adx" }, |
| 893 |
{ 29, "sha_ni" }, |
| 894 |
}; |
| 895 |
|
| 896 |
static const struct cpuid_table_entry leaf81_edx[] = { |
| 897 |
{ 11, "syscall" }, |
| 898 |
{ 27, "rdtscp" }, |
| 899 |
{ 29, "lm" }, |
| 900 |
}; |
| 901 |
|
| 902 |
static const struct cpuid_table_entry leaf81_ecx[] = { |
| 903 |
{ 0, "lahf_lm" }, |
| 904 |
{ 5, "abm" }, |
| 905 |
}; |
| 906 |
|
| 907 |
static const struct cpuid_table_entry leaf87_edx[] = { |
| 908 |
{ 8, "constant_tsc" }, |
| 909 |
}; |
| 910 |
|
| 911 |
static bool given_flag_in_set(const char *flag, const struct cpuid_table_entry *set, size_t set_size, uint32_t val) { |
| 912 |
for (size_t i = 0; i < set_size; i++) { |
| 913 |
if ((UINT32_C(1) << set[i].flag_bit) & val && |
| 914 |
streq(flag, set[i].name)) |
| 915 |
return true; |
| 916 |
} |
| 917 |
return false; |
| 918 |
} |
| 919 |
|
| 920 |
static bool real_has_cpu_with_flag(const char *flag) { |
| 921 |
uint32_t eax, ebx, ecx, edx; |
| 922 |
|
| 923 |
if (__get_cpuid(1, &eax, &ebx, &ecx, &edx)) { |
| 924 |
if (given_flag_in_set(flag, leaf1_ecx, ELEMENTSOF(leaf1_ecx), ecx)) |
| 925 |
return true; |
| 926 |
|
| 927 |
if (given_flag_in_set(flag, leaf1_edx, ELEMENTSOF(leaf1_edx), edx)) |
| 928 |
return true; |
| 929 |
} |
| 930 |
|
| 931 |
if (__get_cpuid_count(7, 0, &eax, &ebx, &ecx, &edx)) { |
| 932 |
if (given_flag_in_set(flag, leaf7_ebx, ELEMENTSOF(leaf7_ebx), ebx)) |
| 933 |
return true; |
| 934 |
} |
| 935 |
|
| 936 |
if (__get_cpuid(0x80000001U, &eax, &ebx, &ecx, &edx)) { |
| 937 |
if (given_flag_in_set(flag, leaf81_ecx, ELEMENTSOF(leaf81_ecx), ecx)) |
| 938 |
return true; |
| 939 |
|
| 940 |
if (given_flag_in_set(flag, leaf81_edx, ELEMENTSOF(leaf81_edx), edx)) |
| 941 |
return true; |
| 942 |
} |
| 943 |
|
| 944 |
if (__get_cpuid(0x80000007U, &eax, &ebx, &ecx, &edx)) |
| 945 |
if (given_flag_in_set(flag, leaf87_edx, ELEMENTSOF(leaf87_edx), edx)) |
| 946 |
return true; |
| 947 |
|
| 948 |
return false; |
| 949 |
} |
| 950 |
#endif |
| 951 |
|
| 952 |
bool has_cpu_with_flag(const char *flag) { |
| 953 |
/* CPUID is an x86 specific interface. Assume on all others that no CPUs have those flags. */ |
| 954 |
#if defined(__i386__) || defined(__x86_64__) |
| 955 |
return real_has_cpu_with_flag(flag); |
| 956 |
#else |
| 957 |
return false; |
| 958 |
#endif |
| 959 |
} |
| 960 |
|
| 961 |
static const char *const virtualization_table[_VIRTUALIZATION_MAX] = { |
| 962 |
[VIRTUALIZATION_NONE] = "none", |
| 963 |
[VIRTUALIZATION_KVM] = "kvm", |
| 964 |
[VIRTUALIZATION_AMAZON] = "amazon", |
| 965 |
[VIRTUALIZATION_QEMU] = "qemu", |
| 966 |
[VIRTUALIZATION_BOCHS] = "bochs", |
| 967 |
[VIRTUALIZATION_XEN] = "xen", |
| 968 |
[VIRTUALIZATION_UML] = "uml", |
| 969 |
[VIRTUALIZATION_VMWARE] = "vmware", |
| 970 |
[VIRTUALIZATION_ORACLE] = "oracle", |
| 971 |
[VIRTUALIZATION_MICROSOFT] = "microsoft", |
| 972 |
[VIRTUALIZATION_ZVM] = "zvm", |
| 973 |
[VIRTUALIZATION_PARALLELS] = "parallels", |
| 974 |
[VIRTUALIZATION_BHYVE] = "bhyve", |
| 975 |
[VIRTUALIZATION_QNX] = "qnx", |
| 976 |
[VIRTUALIZATION_ACRN] = "acrn", |
| 977 |
[VIRTUALIZATION_POWERVM] = "powervm", |
| 978 |
[VIRTUALIZATION_APPLE] = "apple", |
| 979 |
[VIRTUALIZATION_SRE] = "sre", |
| 980 |
[VIRTUALIZATION_GOOGLE] = "google", |
| 981 |
[VIRTUALIZATION_VM_OTHER] = "vm-other", |
| 982 |
|
| 983 |
[VIRTUALIZATION_SYSTEMD_NSPAWN] = "systemd-nspawn", |
| 984 |
[VIRTUALIZATION_LXC_LIBVIRT] = "lxc-libvirt", |
| 985 |
[VIRTUALIZATION_LXC] = "lxc", |
| 986 |
[VIRTUALIZATION_OPENVZ] = "openvz", |
| 987 |
[VIRTUALIZATION_DOCKER] = "docker", |
| 988 |
[VIRTUALIZATION_PODMAN] = "podman", |
| 989 |
[VIRTUALIZATION_RKT] = "rkt", |
| 990 |
[VIRTUALIZATION_WSL] = "wsl", |
| 991 |
[VIRTUALIZATION_PROOT] = "proot", |
| 992 |
[VIRTUALIZATION_POUCH] = "pouch", |
| 993 |
[VIRTUALIZATION_CONTAINER_OTHER] = "container-other", |
| 994 |
}; |
| 995 |
|
| 996 |
DEFINE_STRING_TABLE_LOOKUP(virtualization, Virtualization); |