| // Copyright (C) 2014 The Android Open Source Project |
| // |
| // This software is licensed under the terms of the GNU General Public |
| // License version 2, as published by the Free Software Foundation, and |
| // may be copied, distributed, and modified under those terms. |
| // |
| // This program is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. |
| |
| #include "android/emulation/CpuAccelerator.h" |
| |
| #ifdef _WIN32 |
| #define WIN32_LEAN_AND_MEAN 1 |
| #include <windows.h> |
| #include <winioctl.h> |
| #else |
| #include <fcntl.h> |
| #include <string.h> |
| #include <sys/ioctl.h> |
| #include <unistd.h> |
| #endif |
| |
| #include <stdio.h> |
| |
| #include "android/utils/path.h" |
| |
| #include "android/base/Compiler.h" |
| #include "android/base/files/ScopedFd.h" |
| #ifdef _WIN32 |
| #include "android/base/files/ScopedHandle.h" |
| #endif |
| #include "android/base/Log.h" |
| #include "android/base/StringFormat.h" |
| |
| // NOTE: This source file must be independent of the rest of QEMU, as such |
| // it should not include / reuse any QEMU source file or function |
| // related to KVM or HAX. |
| |
| #ifdef __linux__ |
| # define HAVE_KVM 1 |
| # define HAVE_HAX 0 |
| #elif defined(_WIN32) || defined(__APPLE__) |
| # define HAVE_KVM 0 |
| # define HAVE_HAX 1 |
| #else |
| # error "Unsupported host platform!" |
| #endif |
| |
| namespace android { |
| |
| using base::String; |
| using base::StringAppendFormat; |
| using base::ScopedFd; |
| |
| namespace { |
| |
| struct GlobalState { |
| bool probed; |
| bool testing; |
| CpuAccelerator accel; |
| char status[256]; |
| }; |
| |
| GlobalState gGlobals = { false, false, CPU_ACCELERATOR_NONE, { '\0' } }; |
| |
| ///////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////// |
| ///// |
| ///// Linux KVM support. |
| ///// |
| ///////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////// |
| |
| #if HAVE_KVM |
| |
| #include <linux/kvm.h> |
| |
| // Return true iff KVM is installed and usable on this machine. |
| // |*status| will be set to a small status string explaining the |
| // status of KVM on success or failure. |
| bool ProbeKVM(String *status) { |
| // 1) Check that /dev/kvm exists. |
| if (::access("/dev/kvm", F_OK)) { |
| status->assign( |
| "KVM is not installed on this machine (/dev/kvm is missing)."); |
| return false; |
| } |
| // 2) Check that /dev/kvm can be opened. |
| if (::access("/dev/kvm", R_OK)) { |
| status->assign( |
| "This user doesn't have permissions to use KVM (/dev/kvm)."); |
| return false; |
| } |
| // 3) Open the file. |
| ScopedFd fd(TEMP_FAILURE_RETRY(open("/dev/kvm", O_RDWR))); |
| if (!fd.valid()) { |
| status->assign("Could not open /dev/kvm :"); |
| status->append(strerror(errno)); |
| return false; |
| } |
| |
| // 4) Extract KVM version number. |
| int version = ::ioctl(fd.get(), KVM_GET_API_VERSION, 0); |
| if (version < 0) { |
| status->assign("Could not extract KVM version: "); |
| status->append(strerror(errno)); |
| return false; |
| } |
| |
| // 5) Compare to minimum supported version |
| status->clear(); |
| |
| if (version < KVM_API_VERSION) { |
| StringAppendFormat(status, |
| "KVM version too old: %d (expected at least %d)\n", |
| version, |
| KVM_API_VERSION); |
| return false; |
| } |
| |
| // 6) Profit! |
| StringAppendFormat(status, |
| "KVM (version %d) is installed and usable.", |
| version); |
| return true; |
| } |
| |
| #endif // HAVE_KVM |
| |
| |
| #if HAVE_HAX |
| |
| // Version numbers for the HAX kernel module. |
| // |compat_version| is the minimum API version supported by the module. |
| // |current_version| is its current API version. |
| struct HaxModuleVersion { |
| uint32_t compat_version; |
| uint32_t current_version; |
| }; |
| |
| |
| ///////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////// |
| ///// |
| ///// Windows HAX support. |
| ///// |
| ///////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////// |
| |
| #if defined(_WIN32) |
| |
| using base::ScopedHandle; |
| |
| // Windows IOCTL code to extract HAX kernel module version. |
| #define HAX_DEVICE_TYPE 0x4000 |
| #define HAX_IOCTL_VERSION \ |
| CTL_CODE(HAX_DEVICE_TYPE, 0x900, METHOD_BUFFERED, FILE_ANY_ACCESS) |
| |
| // The minimum API version supported by the Android emulator. |
| #define HAX_MIN_VERSION 1 |
| |
| bool ProbeHAX(String* status) { |
| status->clear(); |
| // 1) Try to find the HAX kernel module. |
| ScopedHandle hax(CreateFile("\\\\.\\HAX", |
| GENERIC_READ | GENERIC_WRITE, |
| 0, |
| NULL, |
| CREATE_ALWAYS, |
| FILE_ATTRIBUTE_NORMAL, |
| NULL)); |
| if (!hax.valid()) { |
| DWORD err = GetLastError(); |
| if (err == ERROR_FILE_NOT_FOUND) { |
| status->assign("HAX kernel module is not installed!"); |
| } else { |
| StringAppendFormat(status, |
| "Opening HAX kernel module failed: %u", |
| err); |
| } |
| return false; |
| } |
| |
| // 2) Extract the module's version. |
| HaxModuleVersion hax_version; |
| |
| DWORD dSize = 0; |
| BOOL ret = DeviceIoControl(hax.get(), |
| HAX_IOCTL_VERSION, |
| NULL, 0, |
| &hax_version, sizeof(hax_version), |
| &dSize, |
| (LPOVERLAPPED) NULL); |
| if (!ret) { |
| DWORD err = GetLastError(); |
| StringAppendFormat(status, |
| "Could not extract HAX module version: %u", |
| err); |
| return false; |
| } |
| |
| // 3) Check that it is the right version. |
| if (hax_version.current_version < HAX_MIN_VERSION) { |
| StringAppendFormat(status, |
| "HAX version (%d) is too old (need at least %d).", |
| hax_version.current_version, |
| HAX_MIN_VERSION); |
| return false; |
| } |
| |
| // 4) Profit! |
| StringAppendFormat(status, |
| "HAX (version %d) is installed and usable.", |
| hax_version.current_version); |
| return true; |
| } |
| |
| #elif defined(__APPLE__) |
| |
| ///////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////// |
| ///// |
| ///// Darwin HAX support. |
| ///// |
| ///////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////// |
| |
| // An IOCTL command number used to retrieve the HAX kernel module version. |
| #define HAX_IOCTL_VERSION _IOWR(0, 0x20, HaxModuleVersion) |
| |
| // The minimum API version supported by the Android emulator. |
| #define HAX_MIN_VERSION 1 |
| |
| bool ProbeHAX(String* status) { |
| // 1) Check that /dev/HAX exists. |
| if (::access("/dev/HAX", F_OK)) { |
| status->assign( |
| "HAX is not installed on this machine (/dev/HAX is missing)."); |
| return false; |
| } |
| // 2) Check that /dev/HAX can be opened. |
| if (::access("/dev/HAX", R_OK)) { |
| status->assign( |
| "This user doesn't have permission to use HAX (/dev/HAX)."); |
| return false; |
| } |
| // 3) Open the file. |
| ScopedFd fd(open("/dev/HAX", O_RDWR)); |
| if (!fd.valid()) { |
| status->assign("Could not open /dev/HAX: "); |
| status->append(strerror(errno)); |
| return false; |
| } |
| |
| // 4) Extract HAX version number. |
| status->clear(); |
| |
| HaxModuleVersion hax_version; |
| if (::ioctl(fd.get(), HAX_IOCTL_VERSION, &hax_version) < 0) { |
| StringAppendFormat(status, |
| "Could not extract HAX version: %s", |
| strerror(errno)); |
| return false; |
| } |
| |
| if (hax_version.current_version < hax_version.compat_version) { |
| StringAppendFormat( |
| status, |
| "Malformed HAX version numbers (current=%d, compat=%d)\n", |
| hax_version.current_version, |
| hax_version.compat_version); |
| return false; |
| } |
| |
| // 5) Compare to minimum supported version. |
| |
| if (hax_version.current_version < HAX_MIN_VERSION) { |
| StringAppendFormat(status, |
| "HAX version too old: %d (expected at least %d)\n", |
| hax_version.current_version, |
| HAX_MIN_VERSION); |
| return false; |
| } |
| |
| // 6) Profit! |
| StringAppendFormat(status, |
| "HAX (version %d) is installed and usable.", |
| hax_version.current_version); |
| return true; |
| } |
| |
| #else // !_WIN32 && !__APPLE__ |
| #error "Unsupported HAX host platform" |
| #endif // !_WIN32 && !__APPLE__ |
| |
| #endif // HAVE_HAX |
| |
| } // namespace |
| |
| CpuAccelerator GetCurrentCpuAccelerator() { |
| GlobalState* g = &gGlobals; |
| |
| if (g->probed || g->testing) { |
| return g->accel; |
| } |
| |
| String status; |
| #if HAVE_KVM |
| if (ProbeKVM(&status)) { |
| g->accel = CPU_ACCELERATOR_KVM; |
| } |
| #elif HAVE_HAX |
| if (ProbeHAX(&status)) { |
| g->accel = CPU_ACCELERATOR_HAX; |
| } |
| #else |
| status = "This system does not support CPU acceleration."; |
| #endif |
| ::snprintf(g->status, sizeof(g->status), "%s", status.c_str()); |
| |
| g->probed = true; |
| return g->accel; |
| } |
| |
| String GetCurrentCpuAcceleratorStatus() { |
| GlobalState *g = &gGlobals; |
| |
| if (!g->probed && !g->testing) { |
| // Force detection of the current CPU accelerator. |
| GetCurrentCpuAccelerator(); |
| } |
| |
| return String(g->status); |
| } |
| |
| void SetCurrentCpuAcceleratorForTesting(CpuAccelerator accel, |
| const char* status) { |
| GlobalState *g = &gGlobals; |
| |
| g->testing = true; |
| g->accel = accel; |
| ::snprintf(g->status, sizeof(g->status), "%s", status); |
| } |
| |
| } // namespace android |
