7a5235c9e6
Since HAX_VM_IOCTL_ALLOC_RAM takes a 32-bit size, it cannot handle RAM blocks of 4GB or larger, which is why HAXM can only run guests with less than 4GB of RAM. Solve this problem by utilizing the new HAXM API, HAX_VM_IOCTL_ADD_RAMBLOCK, which takes a 64-bit size, to register RAM blocks with the HAXM kernel module. The new API is first added in HAXM 7.0.0, and its availablility and be confirmed by the presence of the HAX_CAP_64BIT_RAMBLOCK capability flag. When the guest RAM size reaches 7GB, QEMU will ask HAXM to set up a memory mapping that covers a 4GB region, which will fail, because HAX_VM_IOCTL_SET_RAM also takes a 32-bit size. Work around this limitation by splitting the large mapping into small ones and calling HAX_VM_IOCTL_SET_RAM multiple times. Bug: https://bugs.launchpad.net/qemu/+bug/1735576 Signed-off-by: Yu Ning <yu.ning@intel.com> Message-Id: <1515752555-12784-1-git-send-email-yu.ning@linux.intel.com> Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
370 lines
8.6 KiB
C
370 lines
8.6 KiB
C
/*
|
|
* QEMU HAXM support
|
|
*
|
|
* Copyright (c) 2011 Intel Corporation
|
|
* Written by:
|
|
* Jiang Yunhong<yunhong.jiang@intel.com>
|
|
* Xin Xiaohui<xiaohui.xin@intel.com>
|
|
* Zhang Xiantao<xiantao.zhang@intel.com>
|
|
*
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
* See the COPYING file in the top-level directory.
|
|
*
|
|
*/
|
|
|
|
/* Interface with HAX kernel module */
|
|
|
|
#ifndef _HAX_INTERFACE_H
|
|
#define _HAX_INTERFACE_H
|
|
|
|
/* fx_layout has 3 formats table 3-56, 512bytes */
|
|
struct fx_layout {
|
|
uint16_t fcw;
|
|
uint16_t fsw;
|
|
uint8_t ftw;
|
|
uint8_t res1;
|
|
uint16_t fop;
|
|
union {
|
|
struct {
|
|
uint32_t fip;
|
|
uint16_t fcs;
|
|
uint16_t res2;
|
|
};
|
|
uint64_t fpu_ip;
|
|
};
|
|
union {
|
|
struct {
|
|
uint32_t fdp;
|
|
uint16_t fds;
|
|
uint16_t res3;
|
|
};
|
|
uint64_t fpu_dp;
|
|
};
|
|
uint32_t mxcsr;
|
|
uint32_t mxcsr_mask;
|
|
uint8_t st_mm[8][16];
|
|
uint8_t mmx_1[8][16];
|
|
uint8_t mmx_2[8][16];
|
|
uint8_t pad[96];
|
|
} __attribute__ ((aligned(8)));
|
|
|
|
struct vmx_msr {
|
|
uint64_t entry;
|
|
uint64_t value;
|
|
} __attribute__ ((__packed__));
|
|
|
|
/*
|
|
* Fixed array is not good, but it makes Mac support a bit easier by avoiding
|
|
* memory map or copyin staff.
|
|
*/
|
|
#define HAX_MAX_MSR_ARRAY 0x20
|
|
struct hax_msr_data {
|
|
uint16_t nr_msr;
|
|
uint16_t done;
|
|
uint16_t pad[2];
|
|
struct vmx_msr entries[HAX_MAX_MSR_ARRAY];
|
|
} __attribute__ ((__packed__));
|
|
|
|
union interruptibility_state_t {
|
|
uint32_t raw;
|
|
struct {
|
|
uint32_t sti_blocking:1;
|
|
uint32_t movss_blocking:1;
|
|
uint32_t smi_blocking:1;
|
|
uint32_t nmi_blocking:1;
|
|
uint32_t reserved:28;
|
|
};
|
|
uint64_t pad;
|
|
};
|
|
|
|
typedef union interruptibility_state_t interruptibility_state_t;
|
|
|
|
/* Segment descriptor */
|
|
struct segment_desc_t {
|
|
uint16_t selector;
|
|
uint16_t _dummy;
|
|
uint32_t limit;
|
|
uint64_t base;
|
|
union {
|
|
struct {
|
|
uint32_t type:4;
|
|
uint32_t desc:1;
|
|
uint32_t dpl:2;
|
|
uint32_t present:1;
|
|
uint32_t:4;
|
|
uint32_t available:1;
|
|
uint32_t long_mode:1;
|
|
uint32_t operand_size:1;
|
|
uint32_t granularity:1;
|
|
uint32_t null:1;
|
|
uint32_t:15;
|
|
};
|
|
uint32_t ar;
|
|
};
|
|
uint32_t ipad;
|
|
};
|
|
|
|
typedef struct segment_desc_t segment_desc_t;
|
|
|
|
struct vcpu_state_t {
|
|
union {
|
|
uint64_t _regs[16];
|
|
struct {
|
|
union {
|
|
struct {
|
|
uint8_t _al, _ah;
|
|
};
|
|
uint16_t _ax;
|
|
uint32_t _eax;
|
|
uint64_t _rax;
|
|
};
|
|
union {
|
|
struct {
|
|
uint8_t _cl, _ch;
|
|
};
|
|
uint16_t _cx;
|
|
uint32_t _ecx;
|
|
uint64_t _rcx;
|
|
};
|
|
union {
|
|
struct {
|
|
uint8_t _dl, _dh;
|
|
};
|
|
uint16_t _dx;
|
|
uint32_t _edx;
|
|
uint64_t _rdx;
|
|
};
|
|
union {
|
|
struct {
|
|
uint8_t _bl, _bh;
|
|
};
|
|
uint16_t _bx;
|
|
uint32_t _ebx;
|
|
uint64_t _rbx;
|
|
};
|
|
union {
|
|
uint16_t _sp;
|
|
uint32_t _esp;
|
|
uint64_t _rsp;
|
|
};
|
|
union {
|
|
uint16_t _bp;
|
|
uint32_t _ebp;
|
|
uint64_t _rbp;
|
|
};
|
|
union {
|
|
uint16_t _si;
|
|
uint32_t _esi;
|
|
uint64_t _rsi;
|
|
};
|
|
union {
|
|
uint16_t _di;
|
|
uint32_t _edi;
|
|
uint64_t _rdi;
|
|
};
|
|
|
|
uint64_t _r8;
|
|
uint64_t _r9;
|
|
uint64_t _r10;
|
|
uint64_t _r11;
|
|
uint64_t _r12;
|
|
uint64_t _r13;
|
|
uint64_t _r14;
|
|
uint64_t _r15;
|
|
};
|
|
};
|
|
|
|
union {
|
|
uint32_t _eip;
|
|
uint64_t _rip;
|
|
};
|
|
|
|
union {
|
|
uint32_t _eflags;
|
|
uint64_t _rflags;
|
|
};
|
|
|
|
segment_desc_t _cs;
|
|
segment_desc_t _ss;
|
|
segment_desc_t _ds;
|
|
segment_desc_t _es;
|
|
segment_desc_t _fs;
|
|
segment_desc_t _gs;
|
|
segment_desc_t _ldt;
|
|
segment_desc_t _tr;
|
|
|
|
segment_desc_t _gdt;
|
|
segment_desc_t _idt;
|
|
|
|
uint64_t _cr0;
|
|
uint64_t _cr2;
|
|
uint64_t _cr3;
|
|
uint64_t _cr4;
|
|
|
|
uint64_t _dr0;
|
|
uint64_t _dr1;
|
|
uint64_t _dr2;
|
|
uint64_t _dr3;
|
|
uint64_t _dr6;
|
|
uint64_t _dr7;
|
|
uint64_t _pde;
|
|
|
|
uint32_t _efer;
|
|
|
|
uint32_t _sysenter_cs;
|
|
uint64_t _sysenter_eip;
|
|
uint64_t _sysenter_esp;
|
|
|
|
uint32_t _activity_state;
|
|
uint32_t pad;
|
|
interruptibility_state_t _interruptibility_state;
|
|
};
|
|
|
|
/* HAX exit status */
|
|
enum exit_status {
|
|
/* IO port request */
|
|
HAX_EXIT_IO = 1,
|
|
/* MMIO instruction emulation */
|
|
HAX_EXIT_MMIO,
|
|
/* QEMU emulation mode request, currently means guest enter non-PG mode */
|
|
HAX_EXIT_REAL,
|
|
/*
|
|
* Interrupt window open, qemu can inject interrupt now
|
|
* Also used when signal pending since at that time qemu usually need
|
|
* check interrupt
|
|
*/
|
|
HAX_EXIT_INTERRUPT,
|
|
/* Unknown vmexit, mostly trigger reboot */
|
|
HAX_EXIT_UNKNOWN_VMEXIT,
|
|
/* HALT from guest */
|
|
HAX_EXIT_HLT,
|
|
/* Reboot request, like because of tripple fault in guest */
|
|
HAX_EXIT_STATECHANGE,
|
|
/* the vcpu is now only paused when destroy, so simply return to hax */
|
|
HAX_EXIT_PAUSED,
|
|
HAX_EXIT_FAST_MMIO,
|
|
};
|
|
|
|
/*
|
|
* The interface definition:
|
|
* 1. vcpu_run execute will return 0 on success, otherwise mean failed
|
|
* 2. exit_status return the exit reason, as stated in enum exit_status
|
|
* 3. exit_reason is the vmx exit reason
|
|
*/
|
|
struct hax_tunnel {
|
|
uint32_t _exit_reason;
|
|
uint32_t _exit_flag;
|
|
uint32_t _exit_status;
|
|
uint32_t user_event_pending;
|
|
int ready_for_interrupt_injection;
|
|
int request_interrupt_window;
|
|
union {
|
|
struct {
|
|
/* 0: read, 1: write */
|
|
#define HAX_EXIT_IO_IN 1
|
|
#define HAX_EXIT_IO_OUT 0
|
|
uint8_t _direction;
|
|
uint8_t _df;
|
|
uint16_t _size;
|
|
uint16_t _port;
|
|
uint16_t _count;
|
|
uint8_t _flags;
|
|
uint8_t _pad0;
|
|
uint16_t _pad1;
|
|
uint32_t _pad2;
|
|
uint64_t _vaddr;
|
|
} pio;
|
|
struct {
|
|
uint64_t gla;
|
|
} mmio;
|
|
struct {
|
|
} state;
|
|
};
|
|
} __attribute__ ((__packed__));
|
|
|
|
struct hax_module_version {
|
|
uint32_t compat_version;
|
|
uint32_t cur_version;
|
|
} __attribute__ ((__packed__));
|
|
|
|
/* This interface is support only after API version 2 */
|
|
struct hax_qemu_version {
|
|
/* Current API version in QEMU */
|
|
uint32_t cur_version;
|
|
/* The minimum API version supported by QEMU */
|
|
uint32_t min_version;
|
|
} __attribute__ ((__packed__));
|
|
|
|
/* The mac specfic interface to qemu, mostly is ioctl related */
|
|
struct hax_tunnel_info {
|
|
uint64_t va;
|
|
uint64_t io_va;
|
|
uint16_t size;
|
|
uint16_t pad[3];
|
|
} __attribute__ ((__packed__));
|
|
|
|
struct hax_alloc_ram_info {
|
|
uint32_t size;
|
|
uint32_t pad;
|
|
uint64_t va;
|
|
} __attribute__ ((__packed__));
|
|
|
|
struct hax_ramblock_info {
|
|
uint64_t start_va;
|
|
uint64_t size;
|
|
uint64_t reserved;
|
|
} __attribute__ ((__packed__));
|
|
|
|
#define HAX_RAM_INFO_ROM 0x01 /* Read-Only */
|
|
#define HAX_RAM_INFO_INVALID 0x80 /* Unmapped, usually used for MMIO */
|
|
struct hax_set_ram_info {
|
|
uint64_t pa_start;
|
|
uint32_t size;
|
|
uint8_t flags;
|
|
uint8_t pad[3];
|
|
uint64_t va;
|
|
} __attribute__ ((__packed__));
|
|
|
|
#define HAX_CAP_STATUS_WORKING 0x1
|
|
#define HAX_CAP_STATUS_NOTWORKING 0x0
|
|
#define HAX_CAP_WORKSTATUS_MASK 0x1
|
|
|
|
#define HAX_CAP_FAILREASON_VT 0x1
|
|
#define HAX_CAP_FAILREASON_NX 0x2
|
|
|
|
#define HAX_CAP_MEMQUOTA 0x2
|
|
#define HAX_CAP_UG 0x4
|
|
#define HAX_CAP_64BIT_RAMBLOCK 0x8
|
|
|
|
struct hax_capabilityinfo {
|
|
/* bit 0: 1 - working
|
|
* 0 - not working, possibly because NT/NX disabled
|
|
* bit 1: 1 - memory limitation working
|
|
* 0 - no memory limitation
|
|
*/
|
|
uint16_t wstatus;
|
|
/* valid when not working
|
|
* bit 0: VT not enabeld
|
|
* bit 1: NX not enabled*/
|
|
uint16_t winfo;
|
|
uint32_t pad;
|
|
uint64_t mem_quota;
|
|
} __attribute__ ((__packed__));
|
|
|
|
struct hax_fastmmio {
|
|
uint64_t gpa;
|
|
union {
|
|
uint64_t value;
|
|
uint64_t gpa2; /* since HAX API v4 */
|
|
};
|
|
uint8_t size;
|
|
uint8_t direction;
|
|
uint16_t reg_index;
|
|
uint32_t pad0;
|
|
uint64_t _cr0;
|
|
uint64_t _cr2;
|
|
uint64_t _cr3;
|
|
uint64_t _cr4;
|
|
} __attribute__ ((__packed__));
|
|
#endif
|