kvm_emulate.h File Reference

#include <asm/desc_defs.h>
#include "fpu.h"

Include dependency graph for kvm_emulate.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	x86_exception
struct	x86_instruction_info
struct	x86_emulate_ops
struct	operand
struct	fetch_cache
struct	read_cache
struct	x86_emulate_ctxt

Macros
#define	X86EMUL_CONTINUE   0
#define	X86EMUL_UNHANDLEABLE   1
#define	X86EMUL_PROPAGATE_FAULT   2 /* propagate a generated fault to guest */
#define	X86EMUL_RETRY_INSTR   3 /* retry the instruction for some reason */
#define	X86EMUL_CMPXCHG_FAILED   4 /* cmpxchg did not see expected value */
#define	X86EMUL_IO_NEEDED   5 /* IO is needed to complete emulation */
#define	X86EMUL_INTERCEPTED   6 /* Intercepted by nested VMCB/VMCS */
#define	X86EMUL_F_WRITE   BIT(0)
#define	X86EMUL_F_FETCH   BIT(1)
#define	X86EMUL_F_IMPLICIT   BIT(2)
#define	X86EMUL_F_INVLPG   BIT(3)
#define	NR_EMULATOR_GPRS   8
#define	KVM_EMULATOR_BUG_ON(cond, ctxt)
#define	REPE_PREFIX   0xf3
#define	REPNE_PREFIX   0xf2
#define	X86EMUL_CPUID_VENDOR_AuthenticAMD_ebx   0x68747541
#define	X86EMUL_CPUID_VENDOR_AuthenticAMD_ecx   0x444d4163
#define	X86EMUL_CPUID_VENDOR_AuthenticAMD_edx   0x69746e65
#define	X86EMUL_CPUID_VENDOR_AMDisbetterI_ebx   0x69444d41
#define	X86EMUL_CPUID_VENDOR_AMDisbetterI_ecx   0x21726574
#define	X86EMUL_CPUID_VENDOR_AMDisbetterI_edx   0x74656273
#define	X86EMUL_CPUID_VENDOR_HygonGenuine_ebx   0x6f677948
#define	X86EMUL_CPUID_VENDOR_HygonGenuine_ecx   0x656e6975
#define	X86EMUL_CPUID_VENDOR_HygonGenuine_edx   0x6e65476e
#define	X86EMUL_CPUID_VENDOR_GenuineIntel_ebx   0x756e6547
#define	X86EMUL_CPUID_VENDOR_GenuineIntel_ecx   0x6c65746e
#define	X86EMUL_CPUID_VENDOR_GenuineIntel_edx   0x49656e69
#define	X86EMUL_CPUID_VENDOR_CentaurHauls_ebx   0x746e6543
#define	X86EMUL_CPUID_VENDOR_CentaurHauls_ecx   0x736c7561
#define	X86EMUL_CPUID_VENDOR_CentaurHauls_edx   0x48727561
#define	EMULATION_FAILED   -1
#define	EMULATION_OK   0
#define	EMULATION_RESTART   1
#define	EMULATION_INTERCEPTED   2

Typedefs
typedef void(*	fastop_t) (struct fastop *)

Enumerations
enum	x86emul_mode {   X86EMUL_MODE_REAL , X86EMUL_MODE_VM86 , X86EMUL_MODE_PROT16 , X86EMUL_MODE_PROT32 ,   X86EMUL_MODE_PROT64 }
enum	x86_intercept_stage { X86_ICTP_NONE = 0 , X86_ICPT_PRE_EXCEPT , X86_ICPT_POST_EXCEPT , X86_ICPT_POST_MEMACCESS }
enum	x86_intercept {   x86_intercept_none , x86_intercept_cr_read , x86_intercept_cr_write , x86_intercept_clts ,   x86_intercept_lmsw , x86_intercept_smsw , x86_intercept_dr_read , x86_intercept_dr_write ,   x86_intercept_lidt , x86_intercept_sidt , x86_intercept_lgdt , x86_intercept_sgdt ,   x86_intercept_lldt , x86_intercept_sldt , x86_intercept_ltr , x86_intercept_str ,   x86_intercept_rdtsc , x86_intercept_rdpmc , x86_intercept_pushf , x86_intercept_popf ,   x86_intercept_cpuid , x86_intercept_rsm , x86_intercept_iret , x86_intercept_intn ,   x86_intercept_invd , x86_intercept_pause , x86_intercept_hlt , x86_intercept_invlpg ,   x86_intercept_invlpga , x86_intercept_vmrun , x86_intercept_vmload , x86_intercept_vmsave ,   x86_intercept_vmmcall , x86_intercept_stgi , x86_intercept_clgi , x86_intercept_skinit ,   x86_intercept_rdtscp , x86_intercept_rdpid , x86_intercept_icebp , x86_intercept_wbinvd ,   x86_intercept_monitor , x86_intercept_mwait , x86_intercept_rdmsr , x86_intercept_wrmsr ,   x86_intercept_in , x86_intercept_ins , x86_intercept_out , x86_intercept_outs ,   x86_intercept_xsetbv , nr_x86_intercepts }

Functions
static bool	is_guest_vendor_intel (u32 ebx, u32 ecx, u32 edx)
static bool	is_guest_vendor_amd (u32 ebx, u32 ecx, u32 edx)
static bool	is_guest_vendor_hygon (u32 ebx, u32 ecx, u32 edx)
int	x86_decode_insn (struct x86_emulate_ctxt *ctxt, void *insn, int insn_len, int emulation_type)
bool	x86_page_table_writing_insn (struct x86_emulate_ctxt *ctxt)
void	init_decode_cache (struct x86_emulate_ctxt *ctxt)
int	x86_emulate_insn (struct x86_emulate_ctxt *ctxt)
int	emulator_task_switch (struct x86_emulate_ctxt *ctxt, u16 tss_selector, int idt_index, int reason, bool has_error_code, u32 error_code)
int	emulate_int_real (struct x86_emulate_ctxt *ctxt, int irq)
void	emulator_invalidate_register_cache (struct x86_emulate_ctxt *ctxt)
void	emulator_writeback_register_cache (struct x86_emulate_ctxt *ctxt)
bool	emulator_can_use_gpa (struct x86_emulate_ctxt *ctxt)
static ulong	reg_read (struct x86_emulate_ctxt *ctxt, unsigned nr)
static ulong *	reg_write (struct x86_emulate_ctxt *ctxt, unsigned nr)
static ulong *	reg_rmw (struct x86_emulate_ctxt *ctxt, unsigned nr)

Macro Definition Documentation

EMULATION_FAILED

#define EMULATION_FAILED   -1

Definition at line 505 of file kvm_emulate.h.

EMULATION_INTERCEPTED

#define EMULATION_INTERCEPTED   2

Definition at line 508 of file kvm_emulate.h.

EMULATION_OK

#define EMULATION_OK   0

Definition at line 506 of file kvm_emulate.h.

EMULATION_RESTART

#define EMULATION_RESTART   1

Definition at line 507 of file kvm_emulate.h.

KVM_EMULATOR_BUG_ON

#define KVM_EMULATOR_BUG_ON	(		cond,
			ctxt
	)

Value:

({                      \
    int __ret = (cond);         \
                        \
    if (WARN_ON_ONCE(__ret))        \
        ctxt->ops->vm_bugged(ctxt); \
    unlikely(__ret);            \
})

Definition at line 377 of file kvm_emulate.h.

NR_EMULATOR_GPRS

#define NR_EMULATOR_GPRS   8

Definition at line 304 of file kvm_emulate.h.

REPE_PREFIX

#define REPE_PREFIX   0xf3

Definition at line 387 of file kvm_emulate.h.

REPNE_PREFIX

#define REPNE_PREFIX   0xf2

Definition at line 388 of file kvm_emulate.h.

X86EMUL_CMPXCHG_FAILED

#define X86EMUL_CMPXCHG_FAILED   4 /* cmpxchg did not see expected value */

Definition at line 87 of file kvm_emulate.h.

X86EMUL_CONTINUE

#define X86EMUL_CONTINUE   0

Definition at line 81 of file kvm_emulate.h.

X86EMUL_CPUID_VENDOR_AMDisbetterI_ebx

#define X86EMUL_CPUID_VENDOR_AMDisbetterI_ebx   0x69444d41

Definition at line 395 of file kvm_emulate.h.

X86EMUL_CPUID_VENDOR_AMDisbetterI_ecx

#define X86EMUL_CPUID_VENDOR_AMDisbetterI_ecx   0x21726574

Definition at line 396 of file kvm_emulate.h.

X86EMUL_CPUID_VENDOR_AMDisbetterI_edx

#define X86EMUL_CPUID_VENDOR_AMDisbetterI_edx   0x74656273

Definition at line 397 of file kvm_emulate.h.

X86EMUL_CPUID_VENDOR_AuthenticAMD_ebx

#define X86EMUL_CPUID_VENDOR_AuthenticAMD_ebx   0x68747541

Definition at line 391 of file kvm_emulate.h.

X86EMUL_CPUID_VENDOR_AuthenticAMD_ecx

#define X86EMUL_CPUID_VENDOR_AuthenticAMD_ecx   0x444d4163

Definition at line 392 of file kvm_emulate.h.

X86EMUL_CPUID_VENDOR_AuthenticAMD_edx

#define X86EMUL_CPUID_VENDOR_AuthenticAMD_edx   0x69746e65

Definition at line 393 of file kvm_emulate.h.

X86EMUL_CPUID_VENDOR_CentaurHauls_ebx

#define X86EMUL_CPUID_VENDOR_CentaurHauls_ebx   0x746e6543

Definition at line 407 of file kvm_emulate.h.

X86EMUL_CPUID_VENDOR_CentaurHauls_ecx

#define X86EMUL_CPUID_VENDOR_CentaurHauls_ecx   0x736c7561

Definition at line 408 of file kvm_emulate.h.

X86EMUL_CPUID_VENDOR_CentaurHauls_edx

#define X86EMUL_CPUID_VENDOR_CentaurHauls_edx   0x48727561

Definition at line 409 of file kvm_emulate.h.

X86EMUL_CPUID_VENDOR_GenuineIntel_ebx

#define X86EMUL_CPUID_VENDOR_GenuineIntel_ebx   0x756e6547

Definition at line 403 of file kvm_emulate.h.

X86EMUL_CPUID_VENDOR_GenuineIntel_ecx

#define X86EMUL_CPUID_VENDOR_GenuineIntel_ecx   0x6c65746e

Definition at line 404 of file kvm_emulate.h.

X86EMUL_CPUID_VENDOR_GenuineIntel_edx

#define X86EMUL_CPUID_VENDOR_GenuineIntel_edx   0x49656e69

Definition at line 405 of file kvm_emulate.h.

X86EMUL_CPUID_VENDOR_HygonGenuine_ebx

#define X86EMUL_CPUID_VENDOR_HygonGenuine_ebx   0x6f677948

Definition at line 399 of file kvm_emulate.h.

X86EMUL_CPUID_VENDOR_HygonGenuine_ecx

#define X86EMUL_CPUID_VENDOR_HygonGenuine_ecx   0x656e6975

Definition at line 400 of file kvm_emulate.h.

X86EMUL_CPUID_VENDOR_HygonGenuine_edx

#define X86EMUL_CPUID_VENDOR_HygonGenuine_edx   0x6e65476e

Definition at line 401 of file kvm_emulate.h.

X86EMUL_F_FETCH

#define X86EMUL_F_FETCH   BIT(1)

Definition at line 93 of file kvm_emulate.h.

X86EMUL_F_IMPLICIT

#define X86EMUL_F_IMPLICIT   BIT(2)

Definition at line 94 of file kvm_emulate.h.

X86EMUL_F_INVLPG

#define X86EMUL_F_INVLPG   BIT(3)

Definition at line 95 of file kvm_emulate.h.

X86EMUL_F_WRITE

#define X86EMUL_F_WRITE   BIT(0)

Definition at line 92 of file kvm_emulate.h.

X86EMUL_INTERCEPTED

#define X86EMUL_INTERCEPTED   6 /* Intercepted by nested VMCB/VMCS */

Definition at line 89 of file kvm_emulate.h.

X86EMUL_IO_NEEDED

#define X86EMUL_IO_NEEDED   5 /* IO is needed to complete emulation */

Definition at line 88 of file kvm_emulate.h.

X86EMUL_PROPAGATE_FAULT

#define X86EMUL_PROPAGATE_FAULT   2 /* propagate a generated fault to guest */

Definition at line 85 of file kvm_emulate.h.

X86EMUL_RETRY_INSTR

#define X86EMUL_RETRY_INSTR   3 /* retry the instruction for some reason */

Definition at line 86 of file kvm_emulate.h.

X86EMUL_UNHANDLEABLE

#define X86EMUL_UNHANDLEABLE   1

Definition at line 83 of file kvm_emulate.h.

Typedef Documentation

fastop_t

typedef void(* fastop_t) (struct fastop *)

Definition at line 293 of file kvm_emulate.h.

Enumeration Type Documentation

x86_intercept

enum x86_intercept

Enumerator
x86_intercept_none
x86_intercept_cr_read
x86_intercept_cr_write
x86_intercept_clts
x86_intercept_lmsw
x86_intercept_smsw
x86_intercept_dr_read
x86_intercept_dr_write
x86_intercept_lidt
x86_intercept_sidt
x86_intercept_lgdt
x86_intercept_sgdt
x86_intercept_lldt
x86_intercept_sldt
x86_intercept_ltr
x86_intercept_str
x86_intercept_rdtsc
x86_intercept_rdpmc
x86_intercept_pushf
x86_intercept_popf
x86_intercept_cpuid
x86_intercept_rsm
x86_intercept_iret
x86_intercept_intn
x86_intercept_invd
x86_intercept_pause
x86_intercept_hlt
x86_intercept_invlpg
x86_intercept_invlpga
x86_intercept_vmrun
x86_intercept_vmload
x86_intercept_vmsave
x86_intercept_vmmcall
x86_intercept_stgi
x86_intercept_clgi
x86_intercept_skinit
x86_intercept_rdtscp
x86_intercept_rdpid
x86_intercept_icebp
x86_intercept_wbinvd
x86_intercept_monitor
x86_intercept_mwait
x86_intercept_rdmsr
x86_intercept_wrmsr
x86_intercept_in
x86_intercept_ins
x86_intercept_out
x86_intercept_outs
x86_intercept_xsetbv
nr_x86_intercepts

Definition at line 442 of file kvm_emulate.h.

                   {
    x86_intercept_none,
    x86_intercept_cr_read,
    x86_intercept_cr_write,
    x86_intercept_clts,
    x86_intercept_lmsw,
    x86_intercept_smsw,
    x86_intercept_dr_read,
    x86_intercept_dr_write,
    x86_intercept_lidt,
    x86_intercept_sidt,
    x86_intercept_lgdt,
    x86_intercept_sgdt,
    x86_intercept_lldt,
    x86_intercept_sldt,
    x86_intercept_ltr,
    x86_intercept_str,
    x86_intercept_rdtsc,
    x86_intercept_rdpmc,
    x86_intercept_pushf,
    x86_intercept_popf,
    x86_intercept_cpuid,
    x86_intercept_rsm,
    x86_intercept_iret,
    x86_intercept_intn,
    x86_intercept_invd,
    x86_intercept_pause,
    x86_intercept_hlt,
    x86_intercept_invlpg,
    x86_intercept_invlpga,
    x86_intercept_vmrun,
    x86_intercept_vmload,
    x86_intercept_vmsave,
    x86_intercept_vmmcall,
    x86_intercept_stgi,
    x86_intercept_clgi,
    x86_intercept_skinit,
    x86_intercept_rdtscp,
    x86_intercept_rdpid,
    x86_intercept_icebp,
    x86_intercept_wbinvd,
    x86_intercept_monitor,
    x86_intercept_mwait,
    x86_intercept_rdmsr,
    x86_intercept_wrmsr,
    x86_intercept_in,
    x86_intercept_ins,
    x86_intercept_out,
    x86_intercept_outs,
    x86_intercept_xsetbv,
 
    nr_x86_intercepts
};

x86_intercept_stage

enum x86_intercept_stage

Enumerator
X86_ICTP_NONE
X86_ICPT_PRE_EXCEPT
X86_ICPT_POST_EXCEPT
X86_ICPT_POST_MEMACCESS

Definition at line 435 of file kvm_emulate.h.

                         {
    X86_ICTP_NONE = 0,   /* Allow zero-init to not match anything */
    X86_ICPT_PRE_EXCEPT,
    X86_ICPT_POST_EXCEPT,
    X86_ICPT_POST_MEMACCESS,
};

x86emul_mode

enum x86emul_mode

Enumerator
X86EMUL_MODE_REAL
X86EMUL_MODE_VM86
X86EMUL_MODE_PROT16
X86EMUL_MODE_PROT32
X86EMUL_MODE_PROT64

Definition at line 279 of file kvm_emulate.h.

                  {
    X86EMUL_MODE_REAL,  /* Real mode.             */
    X86EMUL_MODE_VM86,  /* Virtual 8086 mode.     */
    X86EMUL_MODE_PROT16,    /* 16-bit protected mode. */
    X86EMUL_MODE_PROT32,    /* 32-bit protected mode. */
    X86EMUL_MODE_PROT64,    /* 64-bit (long) mode.    */
};

Function Documentation

emulate_int_real()

int emulate_int_real	(	struct x86_emulate_ctxt *	ctxt,
		int	irq
	)

Definition at line 2069 of file emulate.c.

{
    int rc;
 
    invalidate_registers(ctxt);
    rc = __emulate_int_real(ctxt, irq);
    if (rc == X86EMUL_CONTINUE)
        writeback_registers(ctxt);
    return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

emulator_can_use_gpa()

bool emulator_can_use_gpa

(

struct x86_emulate_ctxt *

ctxt

)

Definition at line 5502 of file emulate.c.

{
    if (ctxt->rep_prefix && (ctxt->d & String))
        return false;
 
    if (ctxt->d & TwoMemOp)
        return false;
 
    return true;
}

Here is the caller graph for this function:

emulator_invalidate_register_cache()

void emulator_invalidate_register_cache

(

struct x86_emulate_ctxt *

ctxt

)

Definition at line 5492 of file emulate.c.

{
    invalidate_registers(ctxt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

emulator_task_switch()

int emulator_task_switch	(	struct x86_emulate_ctxt *	ctxt,
		u16	tss_selector,
		int	idt_index,
		int	reason,
		bool	has_error_code,
		u32	error_code
	)

Definition at line 3020 of file emulate.c.

{
    int rc;
 
    invalidate_registers(ctxt);
    ctxt->_eip = ctxt->eip;
    ctxt->dst.type = OP_NONE;
 
    rc = emulator_do_task_switch(ctxt, tss_selector, idt_index, reason,
                     has_error_code, error_code);
 
    if (rc == X86EMUL_CONTINUE) {
        ctxt->eip = ctxt->_eip;
        writeback_registers(ctxt);
    }
 
    return (rc == X86EMUL_UNHANDLEABLE) ? EMULATION_FAILED : EMULATION_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

emulator_writeback_register_cache()

void emulator_writeback_register_cache

(

struct x86_emulate_ctxt *

ctxt

)

Definition at line 5497 of file emulate.c.

{
    writeback_registers(ctxt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_decode_cache()

void init_decode_cache

(

struct x86_emulate_ctxt *

ctxt

)

Definition at line 5125 of file emulate.c.

{
    /* Clear fields that are set conditionally but read without a guard. */
    ctxt->rip_relative = false;
    ctxt->rex_prefix = 0;
    ctxt->lock_prefix = 0;
    ctxt->rep_prefix = 0;
    ctxt->regs_valid = 0;
    ctxt->regs_dirty = 0;
 
    ctxt->io_read.pos = 0;
    ctxt->io_read.end = 0;
    ctxt->mem_read.end = 0;
}

Here is the caller graph for this function:

is_guest_vendor_amd()

static bool is_guest_vendor_amd ( u32  ebx, u32  ecx, u32  edx  )

inlinestatic

Definition at line 418 of file kvm_emulate.h.

{
    return (ebx == X86EMUL_CPUID_VENDOR_AuthenticAMD_ebx &&
        ecx == X86EMUL_CPUID_VENDOR_AuthenticAMD_ecx &&
        edx == X86EMUL_CPUID_VENDOR_AuthenticAMD_edx) ||
           (ebx == X86EMUL_CPUID_VENDOR_AMDisbetterI_ebx &&
        ecx == X86EMUL_CPUID_VENDOR_AMDisbetterI_ecx &&
        edx == X86EMUL_CPUID_VENDOR_AMDisbetterI_edx);
}

Here is the caller graph for this function:

is_guest_vendor_hygon()

static bool is_guest_vendor_hygon ( u32  ebx, u32  ecx, u32  edx  )

inlinestatic

Definition at line 428 of file kvm_emulate.h.

{
    return ebx == X86EMUL_CPUID_VENDOR_HygonGenuine_ebx &&
           ecx == X86EMUL_CPUID_VENDOR_HygonGenuine_ecx &&
           edx == X86EMUL_CPUID_VENDOR_HygonGenuine_edx;
}

Here is the caller graph for this function:

is_guest_vendor_intel()

static bool is_guest_vendor_intel ( u32  ebx, u32  ecx, u32  edx  )

inlinestatic

Definition at line 411 of file kvm_emulate.h.

{
    return ebx == X86EMUL_CPUID_VENDOR_GenuineIntel_ebx &&
           ecx == X86EMUL_CPUID_VENDOR_GenuineIntel_ecx &&
           edx == X86EMUL_CPUID_VENDOR_GenuineIntel_edx;
}

Here is the caller graph for this function:

reg_read()

static ulong reg_read ( struct x86_emulate_ctxt *  ctxt, unsigned  nr  )

inlinestatic

Definition at line 519 of file kvm_emulate.h.

{
    if (KVM_EMULATOR_BUG_ON(nr >= NR_EMULATOR_GPRS, ctxt))
        nr &= NR_EMULATOR_GPRS - 1;
 
    if (!(ctxt->regs_valid & (1 << nr))) {
        ctxt->regs_valid |= 1 << nr;
        ctxt->_regs[nr] = ctxt->ops->read_gpr(ctxt, nr);
    }
    return ctxt->_regs[nr];
}

Here is the caller graph for this function:

reg_rmw()

static ulong* reg_rmw ( struct x86_emulate_ctxt *  ctxt, unsigned  nr  )

inlinestatic

Definition at line 544 of file kvm_emulate.h.

{
    reg_read(ctxt, nr);
    return reg_write(ctxt, nr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

reg_write()

static ulong* reg_write ( struct x86_emulate_ctxt *  ctxt, unsigned  nr  )

inlinestatic

Definition at line 531 of file kvm_emulate.h.

{
    if (KVM_EMULATOR_BUG_ON(nr >= NR_EMULATOR_GPRS, ctxt))
        nr &= NR_EMULATOR_GPRS - 1;
 
    BUILD_BUG_ON(sizeof(ctxt->regs_dirty) * BITS_PER_BYTE < NR_EMULATOR_GPRS);
    BUILD_BUG_ON(sizeof(ctxt->regs_valid) * BITS_PER_BYTE < NR_EMULATOR_GPRS);
 
    ctxt->regs_valid |= 1 << nr;
    ctxt->regs_dirty |= 1 << nr;
    return &ctxt->_regs[nr];
}

Here is the caller graph for this function:

x86_decode_insn()

int x86_decode_insn	(	struct x86_emulate_ctxt *	ctxt,
		void *	insn,
		int	insn_len,
		int	emulation_type
	)

Definition at line 4763 of file emulate.c.

{
    int rc = X86EMUL_CONTINUE;
    int mode = ctxt->mode;
    int def_op_bytes, def_ad_bytes, goffset, simd_prefix;
    bool op_prefix = false;
    bool has_seg_override = false;
    struct opcode opcode;
    u16 dummy;
    struct desc_struct desc;
 
    ctxt->memop.type = OP_NONE;
    ctxt->memopp = NULL;
    ctxt->_eip = ctxt->eip;
    ctxt->fetch.ptr = ctxt->fetch.data;
    ctxt->fetch.end = ctxt->fetch.data + insn_len;
    ctxt->opcode_len = 1;
    ctxt->intercept = x86_intercept_none;
    if (insn_len > 0)
        memcpy(ctxt->fetch.data, insn, insn_len);
    else {
        rc = __do_insn_fetch_bytes(ctxt, 1);
        if (rc != X86EMUL_CONTINUE)
            goto done;
    }
 
    switch (mode) {
    case X86EMUL_MODE_REAL:
    case X86EMUL_MODE_VM86:
        def_op_bytes = def_ad_bytes = 2;
        ctxt->ops->get_segment(ctxt, &dummy, &desc, NULL, VCPU_SREG_CS);
        if (desc.d)
            def_op_bytes = def_ad_bytes = 4;
        break;
    case X86EMUL_MODE_PROT16:
        def_op_bytes = def_ad_bytes = 2;
        break;
    case X86EMUL_MODE_PROT32:
        def_op_bytes = def_ad_bytes = 4;
        break;
#ifdef CONFIG_X86_64
    case X86EMUL_MODE_PROT64:
        def_op_bytes = 4;
        def_ad_bytes = 8;
        break;
#endif
    default:
        return EMULATION_FAILED;
    }
 
    ctxt->op_bytes = def_op_bytes;
    ctxt->ad_bytes = def_ad_bytes;
 
    /* Legacy prefixes. */
    for (;;) {
        switch (ctxt->b = insn_fetch(u8, ctxt)) {
        case 0x66:  /* operand-size override */
            op_prefix = true;
            /* switch between 2/4 bytes */
            ctxt->op_bytes = def_op_bytes ^ 6;
            break;
        case 0x67:  /* address-size override */
            if (mode == X86EMUL_MODE_PROT64)
                /* switch between 4/8 bytes */
                ctxt->ad_bytes = def_ad_bytes ^ 12;
            else
                /* switch between 2/4 bytes */
                ctxt->ad_bytes = def_ad_bytes ^ 6;
            break;
        case 0x26:  /* ES override */
            has_seg_override = true;
            ctxt->seg_override = VCPU_SREG_ES;
            break;
        case 0x2e:  /* CS override */
            has_seg_override = true;
            ctxt->seg_override = VCPU_SREG_CS;
            break;
        case 0x36:  /* SS override */
            has_seg_override = true;
            ctxt->seg_override = VCPU_SREG_SS;
            break;
        case 0x3e:  /* DS override */
            has_seg_override = true;
            ctxt->seg_override = VCPU_SREG_DS;
            break;
        case 0x64:  /* FS override */
            has_seg_override = true;
            ctxt->seg_override = VCPU_SREG_FS;
            break;
        case 0x65:  /* GS override */
            has_seg_override = true;
            ctxt->seg_override = VCPU_SREG_GS;
            break;
        case 0x40 ... 0x4f: /* REX */
            if (mode != X86EMUL_MODE_PROT64)
                goto done_prefixes;
            ctxt->rex_prefix = ctxt->b;
            continue;
        case 0xf0:  /* LOCK */
            ctxt->lock_prefix = 1;
            break;
        case 0xf2:  /* REPNE/REPNZ */
        case 0xf3:  /* REP/REPE/REPZ */
            ctxt->rep_prefix = ctxt->b;
            break;
        default:
            goto done_prefixes;
        }
 
        /* Any legacy prefix after a REX prefix nullifies its effect. */
 
        ctxt->rex_prefix = 0;
    }
 
done_prefixes:
 
    /* REX prefix. */
    if (ctxt->rex_prefix & 8)
        ctxt->op_bytes = 8; /* REX.W */
 
    /* Opcode byte(s). */
    opcode = opcode_table[ctxt->b];
    /* Two-byte opcode? */
    if (ctxt->b == 0x0f) {
        ctxt->opcode_len = 2;
        ctxt->b = insn_fetch(u8, ctxt);
        opcode = twobyte_table[ctxt->b];
 
        /* 0F_38 opcode map */
        if (ctxt->b == 0x38) {
            ctxt->opcode_len = 3;
            ctxt->b = insn_fetch(u8, ctxt);
            opcode = opcode_map_0f_38[ctxt->b];
        }
    }
    ctxt->d = opcode.flags;
 
    if (ctxt->d & ModRM)
        ctxt->modrm = insn_fetch(u8, ctxt);
 
    /* vex-prefix instructions are not implemented */
    if (ctxt->opcode_len == 1 && (ctxt->b == 0xc5 || ctxt->b == 0xc4) &&
        (mode == X86EMUL_MODE_PROT64 || (ctxt->modrm & 0xc0) == 0xc0)) {
        ctxt->d = NotImpl;
    }
 
    while (ctxt->d & GroupMask) {
        switch (ctxt->d & GroupMask) {
        case Group:
            goffset = (ctxt->modrm >> 3) & 7;
            opcode = opcode.u.group[goffset];
            break;
        case GroupDual:
            goffset = (ctxt->modrm >> 3) & 7;
            if ((ctxt->modrm >> 6) == 3)
                opcode = opcode.u.gdual->mod3[goffset];
            else
                opcode = opcode.u.gdual->mod012[goffset];
            break;
        case RMExt:
            goffset = ctxt->modrm & 7;
            opcode = opcode.u.group[goffset];
            break;
        case Prefix:
            if (ctxt->rep_prefix && op_prefix)
                return EMULATION_FAILED;
            simd_prefix = op_prefix ? 0x66 : ctxt->rep_prefix;
            switch (simd_prefix) {
            case 0x00: opcode = opcode.u.gprefix->pfx_no; break;
            case 0x66: opcode = opcode.u.gprefix->pfx_66; break;
            case 0xf2: opcode = opcode.u.gprefix->pfx_f2; break;
            case 0xf3: opcode = opcode.u.gprefix->pfx_f3; break;
            }
            break;
        case Escape:
            if (ctxt->modrm > 0xbf) {
                size_t size = ARRAY_SIZE(opcode.u.esc->high);
                u32 index = array_index_nospec(
                    ctxt->modrm - 0xc0, size);
 
                opcode = opcode.u.esc->high[index];
            } else {
                opcode = opcode.u.esc->op[(ctxt->modrm >> 3) & 7];
            }
            break;
        case InstrDual:
            if ((ctxt->modrm >> 6) == 3)
                opcode = opcode.u.idual->mod3;
            else
                opcode = opcode.u.idual->mod012;
            break;
        case ModeDual:
            if (ctxt->mode == X86EMUL_MODE_PROT64)
                opcode = opcode.u.mdual->mode64;
            else
                opcode = opcode.u.mdual->mode32;
            break;
        default:
            return EMULATION_FAILED;
        }
 
        ctxt->d &= ~(u64)GroupMask;
        ctxt->d |= opcode.flags;
    }
 
    ctxt->is_branch = opcode.flags & IsBranch;
 
    /* Unrecognised? */
    if (ctxt->d == 0)
        return EMULATION_FAILED;
 
    ctxt->execute = opcode.u.execute;
 
    if (unlikely(emulation_type & EMULTYPE_TRAP_UD) &&
        likely(!(ctxt->d & EmulateOnUD)))
        return EMULATION_FAILED;
 
    if (unlikely(ctxt->d &
        (NotImpl|Stack|Op3264|Sse|Mmx|Intercept|CheckPerm|NearBranch|
         No16))) {
        /*
         * These are copied unconditionally here, and checked unconditionally
         * in x86_emulate_insn.
         */
        ctxt->check_perm = opcode.check_perm;
        ctxt->intercept = opcode.intercept;
 
        if (ctxt->d & NotImpl)
            return EMULATION_FAILED;
 
        if (mode == X86EMUL_MODE_PROT64) {
            if (ctxt->op_bytes == 4 && (ctxt->d & Stack))
                ctxt->op_bytes = 8;
            else if (ctxt->d & NearBranch)
                ctxt->op_bytes = 8;
        }
 
        if (ctxt->d & Op3264) {
            if (mode == X86EMUL_MODE_PROT64)
                ctxt->op_bytes = 8;
            else
                ctxt->op_bytes = 4;
        }
 
        if ((ctxt->d & No16) && ctxt->op_bytes == 2)
            ctxt->op_bytes = 4;
 
        if (ctxt->d & Sse)
            ctxt->op_bytes = 16;
        else if (ctxt->d & Mmx)
            ctxt->op_bytes = 8;
    }
 
    /* ModRM and SIB bytes. */
    if (ctxt->d & ModRM) {
        rc = decode_modrm(ctxt, &ctxt->memop);
        if (!has_seg_override) {
            has_seg_override = true;
            ctxt->seg_override = ctxt->modrm_seg;
        }
    } else if (ctxt->d & MemAbs)
        rc = decode_abs(ctxt, &ctxt->memop);
    if (rc != X86EMUL_CONTINUE)
        goto done;
 
    if (!has_seg_override)
        ctxt->seg_override = VCPU_SREG_DS;
 
    ctxt->memop.addr.mem.seg = ctxt->seg_override;
 
    /*
     * Decode and fetch the source operand: register, memory
     * or immediate.
     */
    rc = decode_operand(ctxt, &ctxt->src, (ctxt->d >> SrcShift) & OpMask);
    if (rc != X86EMUL_CONTINUE)
        goto done;
 
    /*
     * Decode and fetch the second source operand: register, memory
     * or immediate.
     */
    rc = decode_operand(ctxt, &ctxt->src2, (ctxt->d >> Src2Shift) & OpMask);
    if (rc != X86EMUL_CONTINUE)
        goto done;
 
    /* Decode and fetch the destination operand: register or memory. */
    rc = decode_operand(ctxt, &ctxt->dst, (ctxt->d >> DstShift) & OpMask);
 
    if (ctxt->rip_relative && likely(ctxt->memopp))
        ctxt->memopp->addr.mem.ea = address_mask(ctxt,
                    ctxt->memopp->addr.mem.ea + ctxt->_eip);
 
done:
    if (rc == X86EMUL_PROPAGATE_FAULT)
        ctxt->have_exception = true;
    return (rc != X86EMUL_CONTINUE) ? EMULATION_FAILED : EMULATION_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

x86_emulate_insn()

int x86_emulate_insn

(

struct x86_emulate_ctxt *

ctxt

)

Definition at line 5140 of file emulate.c.

{
    const struct x86_emulate_ops *ops = ctxt->ops;
    int rc = X86EMUL_CONTINUE;
    int saved_dst_type = ctxt->dst.type;
    bool is_guest_mode = ctxt->ops->is_guest_mode(ctxt);
 
    ctxt->mem_read.pos = 0;
 
    /* LOCK prefix is allowed only with some instructions */
    if (ctxt->lock_prefix && (!(ctxt->d & Lock) || ctxt->dst.type != OP_MEM)) {
        rc = emulate_ud(ctxt);
        goto done;
    }
 
    if ((ctxt->d & SrcMask) == SrcMemFAddr && ctxt->src.type != OP_MEM) {
        rc = emulate_ud(ctxt);
        goto done;
    }
 
    if (unlikely(ctxt->d &
             (No64|Undefined|Sse|Mmx|Intercept|CheckPerm|Priv|Prot|String))) {
        if ((ctxt->mode == X86EMUL_MODE_PROT64 && (ctxt->d & No64)) ||
                (ctxt->d & Undefined)) {
            rc = emulate_ud(ctxt);
            goto done;
        }
 
        if (((ctxt->d & (Sse|Mmx)) && ((ops->get_cr(ctxt, 0) & X86_CR0_EM)))
            || ((ctxt->d & Sse) && !(ops->get_cr(ctxt, 4) & X86_CR4_OSFXSR))) {
            rc = emulate_ud(ctxt);
            goto done;
        }
 
        if ((ctxt->d & (Sse|Mmx)) && (ops->get_cr(ctxt, 0) & X86_CR0_TS)) {
            rc = emulate_nm(ctxt);
            goto done;
        }
 
        if (ctxt->d & Mmx) {
            rc = flush_pending_x87_faults(ctxt);
            if (rc != X86EMUL_CONTINUE)
                goto done;
            /*
             * Now that we know the fpu is exception safe, we can fetch
             * operands from it.
             */
            fetch_possible_mmx_operand(&ctxt->src);
            fetch_possible_mmx_operand(&ctxt->src2);
            if (!(ctxt->d & Mov))
                fetch_possible_mmx_operand(&ctxt->dst);
        }
 
        if (unlikely(is_guest_mode) && ctxt->intercept) {
            rc = emulator_check_intercept(ctxt, ctxt->intercept,
                              X86_ICPT_PRE_EXCEPT);
            if (rc != X86EMUL_CONTINUE)
                goto done;
        }
 
        /* Instruction can only be executed in protected mode */
        if ((ctxt->d & Prot) && ctxt->mode < X86EMUL_MODE_PROT16) {
            rc = emulate_ud(ctxt);
            goto done;
        }
 
        /* Privileged instruction can be executed only in CPL=0 */
        if ((ctxt->d & Priv) && ops->cpl(ctxt)) {
            if (ctxt->d & PrivUD)
                rc = emulate_ud(ctxt);
            else
                rc = emulate_gp(ctxt, 0);
            goto done;
        }
 
        /* Do instruction specific permission checks */
        if (ctxt->d & CheckPerm) {
            rc = ctxt->check_perm(ctxt);
            if (rc != X86EMUL_CONTINUE)
                goto done;
        }
 
        if (unlikely(is_guest_mode) && (ctxt->d & Intercept)) {
            rc = emulator_check_intercept(ctxt, ctxt->intercept,
                              X86_ICPT_POST_EXCEPT);
            if (rc != X86EMUL_CONTINUE)
                goto done;
        }
 
        if (ctxt->rep_prefix && (ctxt->d & String)) {
            /* All REP prefixes have the same first termination condition */
            if (address_mask(ctxt, reg_read(ctxt, VCPU_REGS_RCX)) == 0) {
                string_registers_quirk(ctxt);
                ctxt->eip = ctxt->_eip;
                ctxt->eflags &= ~X86_EFLAGS_RF;
                goto done;
            }
        }
    }
 
    if ((ctxt->src.type == OP_MEM) && !(ctxt->d & NoAccess)) {
        rc = segmented_read(ctxt, ctxt->src.addr.mem,
                    ctxt->src.valptr, ctxt->src.bytes);
        if (rc != X86EMUL_CONTINUE)
            goto done;
        ctxt->src.orig_val64 = ctxt->src.val64;
    }
 
    if (ctxt->src2.type == OP_MEM) {
        rc = segmented_read(ctxt, ctxt->src2.addr.mem,
                    &ctxt->src2.val, ctxt->src2.bytes);
        if (rc != X86EMUL_CONTINUE)
            goto done;
    }
 
    if ((ctxt->d & DstMask) == ImplicitOps)
        goto special_insn;
 
 
    if ((ctxt->dst.type == OP_MEM) && !(ctxt->d & Mov)) {
        /* optimisation - avoid slow emulated read if Mov */
        rc = segmented_read(ctxt, ctxt->dst.addr.mem,
                   &ctxt->dst.val, ctxt->dst.bytes);
        if (rc != X86EMUL_CONTINUE) {
            if (!(ctxt->d & NoWrite) &&
                rc == X86EMUL_PROPAGATE_FAULT &&
                ctxt->exception.vector == PF_VECTOR)
                ctxt->exception.error_code |= PFERR_WRITE_MASK;
            goto done;
        }
    }
    /* Copy full 64-bit value for CMPXCHG8B.  */
    ctxt->dst.orig_val64 = ctxt->dst.val64;
 
special_insn:
 
    if (unlikely(is_guest_mode) && (ctxt->d & Intercept)) {
        rc = emulator_check_intercept(ctxt, ctxt->intercept,
                          X86_ICPT_POST_MEMACCESS);
        if (rc != X86EMUL_CONTINUE)
            goto done;
    }
 
    if (ctxt->rep_prefix && (ctxt->d & String))
        ctxt->eflags |= X86_EFLAGS_RF;
    else
        ctxt->eflags &= ~X86_EFLAGS_RF;
 
    if (ctxt->execute) {
        if (ctxt->d & Fastop)
            rc = fastop(ctxt, ctxt->fop);
        else
            rc = ctxt->execute(ctxt);
        if (rc != X86EMUL_CONTINUE)
            goto done;
        goto writeback;
    }
 
    if (ctxt->opcode_len == 2)
        goto twobyte_insn;
    else if (ctxt->opcode_len == 3)
        goto threebyte_insn;
 
    switch (ctxt->b) {
    case 0x70 ... 0x7f: /* jcc (short) */
        if (test_cc(ctxt->b, ctxt->eflags))
            rc = jmp_rel(ctxt, ctxt->src.val);
        break;
    case 0x8d: /* lea r16/r32, m */
        ctxt->dst.val = ctxt->src.addr.mem.ea;
        break;
    case 0x90 ... 0x97: /* nop / xchg reg, rax */
        if (ctxt->dst.addr.reg == reg_rmw(ctxt, VCPU_REGS_RAX))
            ctxt->dst.type = OP_NONE;
        else
            rc = em_xchg(ctxt);
        break;
    case 0x98: /* cbw/cwde/cdqe */
        switch (ctxt->op_bytes) {
        case 2: ctxt->dst.val = (s8)ctxt->dst.val; break;
        case 4: ctxt->dst.val = (s16)ctxt->dst.val; break;
        case 8: ctxt->dst.val = (s32)ctxt->dst.val; break;
        }
        break;
    case 0xcc:      /* int3 */
        rc = emulate_int(ctxt, 3);
        break;
    case 0xcd:      /* int n */
        rc = emulate_int(ctxt, ctxt->src.val);
        break;
    case 0xce:      /* into */
        if (ctxt->eflags & X86_EFLAGS_OF)
            rc = emulate_int(ctxt, 4);
        break;
    case 0xe9: /* jmp rel */
    case 0xeb: /* jmp rel short */
        rc = jmp_rel(ctxt, ctxt->src.val);
        ctxt->dst.type = OP_NONE; /* Disable writeback. */
        break;
    case 0xf4:              /* hlt */
        ctxt->ops->halt(ctxt);
        break;
    case 0xf5:  /* cmc */
        /* complement carry flag from eflags reg */
        ctxt->eflags ^= X86_EFLAGS_CF;
        break;
    case 0xf8: /* clc */
        ctxt->eflags &= ~X86_EFLAGS_CF;
        break;
    case 0xf9: /* stc */
        ctxt->eflags |= X86_EFLAGS_CF;
        break;
    case 0xfc: /* cld */
        ctxt->eflags &= ~X86_EFLAGS_DF;
        break;
    case 0xfd: /* std */
        ctxt->eflags |= X86_EFLAGS_DF;
        break;
    default:
        goto cannot_emulate;
    }
 
    if (rc != X86EMUL_CONTINUE)
        goto done;
 
writeback:
    if (ctxt->d & SrcWrite) {
        BUG_ON(ctxt->src.type == OP_MEM || ctxt->src.type == OP_MEM_STR);
        rc = writeback(ctxt, &ctxt->src);
        if (rc != X86EMUL_CONTINUE)
            goto done;
    }
    if (!(ctxt->d & NoWrite)) {
        rc = writeback(ctxt, &ctxt->dst);
        if (rc != X86EMUL_CONTINUE)
            goto done;
    }
 
    /*
     * restore dst type in case the decoding will be reused
     * (happens for string instruction )
     */
    ctxt->dst.type = saved_dst_type;
 
    if ((ctxt->d & SrcMask) == SrcSI)
        string_addr_inc(ctxt, VCPU_REGS_RSI, &ctxt->src);
 
    if ((ctxt->d & DstMask) == DstDI)
        string_addr_inc(ctxt, VCPU_REGS_RDI, &ctxt->dst);
 
    if (ctxt->rep_prefix && (ctxt->d & String)) {
        unsigned int count;
        struct read_cache *r = &ctxt->io_read;
        if ((ctxt->d & SrcMask) == SrcSI)
            count = ctxt->src.count;
        else
            count = ctxt->dst.count;
        register_address_increment(ctxt, VCPU_REGS_RCX, -count);
 
        if (!string_insn_completed(ctxt)) {
            /*
             * Re-enter guest when pio read ahead buffer is empty
             * or, if it is not used, after each 1024 iteration.
             */
            if ((r->end != 0 || reg_read(ctxt, VCPU_REGS_RCX) & 0x3ff) &&
                (r->end == 0 || r->end != r->pos)) {
                /*
                 * Reset read cache. Usually happens before
                 * decode, but since instruction is restarted
                 * we have to do it here.
                 */
                ctxt->mem_read.end = 0;
                writeback_registers(ctxt);
                return EMULATION_RESTART;
            }
            goto done; /* skip rip writeback */
        }
        ctxt->eflags &= ~X86_EFLAGS_RF;
    }
 
    ctxt->eip = ctxt->_eip;
    if (ctxt->mode != X86EMUL_MODE_PROT64)
        ctxt->eip = (u32)ctxt->_eip;
 
done:
    if (rc == X86EMUL_PROPAGATE_FAULT) {
        if (KVM_EMULATOR_BUG_ON(ctxt->exception.vector > 0x1f, ctxt))
            return EMULATION_FAILED;
        ctxt->have_exception = true;
    }
    if (rc == X86EMUL_INTERCEPTED)
        return EMULATION_INTERCEPTED;
 
    if (rc == X86EMUL_CONTINUE)
        writeback_registers(ctxt);
 
    return (rc == X86EMUL_UNHANDLEABLE) ? EMULATION_FAILED : EMULATION_OK;
 
twobyte_insn:
    switch (ctxt->b) {
    case 0x09:      /* wbinvd */
        (ctxt->ops->wbinvd)(ctxt);
        break;
    case 0x08:      /* invd */
    case 0x0d:      /* GrpP (prefetch) */
    case 0x18:      /* Grp16 (prefetch/nop) */
    case 0x1f:      /* nop */
        break;
    case 0x20: /* mov cr, reg */
        ctxt->dst.val = ops->get_cr(ctxt, ctxt->modrm_reg);
        break;
    case 0x21: /* mov from dr to reg */
        ops->get_dr(ctxt, ctxt->modrm_reg, &ctxt->dst.val);
        break;
    case 0x40 ... 0x4f: /* cmov */
        if (test_cc(ctxt->b, ctxt->eflags))
            ctxt->dst.val = ctxt->src.val;
        else if (ctxt->op_bytes != 4)
            ctxt->dst.type = OP_NONE; /* no writeback */
        break;
    case 0x80 ... 0x8f: /* jnz rel, etc*/
        if (test_cc(ctxt->b, ctxt->eflags))
            rc = jmp_rel(ctxt, ctxt->src.val);
        break;
    case 0x90 ... 0x9f:     /* setcc r/m8 */
        ctxt->dst.val = test_cc(ctxt->b, ctxt->eflags);
        break;
    case 0xb6 ... 0xb7: /* movzx */
        ctxt->dst.bytes = ctxt->op_bytes;
        ctxt->dst.val = (ctxt->src.bytes == 1) ? (u8) ctxt->src.val
                               : (u16) ctxt->src.val;
        break;
    case 0xbe ... 0xbf: /* movsx */
        ctxt->dst.bytes = ctxt->op_bytes;
        ctxt->dst.val = (ctxt->src.bytes == 1) ? (s8) ctxt->src.val :
                            (s16) ctxt->src.val;
        break;
    default:
        goto cannot_emulate;
    }
 
threebyte_insn:
 
    if (rc != X86EMUL_CONTINUE)
        goto done;
 
    goto writeback;
 
cannot_emulate:
    return EMULATION_FAILED;
}

Here is the call graph for this function:

Here is the caller graph for this function:

x86_page_table_writing_insn()

bool x86_page_table_writing_insn

(

struct x86_emulate_ctxt *

ctxt

)

Definition at line 5062 of file emulate.c.

{
    return ctxt->d & PageTable;
}

Here is the caller graph for this function: