arch/x86/kvm/emulate.c

   1 /******************************************************************************
   2  * emulate.c
   3  *
   4  * Generic x86 (32-bit and 64-bit) instruction decoder and emulator.
   5  *
   6  * Copyright (c) 2005 Keir Fraser
   7  *
   8  * Linux coding style, mod r/m decoder, segment base fixes, real-mode
   9  * privileged instructions:
  10  *
  11  * Copyright (C) 2006 Qumranet
  12  * Copyright 2010 Red Hat, Inc. and/or its affilates.
  13  *
  14  *   Avi Kivity <avi@qumranet.com>
  15  *   Yaniv Kamay <yaniv@qumranet.com>
  16  *
  17  * This work is licensed under the terms of the GNU GPL, version 2.  See
  18  * the COPYING file in the top-level directory.
  19  *
  20  * From: xen-unstable 10676:af9809f51f81a3c43f276f00c81a52ef558afda4
  21  */
  22
  23 #ifndef __KERNEL__
  24 #include <stdio.h>
  25 #include <stdint.h>
  26 #include <public/xen.h>
  27 #define DPRINTF(_f, _a ...) printf(_f , ## _a)
  28 #else
  29 #include <linux/kvm_host.h>
  30 #include "kvm_cache_regs.h"
  31 #define DPRINTF(x...) do {} while (0)
  32 #endif
  33 #include <linux/module.h>
  34 #include <asm/kvm_emulate.h>
  35
  36 #include "x86.h"
  37 #include "tss.h"
  38
  39 /*
  40  * Opcode effective-address decode tables.
  41  * Note that we only emulate instructions that have at least one memory
  42  * operand (excluding implicit stack references). We assume that stack
  43  * references and instruction fetches will never occur in special memory
  44  * areas that require emulation. So, for example, 'mov <imm>,<reg>' need
  45  * not be handled.
  46  */
  47
  48 /* Operand sizes: 8-bit operands or specified/overridden size. */
  49 #define ByteOp      (1<<0)      /* 8-bit operands. */
  50 /* Destination operand type. */
  51 #define ImplicitOps (1<<1)      /* Implicit in opcode. No generic decode. */
  52 #define DstReg      (2<<1)      /* Register operand. */
  53 #define DstMem      (3<<1)      /* Memory operand. */
  54 #define DstAcc      (4<<1)      /* Destination Accumulator */
  55 #define DstDI       (5<<1)      /* Destination is in ES:(E)DI */
  56 #define DstMem64    (6<<1)      /* 64bit memory operand */
  57 #define DstImmUByte (7<<1)      /* 8-bit unsigned immediate operand */
  58 #define DstMask     (7<<1)
  59 /* Source operand type. */
  60 #define SrcNone     (0<<4)      /* No source operand. */
  61 #define SrcReg      (1<<4)      /* Register operand. */
  62 #define SrcMem      (2<<4)      /* Memory operand. */
  63 #define SrcMem16    (3<<4)      /* Memory operand (16-bit). */
  64 #define SrcMem32    (4<<4)      /* Memory operand (32-bit). */
  65 #define SrcImm      (5<<4)      /* Immediate operand. */
  66 #define SrcImmByte  (6<<4)      /* 8-bit sign-extended immediate operand. */
  67 #define SrcOne      (7<<4)      /* Implied '1' */
  68 #define SrcImmUByte (8<<4)      /* 8-bit unsigned immediate operand. */
  69 #define SrcImmU     (9<<4)      /* Immediate operand, unsigned */
  70 #define SrcSI       (0xa<<4)    /* Source is in the DS:RSI */
  71 #define SrcImmFAddr (0xb<<4)    /* Source is immediate far address */
  72 #define SrcMemFAddr (0xc<<4)    /* Source is far address in memory */
  73 #define SrcAcc      (0xd<<4)    /* Source Accumulator */
  74 #define SrcImmU16   (0xe<<4)    /* Immediate operand, unsigned, 16 bits */
  75 #define SrcMask     (0xf<<4)
  76 /* Generic ModRM decode. */
  77 #define ModRM       (1<<8)
  78 /* Destination is only written; never read. */
  79 #define Mov         (1<<9)
  80 #define BitOp       (1<<10)
  81 #define MemAbs      (1<<11)      /* Memory operand is absolute displacement */
  82 #define String      (1<<12)     /* String instruction (rep capable) */
  83 #define Stack       (1<<13)     /* Stack instruction (push/pop) */
  84 #define Group       (1<<14)     /* Bits 3:5 of modrm byte extend opcode */
  85 #define GroupDual   (1<<15)     /* Alternate decoding of mod == 3 */
  86 /* Misc flags */
  87 #define NoAccess    (1<<23) /* Don't access memory (lea/invlpg/verr etc) */
  88 #define Op3264      (1<<24) /* Operand is 64b in long mode, 32b otherwise */
  89 #define Undefined   (1<<25) /* No Such Instruction */
  90 #define Lock        (1<<26) /* lock prefix is allowed for the instruction */
  91 #define Priv        (1<<27) /* instruction generates #GP if current CPL != 0 */
  92 #define No64        (1<<28)
  93 /* Source 2 operand type */
  94 #define Src2None    (0<<29)
  95 #define Src2CL      (1<<29)
  96 #define Src2ImmByte (2<<29)
  97 #define Src2One     (3<<29)
  98 #define Src2Imm     (4<<29)
  99 #define Src2Mask    (7<<29)
 100
 101 #define X2(x...) x, x
 102 #define X3(x...) X2(x), x
 103 #define X4(x...) X2(x), X2(x)
 104 #define X5(x...) X4(x), x
 105 #define X6(x...) X4(x), X2(x)
 106 #define X7(x...) X4(x), X3(x)
 107 #define X8(x...) X4(x), X4(x)
 108 #define X16(x...) X8(x), X8(x)
 109
 110 struct opcode {
 111         u32 flags;
 112         union {
 113                 int (*execute)(struct x86_emulate_ctxt *ctxt);
 114                 struct opcode *group;
 115                 struct group_dual *gdual;
 116         } u;
 117 };
 118
 119 struct group_dual {
 120         struct opcode mod012[8];
 121         struct opcode mod3[8];
 122 };
 123
 124 /* EFLAGS bit definitions. */
 125 #define EFLG_ID (1<<21)
 126 #define EFLG_VIP (1<<20)
 127 #define EFLG_VIF (1<<19)
 128 #define EFLG_AC (1<<18)
 129 #define EFLG_VM (1<<17)
 130 #define EFLG_RF (1<<16)
 131 #define EFLG_IOPL (3<<12)
 132 #define EFLG_NT (1<<14)
 133 #define EFLG_OF (1<<11)
 134 #define EFLG_DF (1<<10)
 135 #define EFLG_IF (1<<9)
 136 #define EFLG_TF (1<<8)
 137 #define EFLG_SF (1<<7)
 138 #define EFLG_ZF (1<<6)
 139 #define EFLG_AF (1<<4)
 140 #define EFLG_PF (1<<2)
 141 #define EFLG_CF (1<<0)
 142
 143 #define EFLG_RESERVED_ZEROS_MASK 0xffc0802a
 144 #define EFLG_RESERVED_ONE_MASK 2
 145
 146 /*
 147  * Instruction emulation:
 148  * Most instructions are emulated directly via a fragment of inline assembly
 149  * code. This allows us to save/restore EFLAGS and thus very easily pick up
 150  * any modified flags.
 151  */
 152
 153 #if defined(CONFIG_X86_64)
 154 #define _LO32 "k"               /* force 32-bit operand */
 155 #define _STK  "%%rsp"           /* stack pointer */
 156 #elif defined(__i386__)
 157 #define _LO32 ""                /* force 32-bit operand */
 158 #define _STK  "%%esp"           /* stack pointer */
 159 #endif
 160
 161 /*
 162  * These EFLAGS bits are restored from saved value during emulation, and
 163  * any changes are written back to the saved value after emulation.
 164  */
 165 #define EFLAGS_MASK (EFLG_OF|EFLG_SF|EFLG_ZF|EFLG_AF|EFLG_PF|EFLG_CF)
 166
 167 /* Before executing instruction: restore necessary bits in EFLAGS. */
 168 #define _PRE_EFLAGS(_sav, _msk, _tmp)                                   \
 169         /* EFLAGS = (_sav & _msk) | (EFLAGS & ~_msk); _sav &= ~_msk; */ \
 170         "movl %"_sav",%"_LO32 _tmp"; "                                  \
 171         "push %"_tmp"; "                                                \
 172         "push %"_tmp"; "                                                \
 173         "movl %"_msk",%"_LO32 _tmp"; "                                  \
 174         "andl %"_LO32 _tmp",("_STK"); "                                 \
 175         "pushf; "                                                       \
 176         "notl %"_LO32 _tmp"; "                                          \
 177         "andl %"_LO32 _tmp",("_STK"); "                                 \
 178         "andl %"_LO32 _tmp","__stringify(BITS_PER_LONG/4)"("_STK"); "   \
 179         "pop  %"_tmp"; "                                                \
 180         "orl  %"_LO32 _tmp",("_STK"); "                                 \
 181         "popf; "                                                        \
 182         "pop  %"_sav"; "
 183
 184 /* After executing instruction: write-back necessary bits in EFLAGS. */
 185 #define _POST_EFLAGS(_sav, _msk, _tmp) \
 186         /* _sav |= EFLAGS & _msk; */            \
 187         "pushf; "                               \
 188         "pop  %"_tmp"; "                        \
 189         "andl %"_msk",%"_LO32 _tmp"; "          \
 190         "orl  %"_LO32 _tmp",%"_sav"; "
 191
 192 #ifdef CONFIG_X86_64
 193 #define ON64(x) x
 194 #else
 195 #define ON64(x)
 196 #endif
 197
 198 #define ____emulate_2op(_op, _src, _dst, _eflags, _x, _y, _suffix, _dsttype) \
 199         do {                                                            \
 200                 __asm__ __volatile__ (                                  \
 201                         _PRE_EFLAGS("0", "4", "2")                      \
 202                         _op _suffix " %"_x"3,%1; "                      \
 203                         _POST_EFLAGS("0", "4", "2")                     \
 204                         : "=m" (_eflags), "+q" (*(_dsttype*)&(_dst).val),\
 205                           "=&r" (_tmp)                                  \
 206                         : _y ((_src).val), "i" (EFLAGS_MASK));          \
 207         } while (0)
 208
 209
 210 /* Raw emulation: instruction has two explicit operands. */
 211 #define __emulate_2op_nobyte(_op,_src,_dst,_eflags,_wx,_wy,_lx,_ly,_qx,_qy) \
 212         do {                                                            \
 213                 unsigned long _tmp;                                     \
 214                                                                         \
 215                 switch ((_dst).bytes) {                                 \
 216                 case 2:                                                 \
 217                         ____emulate_2op(_op,_src,_dst,_eflags,_wx,_wy,"w",u16);\
 218                         break;                                          \
 219                 case 4:                                                 \
 220                         ____emulate_2op(_op,_src,_dst,_eflags,_lx,_ly,"l",u32);\
 221                         break;                                          \
 222                 case 8:                                                 \
 223                         ON64(____emulate_2op(_op,_src,_dst,_eflags,_qx,_qy,"q",u64)); \
 224                         break;                                          \
 225                 }                                                       \
 226         } while (0)
 227
 228 #define __emulate_2op(_op,_src,_dst,_eflags,_bx,_by,_wx,_wy,_lx,_ly,_qx,_qy) \
 229         do {                                                                 \
 230                 unsigned long _tmp;                                          \
 231                 switch ((_dst).bytes) {                                      \
 232                 case 1:                                                      \
 233                         ____emulate_2op(_op,_src,_dst,_eflags,_bx,_by,"b",u8); \
 234                         break;                                               \
 235                 default:                                                     \
 236                         __emulate_2op_nobyte(_op, _src, _dst, _eflags,       \
 237                                              _wx, _wy, _lx, _ly, _qx, _qy);  \
 238                         break;                                               \
 239                 }                                                            \
 240         } while (0)
 241
 242 /* Source operand is byte-sized and may be restricted to just %cl. */
 243 #define emulate_2op_SrcB(_op, _src, _dst, _eflags)                      \
 244         __emulate_2op(_op, _src, _dst, _eflags,                         \
 245                       "b", "c", "b", "c", "b", "c", "b", "c")
 246
 247 /* Source operand is byte, word, long or quad sized. */
 248 #define emulate_2op_SrcV(_op, _src, _dst, _eflags)                      \
 249         __emulate_2op(_op, _src, _dst, _eflags,                         \
 250                       "b", "q", "w", "r", _LO32, "r", "", "r")
 251
 252 /* Source operand is word, long or quad sized. */
 253 #define emulate_2op_SrcV_nobyte(_op, _src, _dst, _eflags)               \
 254         __emulate_2op_nobyte(_op, _src, _dst, _eflags,                  \
 255                              "w", "r", _LO32, "r", "", "r")
 256
 257 /* Instruction has three operands and one operand is stored in ECX register */
 258 #define __emulate_2op_cl(_op, _cl, _src, _dst, _eflags, _suffix, _type)         \
 259         do {                                                                    \
 260                 unsigned long _tmp;                                             \
 261                 _type _clv  = (_cl).val;                                        \
 262                 _type _srcv = (_src).val;                                       \
 263                 _type _dstv = (_dst).val;                                       \
 264                                                                                 \
 265                 __asm__ __volatile__ (                                          \
 266                         _PRE_EFLAGS("0", "5", "2")                              \
 267                         _op _suffix " %4,%1 \n"                                 \
 268                         _POST_EFLAGS("0", "5", "2")                             \
 269                         : "=m" (_eflags), "+r" (_dstv), "=&r" (_tmp)            \
 270                         : "c" (_clv) , "r" (_srcv), "i" (EFLAGS_MASK)           \
 271                         );                                                      \
 272                                                                                 \
 273                 (_cl).val  = (unsigned long) _clv;                              \
 274                 (_src).val = (unsigned long) _srcv;                             \
 275                 (_dst).val = (unsigned long) _dstv;                             \
 276         } while (0)
 277
 278 #define emulate_2op_cl(_op, _cl, _src, _dst, _eflags)                           \
 279         do {                                                                    \
 280                 switch ((_dst).bytes) {                                         \
 281                 case 2:                                                         \
 282                         __emulate_2op_cl(_op, _cl, _src, _dst, _eflags,         \
 283                                                 "w", unsigned short);           \
 284                         break;                                                  \
 285                 case 4:                                                         \
 286                         __emulate_2op_cl(_op, _cl, _src, _dst, _eflags,         \
 287                                                 "l", unsigned int);             \
 288                         break;                                                  \
 289                 case 8:                                                         \
 290                         ON64(__emulate_2op_cl(_op, _cl, _src, _dst, _eflags,    \
 291                                                 "q", unsigned long));           \
 292                         break;                                                  \
 293                 }                                                               \
 294         } while (0)
 295
 296 #define __emulate_1op(_op, _dst, _eflags, _suffix)                      \
 297         do {                                                            \
 298                 unsigned long _tmp;                                     \
 299                                                                         \
 300                 __asm__ __volatile__ (                                  \
 301                         _PRE_EFLAGS("0", "3", "2")                      \
 302                         _op _suffix " %1; "                             \
 303                         _POST_EFLAGS("0", "3", "2")                     \
 304                         : "=m" (_eflags), "+m" ((_dst).val),            \
 305                           "=&r" (_tmp)                                  \
 306                         : "i" (EFLAGS_MASK));                           \
 307         } while (0)
 308
 309 /* Instruction has only one explicit operand (no source operand). */
 310 #define emulate_1op(_op, _dst, _eflags)                                    \
 311         do {                                                            \
 312                 switch ((_dst).bytes) {                                 \
 313                 case 1: __emulate_1op(_op, _dst, _eflags, "b"); break;  \
 314                 case 2: __emulate_1op(_op, _dst, _eflags, "w"); break;  \
 315                 case 4: __emulate_1op(_op, _dst, _eflags, "l"); break;  \
 316                 case 8: ON64(__emulate_1op(_op, _dst, _eflags, "q")); break; \
 317                 }                                                       \
 318         } while (0)
 319
 320 #define __emulate_1op_rax_rdx(_op, _src, _rax, _rdx, _eflags, _suffix)          \
 321         do {                                                            \
 322                 unsigned long _tmp;                                     \
 323                                                                         \
 324                 __asm__ __volatile__ (                                  \
 325                         _PRE_EFLAGS("0", "4", "1")                      \
 326                         _op _suffix " %5; "                             \
 327                         _POST_EFLAGS("0", "4", "1")                     \
 328                         : "=m" (_eflags), "=&r" (_tmp),                 \
 329                           "+a" (_rax), "+d" (_rdx)                      \
 330                         : "i" (EFLAGS_MASK), "m" ((_src).val),          \
 331                           "a" (_rax), "d" (_rdx));                      \
 332         } while (0)
 333
 334 #define __emulate_1op_rax_rdx_ex(_op, _src, _rax, _rdx, _eflags, _suffix, _ex) \
 335         do {                                                            \
 336                 unsigned long _tmp;                                     \
 337                                                                         \
 338                 __asm__ __volatile__ (                                  \
 339                         _PRE_EFLAGS("0", "5", "1")                      \
 340                         "1: \n\t"                                       \
 341                         _op _suffix " %6; "                             \
 342                         "2: \n\t"                                       \
 343                         _POST_EFLAGS("0", "5", "1")                     \
 344                         ".pushsection .fixup,\"ax\" \n\t"               \
 345                         "3: movb $1, %4 \n\t"                           \
 346                         "jmp 2b \n\t"                                   \
 347                         ".popsection \n\t"                              \
 348                         _ASM_EXTABLE(1b, 3b)                            \
 349                         : "=m" (_eflags), "=&r" (_tmp),                 \
 350                           "+a" (_rax), "+d" (_rdx), "+qm"(_ex)          \
 351                         : "i" (EFLAGS_MASK), "m" ((_src).val),          \
 352                           "a" (_rax), "d" (_rdx));                      \
 353         } while (0)
 354
 355 /* instruction has only one source operand, destination is implicit (e.g. mul, div, imul, idiv) */
 356 #define emulate_1op_rax_rdx(_op, _src, _rax, _rdx, _eflags)                     \
 357         do {                                                                    \
 358                 switch((_src).bytes) {                                          \
 359                 case 1: __emulate_1op_rax_rdx(_op, _src, _rax, _rdx, _eflags, "b"); break; \
 360                 case 2: __emulate_1op_rax_rdx(_op, _src, _rax, _rdx,  _eflags, "w"); break; \
 361                 case 4: __emulate_1op_rax_rdx(_op, _src, _rax, _rdx, _eflags, "l"); break; \
 362                 case 8: ON64(__emulate_1op_rax_rdx(_op, _src, _rax, _rdx, _eflags, "q")); break; \
 363                 }                                                       \
 364         } while (0)
 365
 366 #define emulate_1op_rax_rdx_ex(_op, _src, _rax, _rdx, _eflags, _ex)     \
 367         do {                                                            \
 368                 switch((_src).bytes) {                                  \
 369                 case 1:                                                 \
 370                         __emulate_1op_rax_rdx_ex(_op, _src, _rax, _rdx, \
 371                                                  _eflags, "b", _ex);    \
 372                         break;                                          \
 373                 case 2:                                                 \
 374                         __emulate_1op_rax_rdx_ex(_op, _src, _rax, _rdx, \
 375                                                  _eflags, "w", _ex);    \
 376                         break;                                          \
 377                 case 4:                                                 \
 378                         __emulate_1op_rax_rdx_ex(_op, _src, _rax, _rdx, \
 379                                                  _eflags, "l", _ex);    \
 380                         break;                                          \
 381                 case 8: ON64(                                           \
 382                         __emulate_1op_rax_rdx_ex(_op, _src, _rax, _rdx, \
 383                                                  _eflags, "q", _ex));   \
 384                         break;                                          \
 385                 }                                                       \
 386         } while (0)
 387
 388 /* Fetch next part of the instruction being emulated. */
 389 #define insn_fetch(_type, _size, _eip)                                  \
 390 ({      unsigned long _x;                                               \
 391         rc = do_insn_fetch(ctxt, ops, (_eip), &_x, (_size));            \
 392         if (rc != X86EMUL_CONTINUE)                                     \
 393                 goto done;                                              \
 394         (_eip) += (_size);                                              \
 395         (_type)_x;                                                      \
 396 })
 397
 398 #define insn_fetch_arr(_arr, _size, _eip)                                \
 399 ({      rc = do_insn_fetch(ctxt, ops, (_eip), _arr, (_size));           \
 400         if (rc != X86EMUL_CONTINUE)                                     \
 401                 goto done;                                              \
 402         (_eip) += (_size);                                              \
 403 })
 404
 405 static inline unsigned long ad_mask(struct decode_cache *c)
 406 {
 407         return (1UL << (c->ad_bytes << 3)) - 1;
 408 }
 409
 410 /* Access/update address held in a register, based on addressing mode. */
 411 static inline unsigned long
 412 address_mask(struct decode_cache *c, unsigned long reg)
 413 {
 414         if (c->ad_bytes == sizeof(unsigned long))
 415                 return reg;
 416         else
 417                 return reg & ad_mask(c);
 418 }
 419
 420 static inline unsigned long
 421 register_address(struct decode_cache *c, unsigned long base, unsigned long reg)
 422 {
 423         return base + address_mask(c, reg);
 424 }
 425
 426 static inline void
 427 register_address_increment(struct decode_cache *c, unsigned long *reg, int inc)
 428 {
 429         if (c->ad_bytes == sizeof(unsigned long))
 430                 *reg += inc;
 431         else
 432                 *reg = (*reg & ~ad_mask(c)) | ((*reg + inc) & ad_mask(c));
 433 }
 434
 435 static inline void jmp_rel(struct decode_cache *c, int rel)
 436 {
 437         register_address_increment(c, &c->eip, rel);
 438 }
 439
 440 static void set_seg_override(struct decode_cache *c, int seg)
 441 {
 442         c->has_seg_override = true;
 443         c->seg_override = seg;
 444 }
 445
 446 static unsigned long seg_base(struct x86_emulate_ctxt *ctxt,
 447                               struct x86_emulate_ops *ops, int seg)
 448 {
 449         if (ctxt->mode == X86EMUL_MODE_PROT64 && seg < VCPU_SREG_FS)
 450                 return 0;
 451
 452         return ops->get_cached_segment_base(seg, ctxt->vcpu);
 453 }
 454
 455 static unsigned long seg_override_base(struct x86_emulate_ctxt *ctxt,
 456                                        struct x86_emulate_ops *ops,
 457                                        struct decode_cache *c)
 458 {
 459         if (!c->has_seg_override)
 460                 return 0;
 461
 462         return seg_base(ctxt, ops, c->seg_override);
 463 }
 464
 465 static unsigned long es_base(struct x86_emulate_ctxt *ctxt,
 466                              struct x86_emulate_ops *ops)
 467 {
 468         return seg_base(ctxt, ops, VCPU_SREG_ES);
 469 }
 470
 471 static unsigned long ss_base(struct x86_emulate_ctxt *ctxt,
 472                              struct x86_emulate_ops *ops)
 473 {
 474         return seg_base(ctxt, ops, VCPU_SREG_SS);
 475 }
 476
 477 static void emulate_exception(struct x86_emulate_ctxt *ctxt, int vec,
 478                                       u32 error, bool valid)
 479 {
 480         ctxt->exception = vec;
 481         ctxt->error_code = error;
 482         ctxt->error_code_valid = valid;
 483 }
 484
 485 static void emulate_gp(struct x86_emulate_ctxt *ctxt, int err)
 486 {
 487         emulate_exception(ctxt, GP_VECTOR, err, true);
 488 }
 489
 490 static void emulate_pf(struct x86_emulate_ctxt *ctxt, unsigned long addr,
 491                        int err)
 492 {
 493         ctxt->cr2 = addr;
 494         emulate_exception(ctxt, PF_VECTOR, err, true);
 495 }
 496
 497 static void emulate_ud(struct x86_emulate_ctxt *ctxt)
 498 {
 499         emulate_exception(ctxt, UD_VECTOR, 0, false);
 500 }
 501
 502 static void emulate_ts(struct x86_emulate_ctxt *ctxt, int err)
 503 {
 504         emulate_exception(ctxt, TS_VECTOR, err, true);
 505 }
 506
 507 static int emulate_de(struct x86_emulate_ctxt *ctxt)
 508 {
 509         emulate_exception(ctxt, DE_VECTOR, 0, false);
 510         return X86EMUL_PROPAGATE_FAULT;
 511 }
 512
 513 static int do_fetch_insn_byte(struct x86_emulate_ctxt *ctxt,
 514                               struct x86_emulate_ops *ops,
 515                               unsigned long eip, u8 *dest)
 516 {
 517         struct fetch_cache *fc = &ctxt->decode.fetch;
 518         int rc;
 519         int size, cur_size;
 520
 521         if (eip == fc->end) {
 522                 cur_size = fc->end - fc->start;
 523                 size = min(15UL - cur_size, PAGE_SIZE - offset_in_page(eip));
 524                 rc = ops->fetch(ctxt->cs_base + eip, fc->data + cur_size,
 525                                 size, ctxt->vcpu, NULL);
 526                 if (rc != X86EMUL_CONTINUE)
 527                         return rc;
 528                 fc->end += size;
 529         }
 530         *dest = fc->data[eip - fc->start];
 531         return X86EMUL_CONTINUE;
 532 }
 533
 534 static int do_insn_fetch(struct x86_emulate_ctxt *ctxt,
 535                          struct x86_emulate_ops *ops,
 536                          unsigned long eip, void *dest, unsigned size)
 537 {
 538         int rc;
 539
 540         /* x86 instructions are limited to 15 bytes. */
 541         if (eip + size - ctxt->eip > 15)
 542                 return X86EMUL_UNHANDLEABLE;
 543         while (size--) {
 544                 rc = do_fetch_insn_byte(ctxt, ops, eip++, dest++);
 545                 if (rc != X86EMUL_CONTINUE)
 546                         return rc;
 547         }
 548         return X86EMUL_CONTINUE;
 549 }
 550
 551 /*
 552  * Given the 'reg' portion of a ModRM byte, and a register block, return a
 553  * pointer into the block that addresses the relevant register.
 554  * @highbyte_regs specifies whether to decode AH,CH,DH,BH.
 555  */
 556 static void *decode_register(u8 modrm_reg, unsigned long *regs,
 557                              int highbyte_regs)
 558 {
 559         void *p;
 560
 561         p = &regs[modrm_reg];
 562         if (highbyte_regs && modrm_reg >= 4 && modrm_reg < 8)
 563                 p = (unsigned char *)&regs[modrm_reg & 3] + 1;
 564         return p;
 565 }
 566
 567 static int read_descriptor(struct x86_emulate_ctxt *ctxt,
 568                            struct x86_emulate_ops *ops,
 569                            ulong addr,
 570                            u16 *size, unsigned long *address, int op_bytes)
 571 {
 572         int rc;
 573
 574         if (op_bytes == 2)
 575                 op_bytes = 3;
 576         *address = 0;
 577         rc = ops->read_std(addr, (unsigned long *)size, 2, ctxt->vcpu, NULL);
 578         if (rc != X86EMUL_CONTINUE)
 579                 return rc;
 580         rc = ops->read_std(addr + 2, address, op_bytes, ctxt->vcpu, NULL);
 581         return rc;
 582 }
 583
 584 static int test_cc(unsigned int condition, unsigned int flags)
 585 {
 586         int rc = 0;
 587
 588         switch ((condition & 15) >> 1) {
 589         case 0: /* o */
 590                 rc |= (flags & EFLG_OF);
 591                 break;
 592         case 1: /* b/c/nae */
 593                 rc |= (flags & EFLG_CF);
 594                 break;
 595         case 2: /* z/e */
 596                 rc |= (flags & EFLG_ZF);
 597                 break;
 598         case 3: /* be/na */
 599                 rc |= (flags & (EFLG_CF|EFLG_ZF));
 600                 break;
 601         case 4: /* s */
 602                 rc |= (flags & EFLG_SF);
 603                 break;
 604         case 5: /* p/pe */
 605                 rc |= (flags & EFLG_PF);
 606                 break;
 607         case 7: /* le/ng */
 608                 rc |= (flags & EFLG_ZF);
 609                 /* fall through */
 610         case 6: /* l/nge */
 611                 rc |= (!(flags & EFLG_SF) != !(flags & EFLG_OF));
 612                 break;
 613         }
 614
 615         /* Odd condition identifiers (lsb == 1) have inverted sense. */
 616         return (!!rc ^ (condition & 1));
 617 }
 618
 619 static void fetch_register_operand(struct operand *op)
 620 {
 621         switch (op->bytes) {
 622         case 1:
 623                 op->val = *(u8 *)op->addr.reg;
 624                 break;
 625         case 2:
 626                 op->val = *(u16 *)op->addr.reg;
 627                 break;
 628         case 4:
 629                 op->val = *(u32 *)op->addr.reg;
 630                 break;
 631         case 8:
 632                 op->val = *(u64 *)op->addr.reg;
 633                 break;
 634         }
 635 }
 636
 637 static void decode_register_operand(struct operand *op,
 638                                     struct decode_cache *c,
 639                                     int inhibit_bytereg)
 640 {
 641         unsigned reg = c->modrm_reg;
 642         int highbyte_regs = c->rex_prefix == 0;
 643
 644         if (!(c->d & ModRM))
 645                 reg = (c->b & 7) | ((c->rex_prefix & 1) << 3);
 646         op->type = OP_REG;
 647         if ((c->d & ByteOp) && !inhibit_bytereg) {
 648                 op->addr.reg = decode_register(reg, c->regs, highbyte_regs);
 649                 op->bytes = 1;
 650         } else {
 651                 op->addr.reg = decode_register(reg, c->regs, 0);
 652                 op->bytes = c->op_bytes;
 653         }
 654         fetch_register_operand(op);
 655         op->orig_val = op->val;
 656 }
 657
 658 static int decode_modrm(struct x86_emulate_ctxt *ctxt,
 659                         struct x86_emulate_ops *ops,
 660                         struct operand *op)
 661 {
 662         struct decode_cache *c = &ctxt->decode;
 663         u8 sib;
 664         int index_reg = 0, base_reg = 0, scale;
 665         int rc = X86EMUL_CONTINUE;
 666         ulong modrm_ea = 0;
 667
 668         if (c->rex_prefix) {
 669                 c->modrm_reg = (c->rex_prefix & 4) << 1;        /* REX.R */
 670                 index_reg = (c->rex_prefix & 2) << 2; /* REX.X */
 671                 c->modrm_rm = base_reg = (c->rex_prefix & 1) << 3; /* REG.B */
 672         }
 673
 674         c->modrm = insn_fetch(u8, 1, c->eip);
 675         c->modrm_mod |= (c->modrm & 0xc0) >> 6;
 676         c->modrm_reg |= (c->modrm & 0x38) >> 3;
 677         c->modrm_rm |= (c->modrm & 0x07);
 678         c->modrm_seg = VCPU_SREG_DS;
 679
 680         if (c->modrm_mod == 3) {
 681                 op->type = OP_REG;
 682                 op->bytes = (c->d & ByteOp) ? 1 : c->op_bytes;
 683                 op->addr.reg = decode_register(c->modrm_rm,
 684                                                c->regs, c->d & ByteOp);
 685                 fetch_register_operand(op);
 686                 return rc;
 687         }
 688
 689         op->type = OP_MEM;
 690
 691         if (c->ad_bytes == 2) {
 692                 unsigned bx = c->regs[VCPU_REGS_RBX];
 693                 unsigned bp = c->regs[VCPU_REGS_RBP];
 694                 unsigned si = c->regs[VCPU_REGS_RSI];
 695                 unsigned di = c->regs[VCPU_REGS_RDI];
 696
 697                 /* 16-bit ModR/M decode. */
 698                 switch (c->modrm_mod) {
 699                 case 0:
 700                         if (c->modrm_rm == 6)
 701                                 modrm_ea += insn_fetch(u16, 2, c->eip);
 702                         break;
 703                 case 1:
 704                         modrm_ea += insn_fetch(s8, 1, c->eip);
 705                         break;
 706                 case 2:
 707                         modrm_ea += insn_fetch(u16, 2, c->eip);
 708                         break;
 709                 }
 710                 switch (c->modrm_rm) {
 711                 case 0:
 712                         modrm_ea += bx + si;
 713                         break;
 714                 case 1:
 715                         modrm_ea += bx + di;
 716                         break;
 717                 case 2:
 718                         modrm_ea += bp + si;
 719                         break;
 720                 case 3:
 721                         modrm_ea += bp + di;
 722                         break;
 723                 case 4:
 724                         modrm_ea += si;
 725                         break;
 726                 case 5:
 727                         modrm_ea += di;
 728                         break;
 729                 case 6:
 730                         if (c->modrm_mod != 0)
 731                                 modrm_ea += bp;
 732                         break;
 733                 case 7:
 734                         modrm_ea += bx;
 735                         break;
 736                 }
 737                 if (c->modrm_rm == 2 || c->modrm_rm == 3 ||
 738                     (c->modrm_rm == 6 && c->modrm_mod != 0))
 739                         c->modrm_seg = VCPU_SREG_SS;
 740                 modrm_ea = (u16)modrm_ea;
 741         } else {
 742                 /* 32/64-bit ModR/M decode. */
 743                 if ((c->modrm_rm & 7) == 4) {
 744                         sib = insn_fetch(u8, 1, c->eip);
 745                         index_reg |= (sib >> 3) & 7;
 746                         base_reg |= sib & 7;
 747                         scale = sib >> 6;
 748
 749                         if ((base_reg & 7) == 5 && c->modrm_mod == 0)
 750                                 modrm_ea += insn_fetch(s32, 4, c->eip);
 751                         else
 752                                 modrm_ea += c->regs[base_reg];
 753                         if (index_reg != 4)
 754                                 modrm_ea += c->regs[index_reg] << scale;
 755                 } else if ((c->modrm_rm & 7) == 5 && c->modrm_mod == 0) {
 756                         if (ctxt->mode == X86EMUL_MODE_PROT64)
 757                                 c->rip_relative = 1;
 758                 } else
 759                         modrm_ea += c->regs[c->modrm_rm];
 760                 switch (c->modrm_mod) {
 761                 case 0:
 762                         if (c->modrm_rm == 5)
 763                                 modrm_ea += insn_fetch(s32, 4, c->eip);
 764                         break;
 765                 case 1:
 766                         modrm_ea += insn_fetch(s8, 1, c->eip);
 767                         break;
 768                 case 2:
 769                         modrm_ea += insn_fetch(s32, 4, c->eip);
 770                         break;
 771                 }
 772         }
 773         op->addr.mem = modrm_ea;
 774 done:
 775         return rc;
 776 }
 777
 778 static int decode_abs(struct x86_emulate_ctxt *ctxt,
 779                       struct x86_emulate_ops *ops,
 780                       struct operand *op)
 781 {
 782         struct decode_cache *c = &ctxt->decode;
 783         int rc = X86EMUL_CONTINUE;
 784
 785         op->type = OP_MEM;
 786         switch (c->ad_bytes) {
 787         case 2:
 788                 op->addr.mem = insn_fetch(u16, 2, c->eip);
 789                 break;
 790         case 4:
 791                 op->addr.mem = insn_fetch(u32, 4, c->eip);
 792                 break;
 793         case 8:
 794                 op->addr.mem = insn_fetch(u64, 8, c->eip);
 795                 break;
 796         }
 797 done:
 798         return rc;
 799 }
 800
 801 static void fetch_bit_operand(struct decode_cache *c)
 802 {
 803         long sv, mask;
 804
 805         if (c->dst.type == OP_MEM && c->src.type == OP_REG) {
 806                 mask = ~(c->dst.bytes * 8 - 1);
 807
 808                 if (c->src.bytes == 2)
 809                         sv = (s16)c->src.val & (s16)mask;
 810                 else if (c->src.bytes == 4)
 811                         sv = (s32)c->src.val & (s32)mask;
 812
 813                 c->dst.addr.mem += (sv >> 3);
 814         }
 815
 816         /* only subword offset */
 817         c->src.val &= (c->dst.bytes << 3) - 1;
 818 }
 819
 820 static int read_emulated(struct x86_emulate_ctxt *ctxt,
 821                          struct x86_emulate_ops *ops,
 822                          unsigned long addr, void *dest, unsigned size)
 823 {
 824         int rc;
 825         struct read_cache *mc = &ctxt->decode.mem_read;
 826         u32 err;
 827
 828         while (size) {
 829                 int n = min(size, 8u);
 830                 size -= n;
 831                 if (mc->pos < mc->end)
 832                         goto read_cached;
 833
 834                 rc = ops->read_emulated(addr, mc->data + mc->end, n, &err,
 835                                         ctxt->vcpu);
 836                 if (rc == X86EMUL_PROPAGATE_FAULT)
 837                         emulate_pf(ctxt, addr, err);
 838                 if (rc != X86EMUL_CONTINUE)
 839                         return rc;
 840                 mc->end += n;
 841
 842         read_cached:
 843                 memcpy(dest, mc->data + mc->pos, n);
 844                 mc->pos += n;
 845                 dest += n;
 846                 addr += n;
 847         }
 848         return X86EMUL_CONTINUE;
 849 }
 850
 851 static int pio_in_emulated(struct x86_emulate_ctxt *ctxt,
 852                            struct x86_emulate_ops *ops,
 853                            unsigned int size, unsigned short port,
 854                            void *dest)
 855 {
 856         struct read_cache *rc = &ctxt->decode.io_read;
 857
 858         if (rc->pos == rc->end) { /* refill pio read ahead */
 859                 struct decode_cache *c = &ctxt->decode;
 860                 unsigned int in_page, n;
 861                 unsigned int count = c->rep_prefix ?
 862                         address_mask(c, c->regs[VCPU_REGS_RCX]) : 1;
 863                 in_page = (ctxt->eflags & EFLG_DF) ?
 864                         offset_in_page(c->regs[VCPU_REGS_RDI]) :
 865                         PAGE_SIZE - offset_in_page(c->regs[VCPU_REGS_RDI]);
 866                 n = min(min(in_page, (unsigned int)sizeof(rc->data)) / size,
 867                         count);
 868                 if (n == 0)
 869                         n = 1;
 870                 rc->pos = rc->end = 0;
 871                 if (!ops->pio_in_emulated(size, port, rc->data, n, ctxt->vcpu))
 872                         return 0;
 873                 rc->end = n * size;
 874         }
 875
 876         memcpy(dest, rc->data + rc->pos, size);
 877         rc->pos += size;
 878         return 1;
 879 }
 880
 881 static u32 desc_limit_scaled(struct desc_struct *desc)
 882 {
 883         u32 limit = get_desc_limit(desc);
 884
 885         return desc->g ? (limit << 12) | 0xfff : limit;
 886 }
 887
 888 static void get_descriptor_table_ptr(struct x86_emulate_ctxt *ctxt,
 889                                      struct x86_emulate_ops *ops,
 890                                      u16 selector, struct desc_ptr *dt)
 891 {
 892         if (selector & 1 << 2) {
 893                 struct desc_struct desc;
 894                 memset (dt, 0, sizeof *dt);
 895                 if (!ops->get_cached_descriptor(&desc, VCPU_SREG_LDTR, ctxt->vcpu))
 896                         return;
 897
 898                 dt->size = desc_limit_scaled(&desc); /* what if limit > 65535? */
 899                 dt->address = get_desc_base(&desc);
 900         } else
 901                 ops->get_gdt(dt, ctxt->vcpu);
 902 }
 903
 904 /* allowed just for 8 bytes segments */
 905 static int read_segment_descriptor(struct x86_emulate_ctxt *ctxt,
 906                                    struct x86_emulate_ops *ops,
 907                                    u16 selector, struct desc_struct *desc)
 908 {
 909         struct desc_ptr dt;
 910         u16 index = selector >> 3;
 911         int ret;
 912         u32 err;
 913         ulong addr;
 914
 915         get_descriptor_table_ptr(ctxt, ops, selector, &dt);
 916
 917         if (dt.size < index * 8 + 7) {
 918                 emulate_gp(ctxt, selector & 0xfffc);
 919                 return X86EMUL_PROPAGATE_FAULT;
 920         }
 921         addr = dt.address + index * 8;
 922         ret = ops->read_std(addr, desc, sizeof *desc, ctxt->vcpu,  &err);
 923         if (ret == X86EMUL_PROPAGATE_FAULT)
 924                 emulate_pf(ctxt, addr, err);
 925
 926        return ret;
 927 }
 928
 929 /* allowed just for 8 bytes segments */
 930 static int write_segment_descriptor(struct x86_emulate_ctxt *ctxt,
 931                                     struct x86_emulate_ops *ops,
 932                                     u16 selector, struct desc_struct *desc)
 933 {
 934         struct desc_ptr dt;
 935         u16 index = selector >> 3;
 936         u32 err;
 937         ulong addr;
 938         int ret;
 939
 940         get_descriptor_table_ptr(ctxt, ops, selector, &dt);
 941
 942         if (dt.size < index * 8 + 7) {
 943                 emulate_gp(ctxt, selector & 0xfffc);
 944                 return X86EMUL_PROPAGATE_FAULT;
 945         }
 946
 947         addr = dt.address + index * 8;
 948         ret = ops->write_std(addr, desc, sizeof *desc, ctxt->vcpu, &err);
 949         if (ret == X86EMUL_PROPAGATE_FAULT)
 950                 emulate_pf(ctxt, addr, err);
 951
 952         return ret;
 953 }
 954
 955 static int load_segment_descriptor(struct x86_emulate_ctxt *ctxt,
 956                                    struct x86_emulate_ops *ops,
 957                                    u16 selector, int seg)
 958 {
 959         struct desc_struct seg_desc;
 960         u8 dpl, rpl, cpl;
 961         unsigned err_vec = GP_VECTOR;
 962         u32 err_code = 0;
 963         bool null_selector = !(selector & ~0x3); /* 0000-0003 are null */
 964         int ret;
 965
 966         memset(&seg_desc, 0, sizeof seg_desc);
 967
 968         if ((seg <= VCPU_SREG_GS && ctxt->mode == X86EMUL_MODE_VM86)
 969             || ctxt->mode == X86EMUL_MODE_REAL) {
 970                 /* set real mode segment descriptor */
 971                 set_desc_base(&seg_desc, selector << 4);
 972                 set_desc_limit(&seg_desc, 0xffff);
 973                 seg_desc.type = 3;
 974                 seg_desc.p = 1;
 975                 seg_desc.s = 1;
 976                 goto load;
 977         }
 978
 979         /* NULL selector is not valid for TR, CS and SS */
 980         if ((seg == VCPU_SREG_CS || seg == VCPU_SREG_SS || seg == VCPU_SREG_TR)
 981             && null_selector)
 982                 goto exception;
 983
 984         /* TR should be in GDT only */
 985         if (seg == VCPU_SREG_TR && (selector & (1 << 2)))
 986                 goto exception;
 987
 988         if (null_selector) /* for NULL selector skip all following checks */
 989                 goto load;
 990
 991         ret = read_segment_descriptor(ctxt, ops, selector, &seg_desc);
 992         if (ret != X86EMUL_CONTINUE)
 993                 return ret;
 994
 995         err_code = selector & 0xfffc;
 996         err_vec = GP_VECTOR;
 997
 998         /* can't load system descriptor into segment selecor */
 999         if (seg <= VCPU_SREG_GS && !seg_desc.s)
1000                 goto exception;
1001
1002         if (!seg_desc.p) {
1003                 err_vec = (seg == VCPU_SREG_SS) ? SS_VECTOR : NP_VECTOR;
1004                 goto exception;
1005         }
1006
1007         rpl = selector & 3;
1008         dpl = seg_desc.dpl;
1009         cpl = ops->cpl(ctxt->vcpu);
1010
1011         switch (seg) {
1012         case VCPU_SREG_SS:
1013                 /*
1014                  * segment is not a writable data segment or segment
1015                  * selector's RPL != CPL or segment selector's RPL != CPL
1016                  */
1017                 if (rpl != cpl || (seg_desc.type & 0xa) != 0x2 || dpl != cpl)
1018                         goto exception;
1019                 break;
1020         case VCPU_SREG_CS:
1021                 if (!(seg_desc.type & 8))
1022                         goto exception;
1023
1024                 if (seg_desc.type & 4) {
1025                         /* conforming */
1026                         if (dpl > cpl)
1027                                 goto exception;
1028                 } else {
1029                         /* nonconforming */
1030                         if (rpl > cpl || dpl != cpl)
1031                                 goto exception;
1032                 }
1033                 /* CS(RPL) <- CPL */
1034                 selector = (selector & 0xfffc) | cpl;
1035                 break;
1036         case VCPU_SREG_TR:
1037                 if (seg_desc.s || (seg_desc.type != 1 && seg_desc.type != 9))
1038                         goto exception;
1039                 break;
1040         case VCPU_SREG_LDTR:
1041                 if (seg_desc.s || seg_desc.type != 2)
1042                         goto exception;
1043                 break;
1044         default: /*  DS, ES, FS, or GS */
1045                 /*
1046                  * segment is not a data or readable code segment or
1047                  * ((segment is a data or nonconforming code segment)
1048                  * and (both RPL and CPL > DPL))
1049                  */
1050                 if ((seg_desc.type & 0xa) == 0x8 ||
1051                     (((seg_desc.type & 0xc) != 0xc) &&
1052                      (rpl > dpl && cpl > dpl)))
1053                         goto exception;
1054                 break;
1055         }
1056
1057         if (seg_desc.s) {
1058                 /* mark segment as accessed */
1059                 seg_desc.type |= 1;
1060                 ret = write_segment_descriptor(ctxt, ops, selector, &seg_desc);
1061                 if (ret != X86EMUL_CONTINUE)
1062                         return ret;
1063         }
1064 load:
1065         ops->set_segment_selector(selector, seg, ctxt->vcpu);
1066         ops->set_cached_descriptor(&seg_desc, seg, ctxt->vcpu);
1067         return X86EMUL_CONTINUE;
1068 exception:
1069         emulate_exception(ctxt, err_vec, err_code, true);
1070         return X86EMUL_PROPAGATE_FAULT;
1071 }
1072
1073 static void write_register_operand(struct operand *op)
1074 {
1075         /* The 4-byte case *is* correct: in 64-bit mode we zero-extend. */
1076         switch (op->bytes) {
1077         case 1:
1078                 *(u8 *)op->addr.reg = (u8)op->val;
1079                 break;
1080         case 2:
1081                 *(u16 *)op->addr.reg = (u16)op->val;
1082                 break;
1083         case 4:
1084                 *op->addr.reg = (u32)op->val;
1085                 break;  /* 64b: zero-extend */
1086         case 8:
1087                 *op->addr.reg = op->val;
1088                 break;
1089         }
1090 }
1091
1092 static inline int writeback(struct x86_emulate_ctxt *ctxt,
1093                             struct x86_emulate_ops *ops)
1094 {
1095         int rc;
1096         struct decode_cache *c = &ctxt->decode;
1097         u32 err;
1098
1099         switch (c->dst.type) {
1100         case OP_REG:
1101                 write_register_operand(&c->dst);
1102                 break;
1103         case OP_MEM:
1104                 if (c->lock_prefix)
1105                         rc = ops->cmpxchg_emulated(
1106                                         c->dst.addr.mem,
1107                                         &c->dst.orig_val,
1108                                         &c->dst.val,
1109                                         c->dst.bytes,
1110                                         &err,
1111                                         ctxt->vcpu);
1112                 else
1113                         rc = ops->write_emulated(
1114                                         c->dst.addr.mem,
1115                                         &c->dst.val,
1116                                         c->dst.bytes,
1117                                         &err,
1118                                         ctxt->vcpu);
1119                 if (rc == X86EMUL_PROPAGATE_FAULT)
1120                         emulate_pf(ctxt, c->dst.addr.mem, err);
1121                 if (rc != X86EMUL_CONTINUE)
1122                         return rc;
1123                 break;
1124         case OP_NONE:
1125                 /* no writeback */
1126                 break;
1127         default:
1128                 break;
1129         }
1130         return X86EMUL_CONTINUE;
1131 }
1132
1133 static inline void emulate_push(struct x86_emulate_ctxt *ctxt,
1134                                 struct x86_emulate_ops *ops)
1135 {
1136         struct decode_cache *c = &ctxt->decode;
1137
1138         c->dst.type  = OP_MEM;
1139         c->dst.bytes = c->op_bytes;
1140         c->dst.val = c->src.val;
1141         register_address_increment(c, &c->regs[VCPU_REGS_RSP], -c->op_bytes);
1142         c->dst.addr.mem = register_address(c, ss_base(ctxt, ops),
1143                                            c->regs[VCPU_REGS_RSP]);
1144 }
1145
1146 static int emulate_pop(struct x86_emulate_ctxt *ctxt,
1147                        struct x86_emulate_ops *ops,
1148                        void *dest, int len)
1149 {
1150         struct decode_cache *c = &ctxt->decode;
1151         int rc;
1152
1153         rc = read_emulated(ctxt, ops, register_address(c, ss_base(ctxt, ops),
1154                                                        c->regs[VCPU_REGS_RSP]),
1155                            dest, len);
1156         if (rc != X86EMUL_CONTINUE)
1157                 return rc;
1158
1159         register_address_increment(c, &c->regs[VCPU_REGS_RSP], len);
1160         return rc;
1161 }
1162
1163 static int emulate_popf(struct x86_emulate_ctxt *ctxt,
1164                        struct x86_emulate_ops *ops,
1165                        void *dest, int len)
1166 {
1167         int rc;
1168         unsigned long val, change_mask;
1169         int iopl = (ctxt->eflags & X86_EFLAGS_IOPL) >> IOPL_SHIFT;
1170         int cpl = ops->cpl(ctxt->vcpu);
1171
1172         rc = emulate_pop(ctxt, ops, &val, len);
1173         if (rc != X86EMUL_CONTINUE)
1174                 return rc;
1175
1176         change_mask = EFLG_CF | EFLG_PF | EFLG_AF | EFLG_ZF | EFLG_SF | EFLG_OF
1177                 | EFLG_TF | EFLG_DF | EFLG_NT | EFLG_RF | EFLG_AC | EFLG_ID;
1178
1179         switch(ctxt->mode) {
1180         case X86EMUL_MODE_PROT64:
1181         case X86EMUL_MODE_PROT32:
1182         case X86EMUL_MODE_PROT16:
1183                 if (cpl == 0)
1184                         change_mask |= EFLG_IOPL;
1185                 if (cpl <= iopl)
1186                         change_mask |= EFLG_IF;
1187                 break;
1188         case X86EMUL_MODE_VM86:
1189                 if (iopl < 3) {
1190                         emulate_gp(ctxt, 0);
1191                         return X86EMUL_PROPAGATE_FAULT;
1192                 }
1193                 change_mask |= EFLG_IF;
1194                 break;
1195         default: /* real mode */
1196                 change_mask |= (EFLG_IOPL | EFLG_IF);
1197                 break;
1198         }
1199
1200         *(unsigned long *)dest =
1201                 (ctxt->eflags & ~change_mask) | (val & change_mask);
1202
1203         return rc;
1204 }
1205
1206 static void emulate_push_sreg(struct x86_emulate_ctxt *ctxt,
1207                               struct x86_emulate_ops *ops, int seg)
1208 {
1209         struct decode_cache *c = &ctxt->decode;
1210
1211         c->src.val = ops->get_segment_selector(seg, ctxt->vcpu);
1212
1213         emulate_push(ctxt, ops);
1214 }
1215
1216 static int emulate_pop_sreg(struct x86_emulate_ctxt *ctxt,
1217                              struct x86_emulate_ops *ops, int seg)
1218 {
1219         struct decode_cache *c = &ctxt->decode;
1220         unsigned long selector;
1221         int rc;
1222
1223         rc = emulate_pop(ctxt, ops, &selector, c->op_bytes);
1224         if (rc != X86EMUL_CONTINUE)
1225                 return rc;
1226
1227         rc = load_segment_descriptor(ctxt, ops, (u16)selector, seg);
1228         return rc;
1229 }
1230
1231 static int emulate_pusha(struct x86_emulate_ctxt *ctxt,
1232                           struct x86_emulate_ops *ops)
1233 {
1234         struct decode_cache *c = &ctxt->decode;
1235         unsigned long old_esp = c->regs[VCPU_REGS_RSP];
1236         int rc = X86EMUL_CONTINUE;
1237         int reg = VCPU_REGS_RAX;
1238
1239         while (reg <= VCPU_REGS_RDI) {
1240                 (reg == VCPU_REGS_RSP) ?
1241                 (c->src.val = old_esp) : (c->src.val = c->regs[reg]);
1242
1243                 emulate_push(ctxt, ops);
1244
1245                 rc = writeback(ctxt, ops);
1246                 if (rc != X86EMUL_CONTINUE)
1247                         return rc;
1248
1249                 ++reg;
1250         }
1251
1252         /* Disable writeback. */
1253         c->dst.type = OP_NONE;
1254
1255         return rc;
1256 }
1257
1258 static int emulate_popa(struct x86_emulate_ctxt *ctxt,
1259                         struct x86_emulate_ops *ops)
1260 {
1261         struct decode_cache *c = &ctxt->decode;
1262         int rc = X86EMUL_CONTINUE;
1263         int reg = VCPU_REGS_RDI;
1264
1265         while (reg >= VCPU_REGS_RAX) {
1266                 if (reg == VCPU_REGS_RSP) {
1267                         register_address_increment(c, &c->regs[VCPU_REGS_RSP],
1268                                                         c->op_bytes);
1269                         --reg;
1270                 }
1271
1272                 rc = emulate_pop(ctxt, ops, &c->regs[reg], c->op_bytes);
1273                 if (rc != X86EMUL_CONTINUE)
1274                         break;
1275                 --reg;
1276         }
1277         return rc;
1278 }
1279
1280 int emulate_int_real(struct x86_emulate_ctxt *ctxt,
1281                                struct x86_emulate_ops *ops, int irq)
1282 {
1283         struct decode_cache *c = &ctxt->decode;
1284         int rc;
1285         struct desc_ptr dt;
1286         gva_t cs_addr;
1287         gva_t eip_addr;
1288         u16 cs, eip;
1289         u32 err;
1290
1291         /* TODO: Add limit checks */
1292         c->src.val = ctxt->eflags;
1293         emulate_push(ctxt, ops);
1294         rc = writeback(ctxt, ops);
1295         if (rc != X86EMUL_CONTINUE)
1296                 return rc;
1297
1298         ctxt->eflags &= ~(EFLG_IF | EFLG_TF | EFLG_AC);
1299
1300         c->src.val = ops->get_segment_selector(VCPU_SREG_CS, ctxt->vcpu);
1301         emulate_push(ctxt, ops);
1302         rc = writeback(ctxt, ops);
1303         if (rc != X86EMUL_CONTINUE)
1304                 return rc;
1305
1306         c->src.val = c->eip;
1307         emulate_push(ctxt, ops);
1308         rc = writeback(ctxt, ops);
1309         if (rc != X86EMUL_CONTINUE)
1310                 return rc;
1311
1312         c->dst.type = OP_NONE;
1313
1314         ops->get_idt(&dt, ctxt->vcpu);
1315
1316         eip_addr = dt.address + (irq << 2);
1317         cs_addr = dt.address + (irq << 2) + 2;
1318
1319         rc = ops->read_std(cs_addr, &cs, 2, ctxt->vcpu, &err);
1320         if (rc != X86EMUL_CONTINUE)
1321                 return rc;
1322
1323         rc = ops->read_std(eip_addr, &eip, 2, ctxt->vcpu, &err);
1324         if (rc != X86EMUL_CONTINUE)
1325                 return rc;
1326
1327         rc = load_segment_descriptor(ctxt, ops, cs, VCPU_SREG_CS);
1328         if (rc != X86EMUL_CONTINUE)
1329                 return rc;
1330
1331         c->eip = eip;
1332
1333         return rc;
1334 }
1335
1336 static int emulate_int(struct x86_emulate_ctxt *ctxt,
1337                        struct x86_emulate_ops *ops, int irq)
1338 {
1339         switch(ctxt->mode) {
1340         case X86EMUL_MODE_REAL:
1341                 return emulate_int_real(ctxt, ops, irq);
1342         case X86EMUL_MODE_VM86:
1343         case X86EMUL_MODE_PROT16:
1344         case X86EMUL_MODE_PROT32:
1345         case X86EMUL_MODE_PROT64:
1346         default:
1347                 /* Protected mode interrupts unimplemented yet */
1348                 return X86EMUL_UNHANDLEABLE;
1349         }
1350 }
1351
1352 static int emulate_iret_real(struct x86_emulate_ctxt *ctxt,
1353                              struct x86_emulate_ops *ops)
1354 {
1355         struct decode_cache *c = &ctxt->decode;
1356         int rc = X86EMUL_CONTINUE;
1357         unsigned long temp_eip = 0;
1358         unsigned long temp_eflags = 0;
1359         unsigned long cs = 0;
1360         unsigned long mask = EFLG_CF | EFLG_PF | EFLG_AF | EFLG_ZF | EFLG_SF | EFLG_TF |
1361                              EFLG_IF | EFLG_DF | EFLG_OF | EFLG_IOPL | EFLG_NT | EFLG_RF |
1362                              EFLG_AC | EFLG_ID | (1 << 1); /* Last one is the reserved bit */
1363         unsigned long vm86_mask = EFLG_VM | EFLG_VIF | EFLG_VIP;
1364
1365         /* TODO: Add stack limit check */
1366
1367         rc = emulate_pop(ctxt, ops, &temp_eip, c->op_bytes);
1368
1369         if (rc != X86EMUL_CONTINUE)
1370                 return rc;
1371
1372         if (temp_eip & ~0xffff) {
1373                 emulate_gp(ctxt, 0);
1374                 return X86EMUL_PROPAGATE_FAULT;
1375         }
1376
1377         rc = emulate_pop(ctxt, ops, &cs, c->op_bytes);
1378
1379         if (rc != X86EMUL_CONTINUE)
1380                 return rc;
1381
1382         rc = emulate_pop(ctxt, ops, &temp_eflags, c->op_bytes);
1383
1384         if (rc != X86EMUL_CONTINUE)
1385                 return rc;
1386
1387         rc = load_segment_descriptor(ctxt, ops, (u16)cs, VCPU_SREG_CS);
1388
1389         if (rc != X86EMUL_CONTINUE)
1390                 return rc;
1391
1392         c->eip = temp_eip;
1393
1394
1395         if (c->op_bytes == 4)
1396                 ctxt->eflags = ((temp_eflags & mask) | (ctxt->eflags & vm86_mask));
1397         else if (c->op_bytes == 2) {
1398                 ctxt->eflags &= ~0xffff;
1399                 ctxt->eflags |= temp_eflags;
1400         }
1401
1402         ctxt->eflags &= ~EFLG_RESERVED_ZEROS_MASK; /* Clear reserved zeros */
1403         ctxt->eflags |= EFLG_RESERVED_ONE_MASK;
1404
1405         return rc;
1406 }
1407
1408 static inline int emulate_iret(struct x86_emulate_ctxt *ctxt,
1409                                     struct x86_emulate_ops* ops)
1410 {
1411         switch(ctxt->mode) {
1412         case X86EMUL_MODE_REAL:
1413                 return emulate_iret_real(ctxt, ops);
1414         case X86EMUL_MODE_VM86:
1415         case X86EMUL_MODE_PROT16:
1416         case X86EMUL_MODE_PROT32:
1417         case X86EMUL_MODE_PROT64:
1418         default:
1419                 /* iret from protected mode unimplemented yet */
1420                 return X86EMUL_UNHANDLEABLE;
1421         }
1422 }
1423
1424 static inline int emulate_grp1a(struct x86_emulate_ctxt *ctxt,
1425                                 struct x86_emulate_ops *ops)
1426 {
1427         struct decode_cache *c = &ctxt->decode;
1428
1429         return emulate_pop(ctxt, ops, &c->dst.val, c->dst.bytes);
1430 }
1431
1432 static inline void emulate_grp2(struct x86_emulate_ctxt *ctxt)
1433 {
1434         struct decode_cache *c = &ctxt->decode;
1435         switch (c->modrm_reg) {
1436         case 0: /* rol */
1437                 emulate_2op_SrcB("rol", c->src, c->dst, ctxt->eflags);
1438                 break;
1439         case 1: /* ror */
1440                 emulate_2op_SrcB("ror", c->src, c->dst, ctxt->eflags);
1441                 break;
1442         case 2: /* rcl */
1443                 emulate_2op_SrcB("rcl", c->src, c->dst, ctxt->eflags);
1444                 break;
1445         case 3: /* rcr */
1446                 emulate_2op_SrcB("rcr", c->src, c->dst, ctxt->eflags);
1447                 break;
1448         case 4: /* sal/shl */
1449         case 6: /* sal/shl */
1450                 emulate_2op_SrcB("sal", c->src, c->dst, ctxt->eflags);
1451                 break;
1452         case 5: /* shr */
1453                 emulate_2op_SrcB("shr", c->src, c->dst, ctxt->eflags);
1454                 break;
1455         case 7: /* sar */
1456                 emulate_2op_SrcB("sar", c->src, c->dst, ctxt->eflags);
1457                 break;
1458         }
1459 }
1460
1461 static inline int emulate_grp3(struct x86_emulate_ctxt *ctxt,
1462                                struct x86_emulate_ops *ops)
1463 {
1464         struct decode_cache *c = &ctxt->decode;
1465         unsigned long *rax = &c->regs[VCPU_REGS_RAX];
1466         unsigned long *rdx = &c->regs[VCPU_REGS_RDX];
1467         u8 de = 0;
1468
1469         switch (c->modrm_reg) {
1470         case 0 ... 1:   /* test */
1471                 emulate_2op_SrcV("test", c->src, c->dst, ctxt->eflags);
1472                 break;
1473         case 2: /* not */
1474                 c->dst.val = ~c->dst.val;
1475                 break;
1476         case 3: /* neg */
1477                 emulate_1op("neg", c->dst, ctxt->eflags);
1478                 break;
1479         case 4: /* mul */
1480                 emulate_1op_rax_rdx("mul", c->src, *rax, *rdx, ctxt->eflags);
1481                 break;
1482         case 5: /* imul */
1483                 emulate_1op_rax_rdx("imul", c->src, *rax, *rdx, ctxt->eflags);
1484                 break;
1485         case 6: /* div */
1486                 emulate_1op_rax_rdx_ex("div", c->src, *rax, *rdx,
1487                                        ctxt->eflags, de);
1488                 break;
1489         case 7: /* idiv */
1490                 emulate_1op_rax_rdx_ex("idiv", c->src, *rax, *rdx,
1491                                        ctxt->eflags, de);
1492                 break;
1493         default:
1494                 return X86EMUL_UNHANDLEABLE;
1495         }
1496         if (de)
1497                 return emulate_de(ctxt);
1498         return X86EMUL_CONTINUE;
1499 }
1500
1501 static inline int emulate_grp45(struct x86_emulate_ctxt *ctxt,
1502                                struct x86_emulate_ops *ops)
1503 {
1504         struct decode_cache *c = &ctxt->decode;
1505
1506         switch (c->modrm_reg) {
1507         case 0: /* inc */
1508                 emulate_1op("inc", c->dst, ctxt->eflags);
1509                 break;
1510         case 1: /* dec */
1511                 emulate_1op("dec", c->dst, ctxt->eflags);
1512                 break;
1513         case 2: /* call near abs */ {
1514                 long int old_eip;
1515                 old_eip = c->eip;
1516                 c->eip = c->src.val;
1517                 c->src.val = old_eip;
1518                 emulate_push(ctxt, ops);
1519                 break;
1520         }
1521         case 4: /* jmp abs */
1522                 c->eip = c->src.val;
1523                 break;
1524         case 6: /* push */
1525                 emulate_push(ctxt, ops);
1526                 break;
1527         }
1528         return X86EMUL_CONTINUE;
1529 }
1530
1531 static inline int emulate_grp9(struct x86_emulate_ctxt *ctxt,
1532                                struct x86_emulate_ops *ops)
1533 {
1534         struct decode_cache *c = &ctxt->decode;
1535         u64 old = c->dst.orig_val64;
1536
1537         if (((u32) (old >> 0) != (u32) c->regs[VCPU_REGS_RAX]) ||
1538             ((u32) (old >> 32) != (u32) c->regs[VCPU_REGS_RDX])) {
1539                 c->regs[VCPU_REGS_RAX] = (u32) (old >> 0);
1540                 c->regs[VCPU_REGS_RDX] = (u32) (old >> 32);
1541                 ctxt->eflags &= ~EFLG_ZF;
1542         } else {
1543                 c->dst.val64 = ((u64)c->regs[VCPU_REGS_RCX] << 32) |
1544                         (u32) c->regs[VCPU_REGS_RBX];
1545
1546                 ctxt->eflags |= EFLG_ZF;
1547         }
1548         return X86EMUL_CONTINUE;
1549 }
1550
1551 static int emulate_ret_far(struct x86_emulate_ctxt *ctxt,
1552                            struct x86_emulate_ops *ops)
1553 {
1554         struct decode_cache *c = &ctxt->decode;
1555         int rc;
1556         unsigned long cs;
1557
1558         rc = emulate_pop(ctxt, ops, &c->eip, c->op_bytes);
1559         if (rc != X86EMUL_CONTINUE)
1560                 return rc;
1561         if (c->op_bytes == 4)
1562                 c->eip = (u32)c->eip;
1563         rc = emulate_pop(ctxt, ops, &cs, c->op_bytes);
1564         if (rc != X86EMUL_CONTINUE)
1565                 return rc;
1566         rc = load_segment_descriptor(ctxt, ops, (u16)cs, VCPU_SREG_CS);
1567         return rc;
1568 }
1569
1570 static int emulate_load_segment(struct x86_emulate_ctxt *ctxt,
1571                            struct x86_emulate_ops *ops, int seg)
1572 {
1573         struct decode_cache *c = &ctxt->decode;
1574         unsigned short sel;
1575         int rc;
1576
1577         memcpy(&sel, c->src.valptr + c->op_bytes, 2);
1578
1579         rc = load_segment_descriptor(ctxt, ops, sel, seg);
1580         if (rc != X86EMUL_CONTINUE)
1581                 return rc;
1582
1583         c->dst.val = c->src.val;
1584         return rc;
1585 }
1586
1587 static inline void
1588 setup_syscalls_segments(struct x86_emulate_ctxt *ctxt,
1589                         struct x86_emulate_ops *ops, struct desc_struct *cs,
1590                         struct desc_struct *ss)
1591 {
1592         memset(cs, 0, sizeof(struct desc_struct));
1593         ops->get_cached_descriptor(cs, VCPU_SREG_CS, ctxt->vcpu);
1594         memset(ss, 0, sizeof(struct desc_struct));
1595
1596         cs->l = 0;              /* will be adjusted later */
1597         set_desc_base(cs, 0);   /* flat segment */
1598         cs->g = 1;              /* 4kb granularity */
1599         set_desc_limit(cs, 0xfffff);    /* 4GB limit */
1600         cs->type = 0x0b;        /* Read, Execute, Accessed */
1601         cs->s = 1;
1602         cs->dpl = 0;            /* will be adjusted later */
1603         cs->p = 1;
1604         cs->d = 1;
1605
1606         set_desc_base(ss, 0);   /* flat segment */
1607         set_desc_limit(ss, 0xfffff);    /* 4GB limit */
1608         ss->g = 1;              /* 4kb granularity */
1609         ss->s = 1;
1610         ss->type = 0x03;        /* Read/Write, Accessed */
1611         ss->d = 1;              /* 32bit stack segment */
1612         ss->dpl = 0;
1613         ss->p = 1;
1614 }
1615
1616 static int
1617 emulate_syscall(struct x86_emulate_ctxt *ctxt, struct x86_emulate_ops *ops)
1618 {
1619         struct decode_cache *c = &ctxt->decode;
1620         struct desc_struct cs, ss;
1621         u64 msr_data;
1622         u16 cs_sel, ss_sel;
1623
1624         /* syscall is not available in real mode */
1625         if (ctxt->mode == X86EMUL_MODE_REAL ||
1626             ctxt->mode == X86EMUL_MODE_VM86) {
1627                 emulate_ud(ctxt);
1628                 return X86EMUL_PROPAGATE_FAULT;
1629         }
1630
1631         setup_syscalls_segments(ctxt, ops, &cs, &ss);
1632
1633         ops->get_msr(ctxt->vcpu, MSR_STAR, &msr_data);
1634         msr_data >>= 32;
1635         cs_sel = (u16)(msr_data & 0xfffc);
1636         ss_sel = (u16)(msr_data + 8);
1637
1638         if (is_long_mode(ctxt->vcpu)) {
1639                 cs.d = 0;
1640                 cs.l = 1;
1641         }
1642         ops->set_cached_descriptor(&cs, VCPU_SREG_CS, ctxt->vcpu);
1643         ops->set_segment_selector(cs_sel, VCPU_SREG_CS, ctxt->vcpu);
1644         ops->set_cached_descriptor(&ss, VCPU_SREG_SS, ctxt->vcpu);
1645         ops->set_segment_selector(ss_sel, VCPU_SREG_SS, ctxt->vcpu);
1646
1647         c->regs[VCPU_REGS_RCX] = c->eip;
1648         if (is_long_mode(ctxt->vcpu)) {
1649 #ifdef CONFIG_X86_64
1650                 c->regs[VCPU_REGS_R11] = ctxt->eflags & ~EFLG_RF;
1651
1652                 ops->get_msr(ctxt->vcpu,
1653                              ctxt->mode == X86EMUL_MODE_PROT64 ?
1654                              MSR_LSTAR : MSR_CSTAR, &msr_data);
1655                 c->eip = msr_data;
1656
1657                 ops->get_msr(ctxt->vcpu, MSR_SYSCALL_MASK, &msr_data);
1658                 ctxt->eflags &= ~(msr_data | EFLG_RF);
1659 #endif
1660         } else {
1661                 /* legacy mode */
1662                 ops->get_msr(ctxt->vcpu, MSR_STAR, &msr_data);
1663                 c->eip = (u32)msr_data;
1664
1665                 ctxt->eflags &= ~(EFLG_VM | EFLG_IF | EFLG_RF);
1666         }
1667
1668         return X86EMUL_CONTINUE;
1669 }
1670
1671 static int
1672 emulate_sysenter(struct x86_emulate_ctxt *ctxt, struct x86_emulate_ops *ops)
1673 {
1674         struct decode_cache *c = &ctxt->decode;
1675         struct desc_struct cs, ss;
1676         u64 msr_data;
1677         u16 cs_sel, ss_sel;
1678
1679         /* inject #GP if in real mode */
1680         if (ctxt->mode == X86EMUL_MODE_REAL) {
1681                 emulate_gp(ctxt, 0);
1682                 return X86EMUL_PROPAGATE_FAULT;
1683         }
1684
1685         /* XXX sysenter/sysexit have not been tested in 64bit mode.
1686         * Therefore, we inject an #UD.
1687         */
1688         if (ctxt->mode == X86EMUL_MODE_PROT64) {
1689                 emulate_ud(ctxt);
1690                 return X86EMUL_PROPAGATE_FAULT;
1691         }
1692
1693         setup_syscalls_segments(ctxt, ops, &cs, &ss);
1694
1695         ops->get_msr(ctxt->vcpu, MSR_IA32_SYSENTER_CS, &msr_data);
1696         switch (ctxt->mode) {
1697         case X86EMUL_MODE_PROT32:
1698                 if ((msr_data & 0xfffc) == 0x0) {
1699                         emulate_gp(ctxt, 0);
1700                         return X86EMUL_PROPAGATE_FAULT;
1701                 }
1702                 break;
1703         case X86EMUL_MODE_PROT64:
1704                 if (msr_data == 0x0) {
1705                         emulate_gp(ctxt, 0);
1706                         return X86EMUL_PROPAGATE_FAULT;
1707                 }
1708                 break;
1709         }
1710
1711         ctxt->eflags &= ~(EFLG_VM | EFLG_IF | EFLG_RF);
1712         cs_sel = (u16)msr_data;
1713         cs_sel &= ~SELECTOR_RPL_MASK;
1714         ss_sel = cs_sel + 8;
1715         ss_sel &= ~SELECTOR_RPL_MASK;
1716         if (ctxt->mode == X86EMUL_MODE_PROT64
1717                 || is_long_mode(ctxt->vcpu)) {
1718                 cs.d = 0;
1719                 cs.l = 1;
1720         }
1721
1722         ops->set_cached_descriptor(&cs, VCPU_SREG_CS, ctxt->vcpu);
1723         ops->set_segment_selector(cs_sel, VCPU_SREG_CS, ctxt->vcpu);
1724         ops->set_cached_descriptor(&ss, VCPU_SREG_SS, ctxt->vcpu);
1725         ops->set_segment_selector(ss_sel, VCPU_SREG_SS, ctxt->vcpu);
1726
1727         ops->get_msr(ctxt->vcpu, MSR_IA32_SYSENTER_EIP, &msr_data);
1728         c->eip = msr_data;
1729
1730         ops->get_msr(ctxt->vcpu, MSR_IA32_SYSENTER_ESP, &msr_data);
1731         c->regs[VCPU_REGS_RSP] = msr_data;
1732
1733         return X86EMUL_CONTINUE;
1734 }
1735
1736 static int
1737 emulate_sysexit(struct x86_emulate_ctxt *ctxt, struct x86_emulate_ops *ops)
1738 {
1739         struct decode_cache *c = &ctxt->decode;
1740         struct desc_struct cs, ss;
1741         u64 msr_data;
1742         int usermode;
1743         u16 cs_sel, ss_sel;
1744
1745         /* inject #GP if in real mode or Virtual 8086 mode */
1746         if (ctxt->mode == X86EMUL_MODE_REAL ||
1747             ctxt->mode == X86EMUL_MODE_VM86) {
1748                 emulate_gp(ctxt, 0);
1749                 return X86EMUL_PROPAGATE_FAULT;
1750         }
1751
1752         setup_syscalls_segments(ctxt, ops, &cs, &ss);
1753
1754         if ((c->rex_prefix & 0x8) != 0x0)
1755                 usermode = X86EMUL_MODE_PROT64;
1756         else
1757                 usermode = X86EMUL_MODE_PROT32;
1758
1759         cs.dpl = 3;
1760         ss.dpl = 3;
1761         ops->get_msr(ctxt->vcpu, MSR_IA32_SYSENTER_CS, &msr_data);
1762         switch (usermode) {
1763         case X86EMUL_MODE_PROT32:
1764                 cs_sel = (u16)(msr_data + 16);
1765                 if ((msr_data & 0xfffc) == 0x0) {
1766                         emulate_gp(ctxt, 0);
1767                         return X86EMUL_PROPAGATE_FAULT;
1768                 }
1769                 ss_sel = (u16)(msr_data + 24);
1770                 break;
1771         case X86EMUL_MODE_PROT64:
1772                 cs_sel = (u16)(msr_data + 32);
1773                 if (msr_data == 0x0) {
1774                         emulate_gp(ctxt, 0);
1775                         return X86EMUL_PROPAGATE_FAULT;
1776                 }
1777                 ss_sel = cs_sel + 8;
1778                 cs.d = 0;
1779                 cs.l = 1;
1780                 break;
1781         }
1782         cs_sel |= SELECTOR_RPL_MASK;
1783         ss_sel |= SELECTOR_RPL_MASK;
1784
1785         ops->set_cached_descriptor(&cs, VCPU_SREG_CS, ctxt->vcpu);
1786         ops->set_segment_selector(cs_sel, VCPU_SREG_CS, ctxt->vcpu);
1787         ops->set_cached_descriptor(&ss, VCPU_SREG_SS, ctxt->vcpu);
1788         ops->set_segment_selector(ss_sel, VCPU_SREG_SS, ctxt->vcpu);
1789
1790         c->eip = c->regs[VCPU_REGS_RDX];
1791         c->regs[VCPU_REGS_RSP] = c->regs[VCPU_REGS_RCX];
1792
1793         return X86EMUL_CONTINUE;
1794 }
1795
1796 static bool emulator_bad_iopl(struct x86_emulate_ctxt *ctxt,
1797                               struct x86_emulate_ops *ops)
1798 {
1799         int iopl;
1800         if (ctxt->mode == X86EMUL_MODE_REAL)
1801                 return false;
1802         if (ctxt->mode == X86EMUL_MODE_VM86)
1803                 return true;
1804         iopl = (ctxt->eflags & X86_EFLAGS_IOPL) >> IOPL_SHIFT;
1805         return ops->cpl(ctxt->vcpu) > iopl;
1806 }
1807
1808 static bool emulator_io_port_access_allowed(struct x86_emulate_ctxt *ctxt,
1809                                             struct x86_emulate_ops *ops,
1810                                             u16 port, u16 len)
1811 {
1812         struct desc_struct tr_seg;
1813         int r;
1814         u16 io_bitmap_ptr;
1815         u8 perm, bit_idx = port & 0x7;
1816         unsigned mask = (1 << len) - 1;
1817
1818         ops->get_cached_descriptor(&tr_seg, VCPU_SREG_TR, ctxt->vcpu);
1819         if (!tr_seg.p)
1820                 return false;
1821         if (desc_limit_scaled(&tr_seg) < 103)
1822                 return false;
1823         r = ops->read_std(get_desc_base(&tr_seg) + 102, &io_bitmap_ptr, 2,
1824                           ctxt->vcpu, NULL);
1825         if (r != X86EMUL_CONTINUE)
1826                 return false;
1827         if (io_bitmap_ptr + port/8 > desc_limit_scaled(&tr_seg))
1828                 return false;
1829         r = ops->read_std(get_desc_base(&tr_seg) + io_bitmap_ptr + port/8,
1830                           &perm, 1, ctxt->vcpu, NULL);
1831         if (r != X86EMUL_CONTINUE)
1832                 return false;
1833         if ((perm >> bit_idx) & mask)
1834                 return false;
1835         return true;
1836 }
1837
1838 static bool emulator_io_permited(struct x86_emulate_ctxt *ctxt,
1839                                  struct x86_emulate_ops *ops,
1840                                  u16 port, u16 len)
1841 {
1842         if (ctxt->perm_ok)
1843                 return true;
1844
1845         if (emulator_bad_iopl(ctxt, ops))
1846                 if (!emulator_io_port_access_allowed(ctxt, ops, port, len))
1847                         return false;
1848
1849         ctxt->perm_ok = true;
1850
1851         return true;
1852 }
1853
1854 static void save_state_to_tss16(struct x86_emulate_ctxt *ctxt,
1855                                 struct x86_emulate_ops *ops,
1856                                 struct tss_segment_16 *tss)
1857 {
1858         struct decode_cache *c = &ctxt->decode;
1859
1860         tss->ip = c->eip;
1861         tss->flag = ctxt->eflags;
1862         tss->ax = c->regs[VCPU_REGS_RAX];
1863         tss->cx = c->regs[VCPU_REGS_RCX];
1864         tss->dx = c->regs[VCPU_REGS_RDX];
1865         tss->bx = c->regs[VCPU_REGS_RBX];
1866         tss->sp = c->regs[VCPU_REGS_RSP];
1867         tss->bp = c->regs[VCPU_REGS_RBP];
1868         tss->si = c->regs[VCPU_REGS_RSI];
1869         tss->di = c->regs[VCPU_REGS_RDI];
1870
1871         tss->es = ops->get_segment_selector(VCPU_SREG_ES, ctxt->vcpu);
1872         tss->cs = ops->get_segment_selector(VCPU_SREG_CS, ctxt->vcpu);
1873         tss->ss = ops->get_segment_selector(VCPU_SREG_SS, ctxt->vcpu);
1874         tss->ds = ops->get_segment_selector(VCPU_SREG_DS, ctxt->vcpu);
1875         tss->ldt = ops->get_segment_selector(VCPU_SREG_LDTR, ctxt->vcpu);
1876 }
1877
1878 static int load_state_from_tss16(struct x86_emulate_ctxt *ctxt,
1879                                  struct x86_emulate_ops *ops,
1880                                  struct tss_segment_16 *tss)
1881 {
1882         struct decode_cache *c = &ctxt->decode;
1883         int ret;
1884
1885         c->eip = tss->ip;
1886         ctxt->eflags = tss->flag | 2;
1887         c->regs[VCPU_REGS_RAX] = tss->ax;
1888         c->regs[VCPU_REGS_RCX] = tss->cx;
1889         c->regs[VCPU_REGS_RDX] = tss->dx;
1890         c->regs[VCPU_REGS_RBX] = tss->bx;
1891         c->regs[VCPU_REGS_RSP] = tss->sp;
1892         c->regs[VCPU_REGS_RBP] = tss->bp;
1893         c->regs[VCPU_REGS_RSI] = tss->si;
1894         c->regs[VCPU_REGS_RDI] = tss->di;
1895
1896         /*
1897          * SDM says that segment selectors are loaded before segment
1898          * descriptors
1899          */
1900         ops->set_segment_selector(tss->ldt, VCPU_SREG_LDTR, ctxt->vcpu);
1901         ops->set_segment_selector(tss->es, VCPU_SREG_ES, ctxt->vcpu);
1902         ops->set_segment_selector(tss->cs, VCPU_SREG_CS, ctxt->vcpu);
1903         ops->set_segment_selector(tss->ss, VCPU_SREG_SS, ctxt->vcpu);
1904         ops->set_segment_selector(tss->ds, VCPU_SREG_DS, ctxt->vcpu);
1905
1906         /*
1907          * Now load segment descriptors. If fault happenes at this stage
1908          * it is handled in a context of new task
1909          */
1910         ret = load_segment_descriptor(ctxt, ops, tss->ldt, VCPU_SREG_LDTR);
1911         if (ret != X86EMUL_CONTINUE)
1912                 return ret;
1913         ret = load_segment_descriptor(ctxt, ops, tss->es, VCPU_SREG_ES);
1914         if (ret != X86EMUL_CONTINUE)
1915                 return ret;
1916         ret = load_segment_descriptor(ctxt, ops, tss->cs, VCPU_SREG_CS);
1917         if (ret != X86EMUL_CONTINUE)
1918                 return ret;
1919         ret = load_segment_descriptor(ctxt, ops, tss->ss, VCPU_SREG_SS);
1920         if (ret != X86EMUL_CONTINUE)
1921                 return ret;
1922         ret = load_segment_descriptor(ctxt, ops, tss->ds, VCPU_SREG_DS);
1923         if (ret != X86EMUL_CONTINUE)
1924                 return ret;
1925
1926         return X86EMUL_CONTINUE;
1927 }
1928
1929 static int task_switch_16(struct x86_emulate_ctxt *ctxt,
1930                           struct x86_emulate_ops *ops,
1931                           u16 tss_selector, u16 old_tss_sel,
1932                           ulong old_tss_base, struct desc_struct *new_desc)
1933 {
1934         struct tss_segment_16 tss_seg;
1935         int ret;
1936         u32 err, new_tss_base = get_desc_base(new_desc);
1937
1938         ret = ops->read_std(old_tss_base, &tss_seg, sizeof tss_seg, ctxt->vcpu,
1939                             &err);
1940         if (ret == X86EMUL_PROPAGATE_FAULT) {
1941                 /* FIXME: need to provide precise fault address */
1942                 emulate_pf(ctxt, old_tss_base, err);
1943                 return ret;
1944         }
1945
1946         save_state_to_tss16(ctxt, ops, &tss_seg);
1947
1948         ret = ops->write_std(old_tss_base, &tss_seg, sizeof tss_seg, ctxt->vcpu,
1949                              &err);
1950         if (ret == X86EMUL_PROPAGATE_FAULT) {
1951                 /* FIXME: need to provide precise fault address */
1952                 emulate_pf(ctxt, old_tss_base, err);
1953                 return ret;
1954         }
1955
1956         ret = ops->read_std(new_tss_base, &tss_seg, sizeof tss_seg, ctxt->vcpu,
1957                             &err);
1958         if (ret == X86EMUL_PROPAGATE_FAULT) {
1959                 /* FIXME: need to provide precise fault address */
1960                 emulate_pf(ctxt, new_tss_base, err);
1961                 return ret;
1962         }
1963
1964         if (old_tss_sel != 0xffff) {
1965                 tss_seg.prev_task_link = old_tss_sel;
1966
1967                 ret = ops->write_std(new_tss_base,
1968                                      &tss_seg.prev_task_link,
1969                                      sizeof tss_seg.prev_task_link,
1970                                      ctxt->vcpu, &err);
1971                 if (ret == X86EMUL_PROPAGATE_FAULT) {
1972                         /* FIXME: need to provide precise fault address */
1973                         emulate_pf(ctxt, new_tss_base, err);
1974                         return ret;
1975                 }
1976         }
1977
1978         return load_state_from_tss16(ctxt, ops, &tss_seg);
1979 }
1980
1981 static void save_state_to_tss32(struct x86_emulate_ctxt *ctxt,
1982                                 struct x86_emulate_ops *ops,
1983                                 struct tss_segment_32 *tss)
1984 {
1985         struct decode_cache *c = &ctxt->decode;
1986
1987         tss->cr3 = ops->get_cr(3, ctxt->vcpu);
1988         tss->eip = c->eip;
1989         tss->eflags = ctxt->eflags;
1990         tss->eax = c->regs[VCPU_REGS_RAX];
1991         tss->ecx = c->regs[VCPU_REGS_RCX];
1992         tss->edx = c->regs[VCPU_REGS_RDX];
1993         tss->ebx = c->regs[VCPU_REGS_RBX];
1994         tss->esp = c->regs[VCPU_REGS_RSP];
1995         tss->ebp = c->regs[VCPU_REGS_RBP];
1996         tss->esi = c->regs[VCPU_REGS_RSI];
1997         tss->edi = c->regs[VCPU_REGS_RDI];
1998
1999         tss->es = ops->get_segment_selector(VCPU_SREG_ES, ctxt->vcpu);
2000         tss->cs = ops->get_segment_selector(VCPU_SREG_CS, ctxt->vcpu);
2001         tss->ss = ops->get_segment_selector(VCPU_SREG_SS, ctxt->vcpu);
2002         tss->ds = ops->get_segment_selector(VCPU_SREG_DS, ctxt->vcpu);
2003         tss->fs = ops->get_segment_selector(VCPU_SREG_FS, ctxt->vcpu);
2004         tss->gs = ops->get_segment_selector(VCPU_SREG_GS, ctxt->vcpu);
2005         tss->ldt_selector = ops->get_segment_selector(VCPU_SREG_LDTR, ctxt->vcpu);
2006 }
2007
2008 static int load_state_from_tss32(struct x86_emulate_ctxt *ctxt,
2009                                  struct x86_emulate_ops *ops,
2010                                  struct tss_segment_32 *tss)
2011 {
2012         struct decode_cache *c = &ctxt->decode;
2013         int ret;
2014
2015         if (ops->set_cr(3, tss->cr3, ctxt->vcpu)) {
2016                 emulate_gp(ctxt, 0);
2017                 return X86EMUL_PROPAGATE_FAULT;
2018         }
2019         c->eip = tss->eip;
2020         ctxt->eflags = tss->eflags | 2;
2021         c->regs[VCPU_REGS_RAX] = tss->eax;
2022         c->regs[VCPU_REGS_RCX] = tss->ecx;
2023         c->regs[VCPU_REGS_RDX] = tss->edx;
2024         c->regs[VCPU_REGS_RBX] = tss->ebx;
2025         c->regs[VCPU_REGS_RSP] = tss->esp;
2026         c->regs[VCPU_REGS_RBP] = tss->ebp;
2027         c->regs[VCPU_REGS_RSI] = tss->esi;
2028         c->regs[VCPU_REGS_RDI] = tss->edi;
2029
2030         /*
2031          * SDM says that segment selectors are loaded before segment
2032          * descriptors
2033          */
2034         ops->set_segment_selector(tss->ldt_selector, VCPU_SREG_LDTR, ctxt->vcpu);
2035         ops->set_segment_selector(tss->es, VCPU_SREG_ES, ctxt->vcpu);
2036         ops->set_segment_selector(tss->cs, VCPU_SREG_CS, ctxt->vcpu);
2037         ops->set_segment_selector(tss->ss, VCPU_SREG_SS, ctxt->vcpu);
2038         ops->set_segment_selector(tss->ds, VCPU_SREG_DS, ctxt->vcpu);
2039         ops->set_segment_selector(tss->fs, VCPU_SREG_FS, ctxt->vcpu);
2040         ops->set_segment_selector(tss->gs, VCPU_SREG_GS, ctxt->vcpu);
2041
2042         /*
2043          * Now load segment descriptors. If fault happenes at this stage
2044          * it is handled in a context of new task
2045          */
2046         ret = load_segment_descriptor(ctxt, ops, tss->ldt_selector, VCPU_SREG_LDTR);
2047         if (ret != X86EMUL_CONTINUE)
2048                 return ret;
2049         ret = load_segment_descriptor(ctxt, ops, tss->es, VCPU_SREG_ES);
2050         if (ret != X86EMUL_CONTINUE)
2051                 return ret;
2052         ret = load_segment_descriptor(ctxt, ops, tss->cs, VCPU_SREG_CS);
2053         if (ret != X86EMUL_CONTINUE)
2054                 return ret;
2055         ret = load_segment_descriptor(ctxt, ops, tss->ss, VCPU_SREG_SS);
2056         if (ret != X86EMUL_CONTINUE)
2057                 return ret;
2058         ret = load_segment_descriptor(ctxt, ops, tss->ds, VCPU_SREG_DS);
2059         if (ret != X86EMUL_CONTINUE)
2060                 return ret;
2061         ret = load_segment_descriptor(ctxt, ops, tss->fs, VCPU_SREG_FS);
2062         if (ret != X86EMUL_CONTINUE)
2063                 return ret;
2064         ret = load_segment_descriptor(ctxt, ops, tss->gs, VCPU_SREG_GS);
2065         if (ret != X86EMUL_CONTINUE)
2066                 return ret;
2067
2068         return X86EMUL_CONTINUE;
2069 }
2070
2071 static int task_switch_32(struct x86_emulate_ctxt *ctxt,
2072                           struct x86_emulate_ops *ops,
2073                           u16 tss_selector, u16 old_tss_sel,
2074                           ulong old_tss_base, struct desc_struct *new_desc)
2075 {
2076         struct tss_segment_32 tss_seg;
2077         int ret;
2078         u32 err, new_tss_base = get_desc_base(new_desc);
2079
2080         ret = ops->read_std(old_tss_base, &tss_seg, sizeof tss_seg, ctxt->vcpu,
2081                             &err);
2082         if (ret == X86EMUL_PROPAGATE_FAULT) {
2083                 /* FIXME: need to provide precise fault address */
2084                 emulate_pf(ctxt, old_tss_base, err);
2085                 return ret;
2086         }
2087
2088         save_state_to_tss32(ctxt, ops, &tss_seg);
2089
2090         ret = ops->write_std(old_tss_base, &tss_seg, sizeof tss_seg, ctxt->vcpu,
2091                              &err);
2092         if (ret == X86EMUL_PROPAGATE_FAULT) {
2093                 /* FIXME: need to provide precise fault address */
2094                 emulate_pf(ctxt, old_tss_base, err);
2095                 return ret;
2096         }
2097
2098         ret = ops->read_std(new_tss_base, &tss_seg, sizeof tss_seg, ctxt->vcpu,
2099                             &err);
2100         if (ret == X86EMUL_PROPAGATE_FAULT) {
2101                 /* FIXME: need to provide precise fault address */
2102                 emulate_pf(ctxt, new_tss_base, err);
2103                 return ret;
2104         }
2105
2106         if (old_tss_sel != 0xffff) {
2107                 tss_seg.prev_task_link = old_tss_sel;
2108
2109                 ret = ops->write_std(new_tss_base,
2110                                      &tss_seg.prev_task_link,
2111                                      sizeof tss_seg.prev_task_link,
2112                                      ctxt->vcpu, &err);
2113                 if (ret == X86EMUL_PROPAGATE_FAULT) {
2114                         /* FIXME: need to provide precise fault address */
2115                         emulate_pf(ctxt, new_tss_base, err);
2116                         return ret;
2117                 }
2118         }
2119
2120         return load_state_from_tss32(ctxt, ops, &tss_seg);
2121 }
2122
2123 static int emulator_do_task_switch(struct x86_emulate_ctxt *ctxt,
2124                                    struct x86_emulate_ops *ops,
2125                                    u16 tss_selector, int reason,
2126                                    bool has_error_code, u32 error_code)
2127 {
2128         struct desc_struct curr_tss_desc, next_tss_desc;
2129         int ret;
2130         u16 old_tss_sel = ops->get_segment_selector(VCPU_SREG_TR, ctxt->vcpu);
2131         ulong old_tss_base =
2132                 ops->get_cached_segment_base(VCPU_SREG_TR, ctxt->vcpu);
2133         u32 desc_limit;
2134
2135         /* FIXME: old_tss_base == ~0 ? */
2136
2137         ret = read_segment_descriptor(ctxt, ops, tss_selector, &next_tss_desc);
2138         if (ret != X86EMUL_CONTINUE)
2139                 return ret;
2140         ret = read_segment_descriptor(ctxt, ops, old_tss_sel, &curr_tss_desc);
2141         if (ret != X86EMUL_CONTINUE)
2142                 return ret;
2143
2144         /* FIXME: check that next_tss_desc is tss */
2145
2146         if (reason != TASK_SWITCH_IRET) {
2147                 if ((tss_selector & 3) > next_tss_desc.dpl ||
2148                     ops->cpl(ctxt->vcpu) > next_tss_desc.dpl) {
2149                         emulate_gp(ctxt, 0);
2150                         return X86EMUL_PROPAGATE_FAULT;
2151                 }
2152         }
2153
2154         desc_limit = desc_limit_scaled(&next_tss_desc);
2155         if (!next_tss_desc.p ||
2156             ((desc_limit < 0x67 && (next_tss_desc.type & 8)) ||
2157              desc_limit < 0x2b)) {
2158                 emulate_ts(ctxt, tss_selector & 0xfffc);
2159                 return X86EMUL_PROPAGATE_FAULT;
2160         }
2161
2162         if (reason == TASK_SWITCH_IRET || reason == TASK_SWITCH_JMP) {
2163                 curr_tss_desc.type &= ~(1 << 1); /* clear busy flag */
2164                 write_segment_descriptor(ctxt, ops, old_tss_sel,
2165                                          &curr_tss_desc);
2166         }
2167
2168         if (reason == TASK_SWITCH_IRET)
2169                 ctxt->eflags = ctxt->eflags & ~X86_EFLAGS_NT;
2170
2171         /* set back link to prev task only if NT bit is set in eflags
2172            note that old_tss_sel is not used afetr this point */
2173         if (reason != TASK_SWITCH_CALL && reason != TASK_SWITCH_GATE)
2174                 old_tss_sel = 0xffff;
2175
2176         if (next_tss_desc.type & 8)
2177                 ret = task_switch_32(ctxt, ops, tss_selector, old_tss_sel,
2178                                      old_tss_base, &next_tss_desc);
2179         else
2180                 ret = task_switch_16(ctxt, ops, tss_selector, old_tss_sel,
2181                                      old_tss_base, &next_tss_desc);
2182         if (ret != X86EMUL_CONTINUE)
2183                 return ret;
2184
2185         if (reason == TASK_SWITCH_CALL || reason == TASK_SWITCH_GATE)
2186                 ctxt->eflags = ctxt->eflags | X86_EFLAGS_NT;
2187
2188         if (reason != TASK_SWITCH_IRET) {
2189                 next_tss_desc.type |= (1 << 1); /* set busy flag */
2190                 write_segment_descriptor(ctxt, ops, tss_selector,
2191                                          &next_tss_desc);
2192         }
2193
2194         ops->set_cr(0,  ops->get_cr(0, ctxt->vcpu) | X86_CR0_TS, ctxt->vcpu);
2195         ops->set_cached_descriptor(&next_tss_desc, VCPU_SREG_TR, ctxt->vcpu);
2196         ops->set_segment_selector(tss_selector, VCPU_SREG_TR, ctxt->vcpu);
2197
2198         if (has_error_code) {
2199                 struct decode_cache *c = &ctxt->decode;
2200
2201                 c->op_bytes = c->ad_bytes = (next_tss_desc.type & 8) ? 4 : 2;
2202                 c->lock_prefix = 0;
2203                 c->src.val = (unsigned long) error_code;
2204                 emulate_push(ctxt, ops);
2205         }
2206
2207         return ret;
2208 }
2209
2210 int emulator_task_switch(struct x86_emulate_ctxt *ctxt,
2211                          u16 tss_selector, int reason,
2212                          bool has_error_code, u32 error_code)
2213 {
2214         struct x86_emulate_ops *ops = ctxt->ops;
2215         struct decode_cache *c = &ctxt->decode;
2216         int rc;
2217
2218         c->eip = ctxt->eip;
2219         c->dst.type = OP_NONE;
2220
2221         rc = emulator_do_task_switch(ctxt, ops, tss_selector, reason,
2222                                      has_error_code, error_code);
2223
2224         if (rc == X86EMUL_CONTINUE) {
2225                 rc = writeback(ctxt, ops);
2226                 if (rc == X86EMUL_CONTINUE)
2227                         ctxt->eip = c->eip;
2228         }
2229
2230         return (rc == X86EMUL_UNHANDLEABLE) ? -1 : 0;
2231 }
2232
2233 static void string_addr_inc(struct x86_emulate_ctxt *ctxt, unsigned long base,
2234                             int reg, struct operand *op)
2235 {
2236         struct decode_cache *c = &ctxt->decode;
2237         int df = (ctxt->eflags & EFLG_DF) ? -1 : 1;
2238
2239         register_address_increment(c, &c->regs[reg], df * op->bytes);
2240         op->addr.mem = register_address(c,  base, c->regs[reg]);
2241 }
2242
2243 static int em_push(struct x86_emulate_ctxt *ctxt)
2244 {
2245         emulate_push(ctxt, ctxt->ops);
2246         return X86EMUL_CONTINUE;
2247 }
2248
2249 static int em_das(struct x86_emulate_ctxt *ctxt)
2250 {
2251         struct decode_cache *c = &ctxt->decode;
2252         u8 al, old_al;
2253         bool af, cf, old_cf;
2254
2255         cf = ctxt->eflags & X86_EFLAGS_CF;
2256         al = c->dst.val;
2257
2258         old_al = al;
2259         old_cf = cf;
2260         cf = false;
2261         af = ctxt->eflags & X86_EFLAGS_AF;
2262         if ((al & 0x0f) > 9 || af) {
2263                 al -= 6;
2264                 cf = old_cf | (al >= 250);
2265                 af = true;
2266         } else {
2267                 af = false;
2268         }
2269         if (old_al > 0x99 || old_cf) {
2270                 al -= 0x60;
2271                 cf = true;
2272         }
2273
2274         c->dst.val = al;
2275         /* Set PF, ZF, SF */
2276         c->src.type = OP_IMM;
2277         c->src.val = 0;
2278         c->src.bytes = 1;
2279         emulate_2op_SrcV("or", c->src, c->dst, ctxt->eflags);
2280         ctxt->eflags &= ~(X86_EFLAGS_AF | X86_EFLAGS_CF);
2281         if (cf)
2282                 ctxt->eflags |= X86_EFLAGS_CF;
2283         if (af)
2284                 ctxt->eflags |= X86_EFLAGS_AF;
2285         return X86EMUL_CONTINUE;
2286 }
2287
2288 static int em_call_far(struct x86_emulate_ctxt *ctxt)
2289 {
2290         struct decode_cache *c = &ctxt->decode;
2291         u16 sel, old_cs;
2292         ulong old_eip;
2293         int rc;
2294
2295         old_cs = ctxt->ops->get_segment_selector(VCPU_SREG_CS, ctxt->vcpu);
2296         old_eip = c->eip;
2297
2298         memcpy(&sel, c->src.valptr + c->op_bytes, 2);
2299         if (load_segment_descriptor(ctxt, ctxt->ops, sel, VCPU_SREG_CS))
2300                 return X86EMUL_CONTINUE;
2301
2302         c->eip = 0;
2303         memcpy(&c->eip, c->src.valptr, c->op_bytes);
2304
2305         c->src.val = old_cs;
2306         emulate_push(ctxt, ctxt->ops);
2307         rc = writeback(ctxt, ctxt->ops);
2308         if (rc != X86EMUL_CONTINUE)
2309                 return rc;
2310
2311         c->src.val = old_eip;
2312         emulate_push(ctxt, ctxt->ops);
2313         rc = writeback(ctxt, ctxt->ops);
2314         if (rc != X86EMUL_CONTINUE)
2315                 return rc;
2316
2317         c->dst.type = OP_NONE;
2318
2319         return X86EMUL_CONTINUE;
2320 }
2321
2322 static int em_ret_near_imm(struct x86_emulate_ctxt *ctxt)
2323 {
2324         struct decode_cache *c = &ctxt->decode;
2325         int rc;
2326
2327         c->dst.type = OP_REG;
2328         c->dst.addr.reg = &c->eip;
2329         c->dst.bytes = c->op_bytes;
2330         rc = emulate_pop(ctxt, ctxt->ops, &c->dst.val, c->op_bytes);
2331         if (rc != X86EMUL_CONTINUE)
2332                 return rc;
2333         register_address_increment(c, &c->regs[VCPU_REGS_RSP], c->src.val);
2334         return X86EMUL_CONTINUE;
2335 }
2336
2337 static int em_imul(struct x86_emulate_ctxt *ctxt)
2338 {
2339         struct decode_cache *c = &ctxt->decode;
2340
2341         emulate_2op_SrcV_nobyte("imul", c->src, c->dst, ctxt->eflags);
2342         return X86EMUL_CONTINUE;
2343 }
2344
2345 static int em_imul_3op(struct x86_emulate_ctxt *ctxt)
2346 {
2347         struct decode_cache *c = &ctxt->decode;
2348
2349         c->dst.val = c->src2.val;
2350         return em_imul(ctxt);
2351 }
2352
2353 static int em_cwd(struct x86_emulate_ctxt *ctxt)
2354 {
2355         struct decode_cache *c = &ctxt->decode;
2356
2357         c->dst.type = OP_REG;
2358         c->dst.bytes = c->src.bytes;
2359         c->dst.addr.reg = &c->regs[VCPU_REGS_RDX];
2360         c->dst.val = ~((c->src.val >> (c->src.bytes * 8 - 1)) - 1);
2361
2362         return X86EMUL_CONTINUE;
2363 }
2364
2365 static int em_rdtsc(struct x86_emulate_ctxt *ctxt)
2366 {
2367         unsigned cpl = ctxt->ops->cpl(ctxt->vcpu);
2368         struct decode_cache *c = &ctxt->decode;
2369         u64 tsc = 0;
2370
2371         if (cpl > 0 && (ctxt->ops->get_cr(4, ctxt->vcpu) & X86_CR4_TSD)) {
2372                 emulate_gp(ctxt, 0);
2373                 return X86EMUL_PROPAGATE_FAULT;
2374         }
2375         ctxt->ops->get_msr(ctxt->vcpu, MSR_IA32_TSC, &tsc);
2376         c->regs[VCPU_REGS_RAX] = (u32)tsc;
2377         c->regs[VCPU_REGS_RDX] = tsc >> 32;
2378         return X86EMUL_CONTINUE;
2379 }
2380
2381 #define D(_y) { .flags = (_y) }
2382 #define N    D(0)
2383 #define G(_f, _g) { .flags = ((_f) | Group), .u.group = (_g) }
2384 #define GD(_f, _g) { .flags = ((_f) | Group | GroupDual), .u.gdual = (_g) }
2385 #define I(_f, _e) { .flags = (_f), .u.execute = (_e) }
2386
2387 #define D2bv(_f)      D((_f) | ByteOp), D(_f)
2388 #define I2bv(_f, _e)  I((_f) | ByteOp, _e), I(_f, _e)
2389
2390 #define D6ALU(_f) D2bv((_f) | DstMem | SrcReg | ModRM),                 \
2391                 D2bv(((_f) | DstReg | SrcMem | ModRM) & ~Lock),         \
2392                 D2bv(((_f) & ~Lock) | DstAcc | SrcImm)
2393
2394
2395 static struct opcode group1[] = {
2396         X7(D(Lock)), N
2397 };
2398
2399 static struct opcode group1A[] = {
2400         D(DstMem | SrcNone | ModRM | Mov | Stack), N, N, N, N, N, N, N,
2401 };
2402
2403 static struct opcode group3[] = {
2404         D(DstMem | SrcImm | ModRM), D(DstMem | SrcImm | ModRM),
2405         D(DstMem | SrcNone | ModRM | Lock), D(DstMem | SrcNone | ModRM | Lock),
2406         X4(D(SrcMem | ModRM)),
2407 };
2408
2409 static struct opcode group4[] = {
2410         D(ByteOp | DstMem | SrcNone | ModRM | Lock), D(ByteOp | DstMem | SrcNone | ModRM | Lock),
2411         N, N, N, N, N, N,
2412 };
2413
2414 static struct opcode group5[] = {
2415         D(DstMem | SrcNone | ModRM | Lock), D(DstMem | SrcNone | ModRM | Lock),
2416         D(SrcMem | ModRM | Stack),
2417         I(SrcMemFAddr | ModRM | ImplicitOps | Stack, em_call_far),
2418         D(SrcMem | ModRM | Stack), D(SrcMemFAddr | ModRM | ImplicitOps),
2419         D(SrcMem | ModRM | Stack), N,
2420 };
2421
2422 static struct group_dual group7 = { {
2423         N, N, D(ModRM | SrcMem | Priv), D(ModRM | SrcMem | Priv),
2424         D(SrcNone | ModRM | DstMem | Mov), N,
2425         D(SrcMem16 | ModRM | Mov | Priv),
2426         D(SrcMem | ModRM | ByteOp | Priv | NoAccess),
2427 }, {
2428         D(SrcNone | ModRM | Priv), N, N, D(SrcNone | ModRM | Priv),
2429         D(SrcNone | ModRM | DstMem | Mov), N,
2430         D(SrcMem16 | ModRM | Mov | Priv), N,
2431 } };
2432
2433 static struct opcode group8[] = {
2434         N, N, N, N,
2435         D(DstMem | SrcImmByte | ModRM), D(DstMem | SrcImmByte | ModRM | Lock),
2436         D(DstMem | SrcImmByte | ModRM | Lock), D(DstMem | SrcImmByte | ModRM | Lock),
2437 };
2438
2439 static struct group_dual group9 = { {
2440         N, D(DstMem64 | ModRM | Lock), N, N, N, N, N, N,
2441 }, {
2442         N, N, N, N, N, N, N, N,
2443 } };
2444
2445 static struct opcode opcode_table[256] = {
2446         /* 0x00 - 0x07 */
2447         D6ALU(Lock),
2448         D(ImplicitOps | Stack | No64), D(ImplicitOps | Stack | No64),
2449         /* 0x08 - 0x0F */
2450         D6ALU(Lock),
2451         D(ImplicitOps | Stack | No64), N,
2452         /* 0x10 - 0x17 */
2453         D6ALU(Lock),
2454         D(ImplicitOps | Stack | No64), D(ImplicitOps | Stack | No64),
2455         /* 0x18 - 0x1F */
2456         D6ALU(Lock),
2457         D(ImplicitOps | Stack | No64), D(ImplicitOps | Stack | No64),
2458         /* 0x20 - 0x27 */
2459         D6ALU(Lock), N, N,
2460         /* 0x28 - 0x2F */
2461         D6ALU(Lock), N, I(ByteOp | DstAcc | No64, em_das),
2462         /* 0x30 - 0x37 */
2463         D6ALU(Lock), N, N,
2464         /* 0x38 - 0x3F */
2465         D6ALU(0), N, N,
2466         /* 0x40 - 0x4F */
2467         X16(D(DstReg)),
2468         /* 0x50 - 0x57 */
2469         X8(I(SrcReg | Stack, em_push)),
2470         /* 0x58 - 0x5F */
2471         X8(D(DstReg | Stack)),
2472         /* 0x60 - 0x67 */
2473         D(ImplicitOps | Stack | No64), D(ImplicitOps | Stack | No64),
2474         N, D(DstReg | SrcMem32 | ModRM | Mov) /* movsxd (x86/64) */ ,
2475         N, N, N, N,
2476         /* 0x68 - 0x6F */
2477         I(SrcImm | Mov | Stack, em_push),
2478         I(DstReg | SrcMem | ModRM | Src2Imm, em_imul_3op),
2479         I(SrcImmByte | Mov | Stack, em_push),
2480         I(DstReg | SrcMem | ModRM | Src2ImmByte, em_imul_3op),
2481         D2bv(DstDI | Mov | String), /* insb, insw/insd */
2482         D2bv(SrcSI | ImplicitOps | String), /* outsb, outsw/outsd */
2483         /* 0x70 - 0x7F */
2484         X16(D(SrcImmByte)),
2485         /* 0x80 - 0x87 */
2486         G(ByteOp | DstMem | SrcImm | ModRM | Group, group1),
2487         G(DstMem | SrcImm | ModRM | Group, group1),
2488         G(ByteOp | DstMem | SrcImm | ModRM | No64 | Group, group1),
2489         G(DstMem | SrcImmByte | ModRM | Group, group1),
2490         D2bv(DstMem | SrcReg | ModRM), D2bv(DstMem | SrcReg | ModRM | Lock),
2491         /* 0x88 - 0x8F */
2492         D2bv(DstMem | SrcReg | ModRM | Mov),
2493         D2bv(DstReg | SrcMem | ModRM | Mov),
2494         D(DstMem | SrcNone | ModRM | Mov), D(ModRM | SrcMem | NoAccess | DstReg),
2495         D(ImplicitOps | SrcMem16 | ModRM), G(0, group1A),
2496         /* 0x90 - 0x97 */
2497         X8(D(SrcAcc | DstReg)),
2498         /* 0x98 - 0x9F */
2499         D(DstAcc | SrcNone), I(ImplicitOps | SrcAcc, em_cwd),
2500         I(SrcImmFAddr | No64, em_call_far), N,
2501         D(ImplicitOps | Stack), D(ImplicitOps | Stack), N, N,
2502         /* 0xA0 - 0xA7 */
2503         D2bv(DstAcc | SrcMem | Mov | MemAbs),
2504         D2bv(DstMem | SrcAcc | Mov | MemAbs),
2505         D2bv(SrcSI | DstDI | Mov | String), D2bv(SrcSI | DstDI | String),
2506         /* 0xA8 - 0xAF */
2507         D2bv(DstAcc | SrcImm),
2508         D2bv(SrcAcc | DstDI | Mov | String),
2509         D2bv(SrcSI | DstAcc | Mov | String),
2510         D2bv(SrcAcc | DstDI | String),
2511         /* 0xB0 - 0xB7 */
2512         X8(D(ByteOp | DstReg | SrcImm | Mov)),
2513         /* 0xB8 - 0xBF */
2514         X8(D(DstReg | SrcImm | Mov)),
2515         /* 0xC0 - 0xC7 */
2516         D2bv(DstMem | SrcImmByte | ModRM),
2517         I(ImplicitOps | Stack | SrcImmU16, em_ret_near_imm),
2518         D(ImplicitOps | Stack),
2519         D(DstReg | SrcMemFAddr | ModRM | No64), D(DstReg | SrcMemFAddr | ModRM | No64),
2520         D2bv(DstMem | SrcImm | ModRM | Mov),
2521         /* 0xC8 - 0xCF */
2522         N, N, N, D(ImplicitOps | Stack),
2523         D(ImplicitOps), D(SrcImmByte), D(ImplicitOps | No64), D(ImplicitOps),
2524         /* 0xD0 - 0xD7 */
2525         D2bv(DstMem | SrcOne | ModRM), D2bv(DstMem | ModRM),
2526         N, N, N, N,
2527         /* 0xD8 - 0xDF */
2528         N, N, N, N, N, N, N, N,
2529         /* 0xE0 - 0xE7 */
2530         X4(D(SrcImmByte)),
2531         D2bv(SrcImmUByte | DstAcc), D2bv(SrcAcc | DstImmUByte),
2532         /* 0xE8 - 0xEF */
2533         D(SrcImm | Stack), D(SrcImm | ImplicitOps),
2534         D(SrcImmFAddr | No64), D(SrcImmByte | ImplicitOps),
2535         D2bv(SrcNone | DstAcc), D2bv(SrcAcc | ImplicitOps),
2536         /* 0xF0 - 0xF7 */
2537         N, N, N, N,
2538         D(ImplicitOps | Priv), D(ImplicitOps), G(ByteOp, group3), G(0, group3),
2539         /* 0xF8 - 0xFF */
2540         D(ImplicitOps), D(ImplicitOps), D(ImplicitOps), D(ImplicitOps),
2541         D(ImplicitOps), D(ImplicitOps), G(0, group4), G(0, group5),
2542 };
2543
2544 static struct opcode twobyte_table[256] = {
2545         /* 0x00 - 0x0F */
2546         N, GD(0, &group7), N, N,
2547         N, D(ImplicitOps), D(ImplicitOps | Priv), N,
2548         D(ImplicitOps | Priv), D(ImplicitOps | Priv), N, N,
2549         N, D(ImplicitOps | ModRM), N, N,
2550         /* 0x10 - 0x1F */
2551         N, N, N, N, N, N, N, N, D(ImplicitOps | ModRM), N, N, N, N, N, N, N,
2552         /* 0x20 - 0x2F */
2553         D(ModRM | DstMem | Priv | Op3264), D(ModRM | DstMem | Priv | Op3264),
2554         D(ModRM | SrcMem | Priv | Op3264), D(ModRM | SrcMem | Priv | Op3264),
2555         N, N, N, N,
2556         N, N, N, N, N, N, N, N,
2557         /* 0x30 - 0x3F */
2558         D(ImplicitOps | Priv), I(ImplicitOps, em_rdtsc),
2559         D(ImplicitOps | Priv), N,
2560         D(ImplicitOps), D(ImplicitOps | Priv), N, N,
2561         N, N, N, N, N, N, N, N,
2562         /* 0x40 - 0x4F */
2563         X16(D(DstReg | SrcMem | ModRM | Mov)),
2564         /* 0x50 - 0x5F */
2565         N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N,
2566         /* 0x60 - 0x6F */
2567         N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N,
2568         /* 0x70 - 0x7F */
2569         N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N,
2570         /* 0x80 - 0x8F */
2571         X16(D(SrcImm)),
2572         /* 0x90 - 0x9F */
2573         X16(D(ByteOp | DstMem | SrcNone | ModRM| Mov)),
2574         /* 0xA0 - 0xA7 */
2575         D(ImplicitOps | Stack), D(ImplicitOps | Stack),
2576         N, D(DstMem | SrcReg | ModRM | BitOp),
2577         D(DstMem | SrcReg | Src2ImmByte | ModRM),
2578         D(DstMem | SrcReg | Src2CL | ModRM), N, N,
2579         /* 0xA8 - 0xAF */
2580         D(ImplicitOps | Stack), D(ImplicitOps | Stack),
2581         N, D(DstMem | SrcReg | ModRM | BitOp | Lock),
2582         D(DstMem | SrcReg | Src2ImmByte | ModRM),
2583         D(DstMem | SrcReg | Src2CL | ModRM),
2584         D(ModRM), I(DstReg | SrcMem | ModRM, em_imul),
2585         /* 0xB0 - 0xB7 */
2586         D2bv(DstMem | SrcReg | ModRM | Lock),
2587         D(DstReg | SrcMemFAddr | ModRM), D(DstMem | SrcReg | ModRM | BitOp | Lock),
2588         D(DstReg | SrcMemFAddr | ModRM), D(DstReg | SrcMemFAddr | ModRM),
2589         D(ByteOp | DstReg | SrcMem | ModRM | Mov), D(DstReg | SrcMem16 | ModRM | Mov),
2590         /* 0xB8 - 0xBF */
2591         N, N,
2592         G(BitOp, group8), D(DstMem | SrcReg | ModRM | BitOp | Lock),
2593         D(DstReg | SrcMem | ModRM), D(DstReg | SrcMem | ModRM),
2594         D(ByteOp | DstReg | SrcMem | ModRM | Mov), D(DstReg | SrcMem16 | ModRM | Mov),
2595         /* 0xC0 - 0xCF */
2596         D2bv(DstMem | SrcReg | ModRM | Lock),
2597         N, D(DstMem | SrcReg | ModRM | Mov),
2598         N, N, N, GD(0, &group9),
2599         N, N, N, N, N, N, N, N,
2600         /* 0xD0 - 0xDF */
2601         N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N,
2602         /* 0xE0 - 0xEF */
2603         N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N,
2604         /* 0xF0 - 0xFF */
2605         N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N
2606 };
2607
2608 #undef D
2609 #undef N
2610 #undef G
2611 #undef GD
2612 #undef I
2613
2614 #undef D2bv
2615 #undef I2bv
2616 #undef D6ALU
2617
2618 static unsigned imm_size(struct decode_cache *c)
2619 {
2620         unsigned size;
2621
2622         size = (c->d & ByteOp) ? 1 : c->op_bytes;
2623         if (size == 8)
2624                 size = 4;
2625         return size;
2626 }
2627
2628 static int decode_imm(struct x86_emulate_ctxt *ctxt, struct operand *op,
2629                       unsigned size, bool sign_extension)
2630 {
2631         struct decode_cache *c = &ctxt->decode;
2632         struct x86_emulate_ops *ops = ctxt->ops;
2633         int rc = X86EMUL_CONTINUE;
2634
2635         op->type = OP_IMM;
2636         op->bytes = size;
2637         op->addr.mem = c->eip;
2638         /* NB. Immediates are sign-extended as necessary. */
2639         switch (op->bytes) {
2640         case 1:
2641                 op->val = insn_fetch(s8, 1, c->eip);
2642                 break;
2643         case 2:
2644                 op->val = insn_fetch(s16, 2, c->eip);
2645                 break;
2646         case 4:
2647                 op->val = insn_fetch(s32, 4, c->eip);
2648                 break;
2649         }
2650         if (!sign_extension) {
2651                 switch (op->bytes) {
2652                 case 1:
2653                         op->val &= 0xff;
2654                         break;
2655                 case 2:
2656                         op->val &= 0xffff;
2657                         break;
2658                 case 4:
2659                         op->val &= 0xffffffff;
2660                         break;
2661                 }
2662         }
2663 done:
2664         return rc;
2665 }
2666
2667 int
2668 x86_decode_insn(struct x86_emulate_ctxt *ctxt)
2669 {
2670         struct x86_emulate_ops *ops = ctxt->ops;
2671         struct decode_cache *c = &ctxt->decode;
2672         int rc = X86EMUL_CONTINUE;
2673         int mode = ctxt->mode;
2674         int def_op_bytes, def_ad_bytes, dual, goffset;
2675         struct opcode opcode, *g_mod012, *g_mod3;
2676         struct operand memop = { .type = OP_NONE };
2677
2678         c->eip = ctxt->eip;
2679         c->fetch.start = c->fetch.end = c->eip;
2680         ctxt->cs_base = seg_base(ctxt, ops, VCPU_SREG_CS);
2681
2682         switch (mode) {
2683         case X86EMUL_MODE_REAL:
2684         case X86EMUL_MODE_VM86:
2685         case X86EMUL_MODE_PROT16:
2686                 def_op_bytes = def_ad_bytes = 2;
2687                 break;
2688         case X86EMUL_MODE_PROT32:
2689                 def_op_bytes = def_ad_bytes = 4;
2690                 break;
2691 #ifdef CONFIG_X86_64
2692         case X86EMUL_MODE_PROT64:
2693                 def_op_bytes = 4;
2694                 def_ad_bytes = 8;
2695                 break;
2696 #endif
2697         default:
2698                 return -1;
2699         }
2700
2701         c->op_bytes = def_op_bytes;
2702         c->ad_bytes = def_ad_bytes;
2703
2704         /* Legacy prefixes. */
2705         for (;;) {
2706                 switch (c->b = insn_fetch(u8, 1, c->eip)) {
2707                 case 0x66:      /* operand-size override */
2708                         /* switch between 2/4 bytes */
2709                         c->op_bytes = def_op_bytes ^ 6;
2710                         break;
2711                 case 0x67:      /* address-size override */
2712                         if (mode == X86EMUL_MODE_PROT64)
2713                                 /* switch between 4/8 bytes */
2714                                 c->ad_bytes = def_ad_bytes ^ 12;
2715                         else
2716                                 /* switch between 2/4 bytes */
2717                                 c->ad_bytes = def_ad_bytes ^ 6;
2718                         break;
2719                 case 0x26:      /* ES override */
2720                 case 0x2e:      /* CS override */
2721                 case 0x36:      /* SS override */
2722                 case 0x3e:      /* DS override */
2723                         set_seg_override(c, (c->b >> 3) & 3);
2724                         break;
2725                 case 0x64:      /* FS override */
2726                 case 0x65:      /* GS override */
2727                         set_seg_override(c, c->b & 7);
2728                         break;
2729                 case 0x40 ... 0x4f: /* REX */
2730                         if (mode != X86EMUL_MODE_PROT64)
2731                                 goto done_prefixes;
2732                         c->rex_prefix = c->b;
2733                         continue;
2734                 case 0xf0:      /* LOCK */
2735                         c->lock_prefix = 1;
2736                         break;
2737                 case 0xf2:      /* REPNE/REPNZ */
2738                         c->rep_prefix = REPNE_PREFIX;
2739                         break;
2740                 case 0xf3:      /* REP/REPE/REPZ */
2741                         c->rep_prefix = REPE_PREFIX;
2742                         break;
2743                 default:
2744                         goto done_prefixes;
2745                 }
2746
2747                 /* Any legacy prefix after a REX prefix nullifies its effect. */
2748
2749                 c->rex_prefix = 0;
2750         }
2751
2752 done_prefixes:
2753
2754         /* REX prefix. */
2755         if (c->rex_prefix & 8)
2756                 c->op_bytes = 8;        /* REX.W */
2757
2758         /* Opcode byte(s). */
2759         opcode = opcode_table[c->b];
2760         /* Two-byte opcode? */
2761         if (c->b == 0x0f) {
2762                 c->twobyte = 1;
2763                 c->b = insn_fetch(u8, 1, c->eip);
2764                 opcode = twobyte_table[c->b];
2765         }
2766         c->d = opcode.flags;
2767
2768         if (c->d & Group) {
2769                 dual = c->d & GroupDual;
2770                 c->modrm = insn_fetch(u8, 1, c->eip);
2771                 --c->eip;
2772
2773                 if (c->d & GroupDual) {
2774                         g_mod012 = opcode.u.gdual->mod012;
2775                         g_mod3 = opcode.u.gdual->mod3;
2776                 } else
2777                         g_mod012 = g_mod3 = opcode.u.group;
2778
2779                 c->d &= ~(Group | GroupDual);
2780
2781                 goffset = (c->modrm >> 3) & 7;
2782
2783                 if ((c->modrm >> 6) == 3)
2784                         opcode = g_mod3[goffset];
2785                 else
2786                         opcode = g_mod012[goffset];
2787                 c->d |= opcode.flags;
2788         }
2789
2790         c->execute = opcode.u.execute;
2791
2792         /* Unrecognised? */
2793         if (c->d == 0 || (c->d & Undefined)) {
2794                 DPRINTF("Cannot emulate %02x\n", c->b);
2795                 return -1;
2796         }
2797
2798         if (mode == X86EMUL_MODE_PROT64 && (c->d & Stack))
2799                 c->op_bytes = 8;
2800
2801         if (c->d & Op3264) {
2802                 if (mode == X86EMUL_MODE_PROT64)
2803                         c->op_bytes = 8;
2804                 else
2805                         c->op_bytes = 4;
2806         }
2807
2808         /* ModRM and SIB bytes. */
2809         if (c->d & ModRM) {
2810                 rc = decode_modrm(ctxt, ops, &memop);
2811                 if (!c->has_seg_override)
2812                         set_seg_override(c, c->modrm_seg);
2813         } else if (c->d & MemAbs)
2814                 rc = decode_abs(ctxt, ops, &memop);
2815         if (rc != X86EMUL_CONTINUE)
2816                 goto done;
2817
2818         if (!c->has_seg_override)
2819                 set_seg_override(c, VCPU_SREG_DS);
2820
2821         if (memop.type == OP_MEM && !(!c->twobyte && c->b == 0x8d))
2822                 memop.addr.mem += seg_override_base(ctxt, ops, c);
2823
2824         if (memop.type == OP_MEM && c->ad_bytes != 8)
2825                 memop.addr.mem = (u32)memop.addr.mem;
2826
2827         if (memop.type == OP_MEM && c->rip_relative)
2828                 memop.addr.mem += c->eip;
2829
2830         /*
2831          * Decode and fetch the source operand: register, memory
2832          * or immediate.
2833          */
2834         switch (c->d & SrcMask) {
2835         case SrcNone:
2836                 break;
2837         case SrcReg:
2838                 decode_register_operand(&c->src, c, 0);
2839                 break;
2840         case SrcMem16:
2841                 memop.bytes = 2;
2842                 goto srcmem_common;
2843         case SrcMem32:
2844                 memop.bytes = 4;
2845                 goto srcmem_common;
2846         case SrcMem:
2847                 memop.bytes = (c->d & ByteOp) ? 1 :
2848                                                            c->op_bytes;
2849         srcmem_common:
2850                 c->src = memop;
2851                 break;
2852         case SrcImmU16:
2853                 rc = decode_imm(ctxt, &c->src, 2, false);
2854                 break;
2855         case SrcImm:
2856                 rc = decode_imm(ctxt, &c->src, imm_size(c), true);
2857                 break;
2858         case SrcImmU:
2859                 rc = decode_imm(ctxt, &c->src, imm_size(c), false);
2860                 break;
2861         case SrcImmByte:
2862                 rc = decode_imm(ctxt, &c->src, 1, true);
2863                 break;
2864         case SrcImmUByte:
2865                 rc = decode_imm(ctxt, &c->src, 1, false);
2866                 break;
2867         case SrcAcc:
2868                 c->src.type = OP_REG;
2869                 c->src.bytes = (c->d & ByteOp) ? 1 : c->op_bytes;
2870                 c->src.addr.reg = &c->regs[VCPU_REGS_RAX];
2871                 fetch_register_operand(&c->src);
2872                 break;
2873         case SrcOne:
2874                 c->src.bytes = 1;
2875                 c->src.val = 1;
2876                 break;
2877         case SrcSI:
2878                 c->src.type = OP_MEM;
2879                 c->src.bytes = (c->d & ByteOp) ? 1 : c->op_bytes;
2880                 c->src.addr.mem =
2881                         register_address(c,  seg_override_base(ctxt, ops, c),
2882                                          c->regs[VCPU_REGS_RSI]);
2883                 c->src.val = 0;
2884                 break;
2885         case SrcImmFAddr:
2886                 c->src.type = OP_IMM;
2887                 c->src.addr.mem = c->eip;
2888                 c->src.bytes = c->op_bytes + 2;
2889                 insn_fetch_arr(c->src.valptr, c->src.bytes, c->eip);
2890                 break;
2891         case SrcMemFAddr:
2892                 memop.bytes = c->op_bytes + 2;
2893                 goto srcmem_common;
2894                 break;
2895         }
2896
2897         if (rc != X86EMUL_CONTINUE)
2898                 goto done;
2899
2900         /*
2901          * Decode and fetch the second source operand: register, memory
2902          * or immediate.
2903          */
2904         switch (c->d & Src2Mask) {
2905         case Src2None:
2906                 break;
2907         case Src2CL:
2908                 c->src2.bytes = 1;
2909                 c->src2.val = c->regs[VCPU_REGS_RCX] & 0x8;
2910                 break;
2911         case Src2ImmByte:
2912                 rc = decode_imm(ctxt, &c->src2, 1, true);
2913                 break;
2914         case Src2One:
2915                 c->src2.bytes = 1;
2916                 c->src2.val = 1;
2917                 break;
2918         case Src2Imm:
2919                 rc = decode_imm(ctxt, &c->src2, imm_size(c), true);
2920                 break;
2921         }
2922
2923         if (rc != X86EMUL_CONTINUE)
2924                 goto done;
2925
2926         /* Decode and fetch the destination operand: register or memory. */
2927         switch (c->d & DstMask) {
2928         case DstReg:
2929                 decode_register_operand(&c->dst, c,
2930                          c->twobyte && (c->b == 0xb6 || c->b == 0xb7));
2931                 break;
2932         case DstImmUByte:
2933                 c->dst.type = OP_IMM;
2934                 c->dst.addr.mem = c->eip;
2935                 c->dst.bytes = 1;
2936                 c->dst.val = insn_fetch(u8, 1, c->eip);
2937                 break;
2938         case DstMem:
2939         case DstMem64:
2940                 c->dst = memop;
2941                 if ((c->d & DstMask) == DstMem64)
2942                         c->dst.bytes = 8;
2943                 else
2944                         c->dst.bytes = (c->d & ByteOp) ? 1 : c->op_bytes;
2945                 if (c->d & BitOp)
2946                         fetch_bit_operand(c);
2947                 c->dst.orig_val = c->dst.val;
2948                 break;
2949         case DstAcc:
2950                 c->dst.type = OP_REG;
2951                 c->dst.bytes = (c->d & ByteOp) ? 1 : c->op_bytes;
2952                 c->dst.addr.reg = &c->regs[VCPU_REGS_RAX];
2953                 fetch_register_operand(&c->dst);
2954                 c->dst.orig_val = c->dst.val;
2955                 break;
2956         case DstDI:
2957                 c->dst.type = OP_MEM;
2958                 c->dst.bytes = (c->d & ByteOp) ? 1 : c->op_bytes;
2959                 c->dst.addr.mem =
2960                         register_address(c, es_base(ctxt, ops),
2961                                          c->regs[VCPU_REGS_RDI]);
2962                 c->dst.val = 0;
2963                 break;
2964         case ImplicitOps:
2965                 /* Special instructions do their own operand decoding. */
2966         default:
2967                 c->dst.type = OP_NONE; /* Disable writeback. */
2968                 return 0;
2969         }
2970
2971 done:
2972         return (rc == X86EMUL_UNHANDLEABLE) ? -1 : 0;
2973 }
2974
2975 static bool string_insn_completed(struct x86_emulate_ctxt *ctxt)
2976 {
2977         struct decode_cache *c = &ctxt->decode;
2978
2979         /* The second termination condition only applies for REPE
2980          * and REPNE. Test if the repeat string operation prefix is
2981          * REPE/REPZ or REPNE/REPNZ and if it's the case it tests the
2982          * corresponding termination condition according to:
2983          *      - if REPE/REPZ and ZF = 0 then done
2984          *      - if REPNE/REPNZ and ZF = 1 then done
2985          */
2986         if (((c->b == 0xa6) || (c->b == 0xa7) ||
2987              (c->b == 0xae) || (c->b == 0xaf))
2988             && (((c->rep_prefix == REPE_PREFIX) &&
2989                  ((ctxt->eflags & EFLG_ZF) == 0))
2990                 || ((c->rep_prefix == REPNE_PREFIX) &&
2991                     ((ctxt->eflags & EFLG_ZF) == EFLG_ZF))))
2992                 return true;
2993
2994         return false;
2995 }
2996
2997 int
2998 x86_emulate_insn(struct x86_emulate_ctxt *ctxt)
2999 {
3000         struct x86_emulate_ops *ops = ctxt->ops;
3001         u64 msr_data;
3002         struct decode_cache *c = &ctxt->decode;
3003         int rc = X86EMUL_CONTINUE;
3004         int saved_dst_type = c->dst.type;
3005         int irq; /* Used for int 3, int, and into */
3006
3007         ctxt->decode.mem_read.pos = 0;
3008
3009         if (ctxt->mode == X86EMUL_MODE_PROT64 && (c->d & No64)) {
3010                 emulate_ud(ctxt);
3011                 goto done;
3012         }
3013
3014         /* LOCK prefix is allowed only with some instructions */
3015         if (c->lock_prefix && (!(c->d & Lock) || c->dst.type != OP_MEM)) {
3016                 emulate_ud(ctxt);
3017                 goto done;
3018         }
3019
3020         if ((c->d & SrcMask) == SrcMemFAddr && c->src.type != OP_MEM) {
3021                 emulate_ud(ctxt);
3022                 goto done;
3023         }
3024
3025         /* Privileged instruction can be executed only in CPL=0 */
3026         if ((c->d & Priv) && ops->cpl(ctxt->vcpu)) {
3027                 emulate_gp(ctxt, 0);
3028                 goto done;
3029         }
3030
3031         if (c->rep_prefix && (c->d & String)) {
3032                 /* All REP prefixes have the same first termination condition */
3033                 if (address_mask(c, c->regs[VCPU_REGS_RCX]) == 0) {
3034                         ctxt->eip = c->eip;
3035                         goto done;
3036                 }
3037         }
3038
3039         if ((c->src.type == OP_MEM) && !(c->d & NoAccess)) {
3040                 rc = read_emulated(ctxt, ops, c->src.addr.mem,
3041                                         c->src.valptr, c->src.bytes);
3042                 if (rc != X86EMUL_CONTINUE)
3043                         goto done;
3044                 c->src.orig_val64 = c->src.val64;
3045         }
3046
3047         if (c->src2.type == OP_MEM) {
3048                 rc = read_emulated(ctxt, ops, c->src2.addr.mem,
3049                                         &c->src2.val, c->src2.bytes);
3050                 if (rc != X86EMUL_CONTINUE)
3051                         goto done;
3052         }
3053
3054         if ((c->d & DstMask) == ImplicitOps)
3055                 goto special_insn;
3056
3057
3058         if ((c->dst.type == OP_MEM) && !(c->d & Mov)) {
3059                 /* optimisation - avoid slow emulated read if Mov */
3060                 rc = read_emulated(ctxt, ops, c->dst.addr.mem,
3061                                    &c->dst.val, c->dst.bytes);
3062                 if (rc != X86EMUL_CONTINUE)
3063                         goto done;
3064         }
3065         c->dst.orig_val = c->dst.val;
3066
3067 special_insn:
3068
3069         if (c->execute) {
3070                 rc = c->execute(ctxt);
3071                 if (rc != X86EMUL_CONTINUE)
3072                         goto done;
3073                 goto writeback;
3074         }
3075
3076         if (c->twobyte)
3077                 goto twobyte_insn;
3078
3079         switch (c->b) {
3080         case 0x00 ... 0x05:
3081               add:              /* add */
3082                 emulate_2op_SrcV("add", c->src, c->dst, ctxt->eflags);
3083                 break;
3084         case 0x06:              /* push es */
3085                 emulate_push_sreg(ctxt, ops, VCPU_SREG_ES);
3086                 break;
3087         case 0x07:              /* pop es */
3088                 rc = emulate_pop_sreg(ctxt, ops, VCPU_SREG_ES);
3089                 if (rc != X86EMUL_CONTINUE)
3090                         goto done;
3091                 break;
3092         case 0x08 ... 0x0d:
3093               or:               /* or */
3094                 emulate_2op_SrcV("or", c->src, c->dst, ctxt->eflags);
3095                 break;
3096         case 0x0e:              /* push cs */
3097                 emulate_push_sreg(ctxt, ops, VCPU_SREG_CS);
3098                 break;
3099         case 0x10 ... 0x15:
3100               adc:              /* adc */
3101                 emulate_2op_SrcV("adc", c->src, c->dst, ctxt->eflags);
3102                 break;
3103         case 0x16:              /* push ss */
3104                 emulate_push_sreg(ctxt, ops, VCPU_SREG_SS);
3105                 break;
3106         case 0x17:              /* pop ss */
3107                 rc = emulate_pop_sreg(ctxt, ops, VCPU_SREG_SS);
3108                 if (rc != X86EMUL_CONTINUE)
3109                         goto done;
3110                 break;
3111         case 0x18 ... 0x1d:
3112               sbb:              /* sbb */
3113                 emulate_2op_SrcV("sbb", c->src, c->dst, ctxt->eflags);
3114                 break;
3115         case 0x1e:              /* push ds */
3116                 emulate_push_sreg(ctxt, ops, VCPU_SREG_DS);
3117                 break;
3118         case 0x1f:              /* pop ds */
3119                 rc = emulate_pop_sreg(ctxt, ops, VCPU_SREG_DS);
3120                 if (rc != X86EMUL_CONTINUE)
3121                         goto done;
3122                 break;
3123         case 0x20 ... 0x25:
3124               and:              /* and */
3125                 emulate_2op_SrcV("and", c->src, c->dst, ctxt->eflags);
3126                 break;
3127         case 0x28 ... 0x2d:
3128               sub:              /* sub */
3129                 emulate_2op_SrcV("sub", c->src, c->dst, ctxt->eflags);
3130                 break;
3131         case 0x30 ... 0x35:
3132               xor:              /* xor */
3133                 emulate_2op_SrcV("xor", c->src, c->dst, ctxt->eflags);
3134                 break;
3135         case 0x38 ... 0x3d:
3136               cmp:              /* cmp */
3137                 emulate_2op_SrcV("cmp", c->src, c->dst, ctxt->eflags);
3138                 break;
3139         case 0x40 ... 0x47: /* inc r16/r32 */
3140                 emulate_1op("inc", c->dst, ctxt->eflags);
3141                 break;
3142         case 0x48 ... 0x4f: /* dec r16/r32 */
3143                 emulate_1op("dec", c->dst, ctxt->eflags);
3144                 break;
3145         case 0x58 ... 0x5f: /* pop reg */
3146         pop_instruction:
3147                 rc = emulate_pop(ctxt, ops, &c->dst.val, c->op_bytes);
3148                 if (rc != X86EMUL_CONTINUE)
3149                         goto done;
3150                 break;
3151         case 0x60:      /* pusha */
3152                 rc = emulate_pusha(ctxt, ops);
3153                 if (rc != X86EMUL_CONTINUE)
3154                         goto done;
3155                 break;
3156         case 0x61:      /* popa */
3157                 rc = emulate_popa(ctxt, ops);
3158                 if (rc != X86EMUL_CONTINUE)
3159                         goto done;
3160                 break;
3161         case 0x63:              /* movsxd */
3162                 if (ctxt->mode != X86EMUL_MODE_PROT64)
3163                         goto cannot_emulate;
3164                 c->dst.val = (s32) c->src.val;
3165                 break;
3166         case 0x6c:              /* insb */
3167         case 0x6d:              /* insw/insd */
3168                 c->src.val = c->regs[VCPU_REGS_RDX];
3169                 goto do_io_in;
3170         case 0x6e:              /* outsb */
3171         case 0x6f:              /* outsw/outsd */
3172                 c->dst.val = c->regs[VCPU_REGS_RDX];
3173                 goto do_io_out;
3174                 break;
3175         case 0x70 ... 0x7f: /* jcc (short) */
3176                 if (test_cc(c->b, ctxt->eflags))
3177                         jmp_rel(c, c->src.val);
3178                 break;
3179         case 0x80 ... 0x83:     /* Grp1 */
3180                 switch (c->modrm_reg) {
3181                 case 0:
3182                         goto add;
3183                 case 1:
3184                         goto or;
3185                 case 2:
3186                         goto adc;
3187                 case 3:
3188                         goto sbb;
3189                 case 4:
3190                         goto and;
3191                 case 5:
3192                         goto sub;
3193                 case 6:
3194                         goto xor;
3195                 case 7:
3196                         goto cmp;
3197                 }
3198                 break;
3199         case 0x84 ... 0x85:
3200         test:
3201                 emulate_2op_SrcV("test", c->src, c->dst, ctxt->eflags);
3202                 break;
3203         case 0x86 ... 0x87:     /* xchg */
3204         xchg:
3205                 /* Write back the register source. */
3206                 c->src.val = c->dst.val;
3207                 write_register_operand(&c->src);
3208                 /*
3209                  * Write back the memory destination with implicit LOCK
3210                  * prefix.
3211                  */
3212                 c->dst.val = c->src.orig_val;
3213                 c->lock_prefix = 1;
3214                 break;
3215         case 0x88 ... 0x8b:     /* mov */
3216                 goto mov;
3217         case 0x8c:  /* mov r/m, sreg */
3218                 if (c->modrm_reg > VCPU_SREG_GS) {
3219                         emulate_ud(ctxt);
3220                         goto done;
3221                 }
3222                 c->dst.val = ops->get_segment_selector(c->modrm_reg, ctxt->vcpu);
3223                 break;
3224         case 0x8d: /* lea r16/r32, m */
3225                 c->dst.val = c->src.addr.mem;
3226                 break;
3227         case 0x8e: { /* mov seg, r/m16 */
3228                 uint16_t sel;
3229
3230                 sel = c->src.val;
3231
3232                 if (c->modrm_reg == VCPU_SREG_CS ||
3233                     c->modrm_reg > VCPU_SREG_GS) {
3234                         emulate_ud(ctxt);
3235                         goto done;
3236                 }
3237
3238                 if (c->modrm_reg == VCPU_SREG_SS)
3239                         ctxt->interruptibility = KVM_X86_SHADOW_INT_MOV_SS;
3240
3241                 rc = load_segment_descriptor(ctxt, ops, sel, c->modrm_reg);
3242
3243                 c->dst.type = OP_NONE;  /* Disable writeback. */
3244                 break;
3245         }
3246         case 0x8f:              /* pop (sole member of Grp1a) */
3247                 rc = emulate_grp1a(ctxt, ops);
3248                 if (rc != X86EMUL_CONTINUE)
3249                         goto done;
3250                 break;
3251         case 0x90 ... 0x97: /* nop / xchg reg, rax */
3252                 if (c->dst.addr.reg == &c->regs[VCPU_REGS_RAX])
3253                         break;
3254                 goto xchg;
3255         case 0x98: /* cbw/cwde/cdqe */
3256                 switch (c->op_bytes) {
3257                 case 2: c->dst.val = (s8)c->dst.val; break;
3258                 case 4: c->dst.val = (s16)c->dst.val; break;
3259                 case 8: c->dst.val = (s32)c->dst.val; break;
3260                 }
3261                 break;
3262         case 0x9c: /* pushf */
3263                 c->src.val =  (unsigned long) ctxt->eflags;
3264                 emulate_push(ctxt, ops);
3265                 break;
3266         case 0x9d: /* popf */
3267                 c->dst.type = OP_REG;
3268                 c->dst.addr.reg = &ctxt->eflags;
3269                 c->dst.bytes = c->op_bytes;
3270                 rc = emulate_popf(ctxt, ops, &c->dst.val, c->op_bytes);
3271                 if (rc != X86EMUL_CONTINUE)
3272                         goto done;
3273                 break;
3274         case 0xa0 ... 0xa3:     /* mov */
3275         case 0xa4 ... 0xa5:     /* movs */
3276                 goto mov;
3277         case 0xa6 ... 0xa7:     /* cmps */
3278                 c->dst.type = OP_NONE; /* Disable writeback. */
3279                 DPRINTF("cmps: mem1=0x%p mem2=0x%p\n", c->src.addr.mem, c->dst.addr.mem);
3280                 goto cmp;
3281         case 0xa8 ... 0xa9:     /* test ax, imm */
3282                 goto test;
3283         case 0xaa ... 0xab:     /* stos */
3284         case 0xac ... 0xad:     /* lods */
3285                 goto mov;
3286         case 0xae ... 0xaf:     /* scas */
3287                 goto cmp;
3288         case 0xb0 ... 0xbf: /* mov r, imm */
3289                 goto mov;
3290         case 0xc0 ... 0xc1:
3291                 emulate_grp2(ctxt);
3292                 break;
3293         case 0xc3: /* ret */
3294                 c->dst.type = OP_REG;
3295                 c->dst.addr.reg = &c->eip;
3296                 c->dst.bytes = c->op_bytes;
3297                 goto pop_instruction;
3298         case 0xc4:              /* les */
3299                 rc = emulate_load_segment(ctxt, ops, VCPU_SREG_ES);
3300                 if (rc != X86EMUL_CONTINUE)
3301                         goto done;
3302                 break;
3303         case 0xc5:              /* lds */
3304                 rc = emulate_load_segment(ctxt, ops, VCPU_SREG_DS);
3305                 if (rc != X86EMUL_CONTINUE)
3306                         goto done;
3307                 break;
3308         case 0xc6 ... 0xc7:     /* mov (sole member of Grp11) */
3309         mov:
3310                 c->dst.val = c->src.val;
3311                 break;
3312         case 0xcb:              /* ret far */
3313                 rc = emulate_ret_far(ctxt, ops);
3314                 if (rc != X86EMUL_CONTINUE)
3315                         goto done;
3316                 break;
3317         case 0xcc:              /* int3 */
3318                 irq = 3;
3319                 goto do_interrupt;
3320         case 0xcd:              /* int n */
3321                 irq = c->src.val;
3322         do_interrupt:
3323                 rc = emulate_int(ctxt, ops, irq);
3324                 if (rc != X86EMUL_CONTINUE)
3325                         goto done;
3326                 break;
3327         case 0xce:              /* into */
3328                 if (ctxt->eflags & EFLG_OF) {
3329                         irq = 4;
3330                         goto do_interrupt;
3331                 }
3332                 break;
3333         case 0xcf:              /* iret */
3334                 rc = emulate_iret(ctxt, ops);
3335
3336                 if (rc != X86EMUL_CONTINUE)
3337                         goto done;
3338                 break;
3339         case 0xd0 ... 0xd1:     /* Grp2 */
3340                 emulate_grp2(ctxt);
3341                 break;
3342         case 0xd2 ... 0xd3:     /* Grp2 */
3343                 c->src.val = c->regs[VCPU_REGS_RCX];
3344                 emulate_grp2(ctxt);
3345                 break;
3346         case 0xe0 ... 0xe2:     /* loop/loopz/loopnz */
3347                 register_address_increment(c, &c->regs[VCPU_REGS_RCX], -1);
3348                 if (address_mask(c, c->regs[VCPU_REGS_RCX]) != 0 &&
3349                     (c->b == 0xe2 || test_cc(c->b ^ 0x5, ctxt->eflags)))
3350                         jmp_rel(c, c->src.val);
3351                 break;
3352         case 0xe3:      /* jcxz/jecxz/jrcxz */
3353                 if (address_mask(c, c->regs[VCPU_REGS_RCX]) == 0)
3354                         jmp_rel(c, c->src.val);
3355                 break;
3356         case 0xe4:      /* inb */
3357         case 0xe5:      /* in */
3358                 goto do_io_in;
3359         case 0xe6: /* outb */
3360         case 0xe7: /* out */
3361                 goto do_io_out;
3362         case 0xe8: /* call (near) */ {
3363                 long int rel = c->src.val;
3364                 c->src.val = (unsigned long) c->eip;
3365                 jmp_rel(c, rel);
3366                 emulate_push(ctxt, ops);
3367                 break;
3368         }
3369         case 0xe9: /* jmp rel */
3370                 goto jmp;
3371         case 0xea: { /* jmp far */
3372                 unsigned short sel;
3373         jump_far:
3374                 memcpy(&sel, c->src.valptr + c->op_bytes, 2);
3375
3376                 if (load_segment_descriptor(ctxt, ops, sel, VCPU_SREG_CS))
3377                         goto done;
3378
3379                 c->eip = 0;
3380                 memcpy(&c->eip, c->src.valptr, c->op_bytes);
3381                 break;
3382         }
3383         case 0xeb:
3384               jmp:              /* jmp rel short */
3385                 jmp_rel(c, c->src.val);
3386                 c->dst.type = OP_NONE; /* Disable writeback. */
3387                 break;
3388         case 0xec: /* in al,dx */
3389         case 0xed: /* in (e/r)ax,dx */
3390                 c->src.val = c->regs[VCPU_REGS_RDX];
3391         do_io_in:
3392                 c->dst.bytes = min(c->dst.bytes, 4u);
3393                 if (!emulator_io_permited(ctxt, ops, c->src.val, c->dst.bytes)) {
3394                         emulate_gp(ctxt, 0);
3395                         goto done;
3396                 }
3397                 if (!pio_in_emulated(ctxt, ops, c->dst.bytes, c->src.val,
3398                                      &c->dst.val))
3399                         goto done; /* IO is needed */
3400                 break;
3401         case 0xee: /* out dx,al */
3402         case 0xef: /* out dx,(e/r)ax */
3403                 c->dst.val = c->regs[VCPU_REGS_RDX];
3404         do_io_out:
3405                 c->src.bytes = min(c->src.bytes, 4u);
3406                 if (!emulator_io_permited(ctxt, ops, c->dst.val,
3407                                           c->src.bytes)) {
3408                         emulate_gp(ctxt, 0);
3409                         goto done;
3410                 }
3411                 ops->pio_out_emulated(c->src.bytes, c->dst.val,
3412                                       &c->src.val, 1, ctxt->vcpu);
3413                 c->dst.type = OP_NONE;  /* Disable writeback. */
3414                 break;
3415         case 0xf4:              /* hlt */
3416                 ctxt->vcpu->arch.halt_request = 1;
3417                 break;
3418         case 0xf5:      /* cmc */
3419                 /* complement carry flag from eflags reg */
3420                 ctxt->eflags ^= EFLG_CF;
3421                 break;
3422         case 0xf6 ... 0xf7:     /* Grp3 */
3423                 rc = emulate_grp3(ctxt, ops);
3424                 if (rc != X86EMUL_CONTINUE)
3425                         goto done;
3426                 break;
3427         case 0xf8: /* clc */
3428                 ctxt->eflags &= ~EFLG_CF;
3429                 break;
3430         case 0xf9: /* stc */
3431                 ctxt->eflags |= EFLG_CF;
3432                 break;
3433         case 0xfa: /* cli */
3434                 if (emulator_bad_iopl(ctxt, ops)) {
3435                         emulate_gp(ctxt, 0);
3436                         goto done;
3437                 } else
3438                         ctxt->eflags &= ~X86_EFLAGS_IF;
3439                 break;
3440         case 0xfb: /* sti */
3441                 if (emulator_bad_iopl(ctxt, ops)) {
3442                         emulate_gp(ctxt, 0);
3443                         goto done;
3444                 } else {
3445                         ctxt->interruptibility = KVM_X86_SHADOW_INT_STI;
3446                         ctxt->eflags |= X86_EFLAGS_IF;
3447                 }
3448                 break;
3449         case 0xfc: /* cld */
3450                 ctxt->eflags &= ~EFLG_DF;
3451                 break;
3452         case 0xfd: /* std */
3453                 ctxt->eflags |= EFLG_DF;
3454                 break;
3455         case 0xfe: /* Grp4 */
3456         grp45:
3457                 rc = emulate_grp45(ctxt, ops);
3458                 if (rc != X86EMUL_CONTINUE)
3459                         goto done;
3460                 break;
3461         case 0xff: /* Grp5 */
3462                 if (c->modrm_reg == 5)
3463                         goto jump_far;
3464                 goto grp45;
3465         default:
3466                 goto cannot_emulate;
3467         }
3468
3469 writeback:
3470         rc = writeback(ctxt, ops);
3471         if (rc != X86EMUL_CONTINUE)
3472                 goto done;
3473
3474         /*
3475          * restore dst type in case the decoding will be reused
3476          * (happens for string instruction )
3477          */
3478         c->dst.type = saved_dst_type;
3479
3480         if ((c->d & SrcMask) == SrcSI)
3481                 string_addr_inc(ctxt, seg_override_base(ctxt, ops, c),
3482                                 VCPU_REGS_RSI, &c->src);
3483
3484         if ((c->d & DstMask) == DstDI)
3485                 string_addr_inc(ctxt, es_base(ctxt, ops), VCPU_REGS_RDI,
3486                                 &c->dst);
3487
3488         if (c->rep_prefix && (c->d & String)) {
3489                 struct read_cache *r = &ctxt->decode.io_read;
3490                 register_address_increment(c, &c->regs[VCPU_REGS_RCX], -1);
3491
3492                 if (!string_insn_completed(ctxt)) {
3493                         /*
3494                          * Re-enter guest when pio read ahead buffer is empty
3495                          * or, if it is not used, after each 1024 iteration.
3496                          */
3497                         if ((r->end != 0 || c->regs[VCPU_REGS_RCX] & 0x3ff) &&
3498                             (r->end == 0 || r->end != r->pos)) {
3499                                 /*
3500                                  * Reset read cache. Usually happens before
3501                                  * decode, but since instruction is restarted
3502                                  * we have to do it here.
3503                                  */
3504                                 ctxt->decode.mem_read.end = 0;
3505                                 return EMULATION_RESTART;
3506                         }
3507                         goto done; /* skip rip writeback */
3508                 }
3509         }
3510
3511         ctxt->eip = c->eip;
3512
3513 done:
3514         return (rc == X86EMUL_UNHANDLEABLE) ? EMULATION_FAILED : EMULATION_OK;
3515
3516 twobyte_insn:
3517         switch (c->b) {
3518         case 0x01: /* lgdt, lidt, lmsw */
3519                 switch (c->modrm_reg) {
3520                         u16 size;
3521                         unsigned long address;
3522
3523                 case 0: /* vmcall */
3524                         if (c->modrm_mod != 3 || c->modrm_rm != 1)
3525                                 goto cannot_emulate;
3526
3527                         rc = kvm_fix_hypercall(ctxt->vcpu);
3528                         if (rc != X86EMUL_CONTINUE)
3529                                 goto done;
3530
3531                         /* Let the processor re-execute the fixed hypercall */
3532                         c->eip = ctxt->eip;
3533                         /* Disable writeback. */
3534                         c->dst.type = OP_NONE;
3535                         break;
3536                 case 2: /* lgdt */
3537                         rc = read_descriptor(ctxt, ops, c->src.addr.mem,
3538                                              &size, &address, c->op_bytes);
3539                         if (rc != X86EMUL_CONTINUE)
3540                                 goto done;
3541                         realmode_lgdt(ctxt->vcpu, size, address);
3542                         /* Disable writeback. */
3543                         c->dst.type = OP_NONE;
3544                         break;
3545                 case 3: /* lidt/vmmcall */
3546                         if (c->modrm_mod == 3) {
3547                                 switch (c->modrm_rm) {
3548                                 case 1:
3549                                         rc = kvm_fix_hypercall(ctxt->vcpu);
3550                                         if (rc != X86EMUL_CONTINUE)
3551                                                 goto done;
3552                                         break;
3553                                 default:
3554                                         goto cannot_emulate;
3555                                 }
3556                         } else {
3557                                 rc = read_descriptor(ctxt, ops, c->src.addr.mem,
3558                                                      &size, &address,
3559                                                      c->op_bytes);
3560                                 if (rc != X86EMUL_CONTINUE)
3561                                         goto done;
3562                                 realmode_lidt(ctxt->vcpu, size, address);
3563                         }
3564                         /* Disable writeback. */
3565                         c->dst.type = OP_NONE;
3566                         break;
3567                 case 4: /* smsw */
3568                         c->dst.bytes = 2;
3569                         c->dst.val = ops->get_cr(0, ctxt->vcpu);
3570                         break;
3571                 case 6: /* lmsw */
3572                         ops->set_cr(0, (ops->get_cr(0, ctxt->vcpu) & ~0x0eul) |
3573                                     (c->src.val & 0x0f), ctxt->vcpu);
3574                         c->dst.type = OP_NONE;
3575                         break;
3576                 case 5: /* not defined */
3577                         emulate_ud(ctxt);
3578                         goto done;
3579                 case 7: /* invlpg*/
3580                         emulate_invlpg(ctxt->vcpu, c->src.addr.mem);
3581                         /* Disable writeback. */
3582                         c->dst.type = OP_NONE;
3583                         break;
3584                 default:
3585                         goto cannot_emulate;
3586                 }
3587                 break;
3588         case 0x05:              /* syscall */
3589                 rc = emulate_syscall(ctxt, ops);
3590                 if (rc != X86EMUL_CONTINUE)
3591                         goto done;
3592                 else
3593                         goto writeback;
3594                 break;
3595         case 0x06:
3596                 emulate_clts(ctxt->vcpu);
3597                 break;
3598         case 0x09:              /* wbinvd */
3599                 kvm_emulate_wbinvd(ctxt->vcpu);
3600                 break;
3601         case 0x08:              /* invd */
3602         case 0x0d:              /* GrpP (prefetch) */
3603         case 0x18:              /* Grp16 (prefetch/nop) */
3604                 break;
3605         case 0x20: /* mov cr, reg */
3606                 switch (c->modrm_reg) {
3607                 case 1:
3608                 case 5 ... 7:
3609                 case 9 ... 15:
3610                         emulate_ud(ctxt);
3611                         goto done;
3612                 }
3613                 c->dst.val = ops->get_cr(c->modrm_reg, ctxt->vcpu);
3614                 break;
3615         case 0x21: /* mov from dr to reg */
3616                 if ((ops->get_cr(4, ctxt->vcpu) & X86_CR4_DE) &&
3617                     (c->modrm_reg == 4 || c->modrm_reg == 5)) {
3618                         emulate_ud(ctxt);
3619                         goto done;
3620                 }
3621                 ops->get_dr(c->modrm_reg, &c->dst.val, ctxt->vcpu);
3622                 break;
3623         case 0x22: /* mov reg, cr */
3624                 if (ops->set_cr(c->modrm_reg, c->src.val, ctxt->vcpu)) {
3625                         emulate_gp(ctxt, 0);
3626                         goto done;
3627                 }
3628                 c->dst.type = OP_NONE;
3629                 break;
3630         case 0x23: /* mov from reg to dr */
3631                 if ((ops->get_cr(4, ctxt->vcpu) & X86_CR4_DE) &&
3632                     (c->modrm_reg == 4 || c->modrm_reg == 5)) {
3633                         emulate_ud(ctxt);
3634                         goto done;
3635                 }
3636
3637                 if (ops->set_dr(c->modrm_reg, c->src.val &
3638                                 ((ctxt->mode == X86EMUL_MODE_PROT64) ?
3639                                  ~0ULL : ~0U), ctxt->vcpu) < 0) {
3640                         /* #UD condition is already handled by the code above */
3641                         emulate_gp(ctxt, 0);
3642                         goto done;
3643                 }
3644
3645                 c->dst.type = OP_NONE;  /* no writeback */
3646                 break;
3647         case 0x30:
3648                 /* wrmsr */
3649                 msr_data = (u32)c->regs[VCPU_REGS_RAX]
3650                         | ((u64)c->regs[VCPU_REGS_RDX] << 32);
3651                 if (ops->set_msr(ctxt->vcpu, c->regs[VCPU_REGS_RCX], msr_data)) {
3652                         emulate_gp(ctxt, 0);
3653                         goto done;
3654                 }
3655                 rc = X86EMUL_CONTINUE;
3656                 break;
3657         case 0x32:
3658                 /* rdmsr */
3659                 if (ops->get_msr(ctxt->vcpu, c->regs[VCPU_REGS_RCX], &msr_data)) {
3660                         emulate_gp(ctxt, 0);
3661                         goto done;
3662                 } else {
3663                         c->regs[VCPU_REGS_RAX] = (u32)msr_data;
3664                         c->regs[VCPU_REGS_RDX] = msr_data >> 32;
3665                 }
3666                 rc = X86EMUL_CONTINUE;
3667                 break;
3668         case 0x34:              /* sysenter */
3669                 rc = emulate_sysenter(ctxt, ops);
3670                 if (rc != X86EMUL_CONTINUE)
3671                         goto done;
3672                 else
3673                         goto writeback;
3674                 break;
3675         case 0x35:              /* sysexit */
3676                 rc = emulate_sysexit(ctxt, ops);
3677                 if (rc != X86EMUL_CONTINUE)
3678                         goto done;
3679                 else
3680                         goto writeback;
3681                 break;
3682         case 0x40 ... 0x4f:     /* cmov */
3683                 c->dst.val = c->dst.orig_val = c->src.val;
3684                 if (!test_cc(c->b, ctxt->eflags))
3685                         c->dst.type = OP_NONE; /* no writeback */
3686                 break;
3687         case 0x80 ... 0x8f: /* jnz rel, etc*/
3688                 if (test_cc(c->b, ctxt->eflags))
3689                         jmp_rel(c, c->src.val);
3690                 break;
3691         case 0x90 ... 0x9f:     /* setcc r/m8 */
3692                 c->dst.val = test_cc(c->b, ctxt->eflags);
3693                 break;
3694         case 0xa0:        /* push fs */
3695                 emulate_push_sreg(ctxt, ops, VCPU_SREG_FS);
3696                 break;
3697         case 0xa1:       /* pop fs */
3698                 rc = emulate_pop_sreg(ctxt, ops, VCPU_SREG_FS);
3699                 if (rc != X86EMUL_CONTINUE)
3700                         goto done;
3701                 break;
3702         case 0xa3:
3703               bt:               /* bt */
3704                 c->dst.type = OP_NONE;
3705                 /* only subword offset */
3706                 c->src.val &= (c->dst.bytes << 3) - 1;
3707                 emulate_2op_SrcV_nobyte("bt", c->src, c->dst, ctxt->eflags);
3708                 break;
3709         case 0xa4: /* shld imm8, r, r/m */
3710         case 0xa5: /* shld cl, r, r/m */
3711                 emulate_2op_cl("shld", c->src2, c->src, c->dst, ctxt->eflags);
3712                 break;
3713         case 0xa8:      /* push gs */
3714                 emulate_push_sreg(ctxt, ops, VCPU_SREG_GS);
3715                 break;
3716         case 0xa9:      /* pop gs */
3717                 rc = emulate_pop_sreg(ctxt, ops, VCPU_SREG_GS);
3718                 if (rc != X86EMUL_CONTINUE)
3719                         goto done;
3720                 break;
3721         case 0xab:
3722               bts:              /* bts */
3723                 emulate_2op_SrcV_nobyte("bts", c->src, c->dst, ctxt->eflags);
3724                 break;
3725         case 0xac: /* shrd imm8, r, r/m */
3726         case 0xad: /* shrd cl, r, r/m */
3727                 emulate_2op_cl("shrd", c->src2, c->src, c->dst, ctxt->eflags);
3728                 break;
3729         case 0xae:              /* clflush */
3730                 break;
3731         case 0xb0 ... 0xb1:     /* cmpxchg */
3732                 /*
3733                  * Save real source value, then compare EAX against
3734                  * destination.
3735                  */
3736                 c->src.orig_val = c->src.val;
3737                 c->src.val = c->regs[VCPU_REGS_RAX];
3738                 emulate_2op_SrcV("cmp", c->src, c->dst, ctxt->eflags);
3739                 if (ctxt->eflags & EFLG_ZF) {
3740                         /* Success: write back to memory. */
3741                         c->dst.val = c->src.orig_val;
3742                 } else {
3743                         /* Failure: write the value we saw to EAX. */
3744                         c->dst.type = OP_REG;
3745                         c->dst.addr.reg = (unsigned long *)&c->regs[VCPU_REGS_RAX];
3746                 }
3747                 break;
3748         case 0xb2:              /* lss */
3749                 rc = emulate_load_segment(ctxt, ops, VCPU_SREG_SS);
3750                 if (rc != X86EMUL_CONTINUE)
3751                         goto done;
3752                 break;
3753         case 0xb3:
3754               btr:              /* btr */
3755                 emulate_2op_SrcV_nobyte("btr", c->src, c->dst, ctxt->eflags);
3756                 break;
3757         case 0xb4:              /* lfs */
3758                 rc = emulate_load_segment(ctxt, ops, VCPU_SREG_FS);
3759                 if (rc != X86EMUL_CONTINUE)
3760                         goto done;
3761                 break;
3762         case 0xb5:              /* lgs */
3763                 rc = emulate_load_segment(ctxt, ops, VCPU_SREG_GS);
3764                 if (rc != X86EMUL_CONTINUE)
3765                         goto done;
3766                 break;
3767         case 0xb6 ... 0xb7:     /* movzx */
3768                 c->dst.bytes = c->op_bytes;
3769                 c->dst.val = (c->d & ByteOp) ? (u8) c->src.val
3770                                                        : (u16) c->src.val;
3771                 break;
3772         case 0xba:              /* Grp8 */
3773                 switch (c->modrm_reg & 3) {
3774                 case 0:
3775                         goto bt;
3776                 case 1:
3777                         goto bts;
3778                 case 2:
3779                         goto btr;
3780                 case 3:
3781                         goto btc;
3782                 }
3783                 break;
3784         case 0xbb:
3785               btc:              /* btc */
3786                 emulate_2op_SrcV_nobyte("btc", c->src, c->dst, ctxt->eflags);
3787                 break;
3788         case 0xbc: {            /* bsf */
3789                 u8 zf;
3790                 __asm__ ("bsf %2, %0; setz %1"
3791                          : "=r"(c->dst.val), "=q"(zf)
3792                          : "r"(c->src.val));
3793                 ctxt->eflags &= ~X86_EFLAGS_ZF;
3794                 if (zf) {
3795                         ctxt->eflags |= X86_EFLAGS_ZF;
3796                         c->dst.type = OP_NONE;  /* Disable writeback. */
3797                 }
3798                 break;
3799         }
3800         case 0xbd: {            /* bsr */
3801                 u8 zf;
3802                 __asm__ ("bsr %2, %0; setz %1"
3803                          : "=r"(c->dst.val), "=q"(zf)
3804                          : "r"(c->src.val));
3805                 ctxt->eflags &= ~X86_EFLAGS_ZF;
3806                 if (zf) {
3807                         ctxt->eflags |= X86_EFLAGS_ZF;
3808                         c->dst.type = OP_NONE;  /* Disable writeback. */
3809                 }
3810                 break;
3811         }
3812         case 0xbe ... 0xbf:     /* movsx */
3813                 c->dst.bytes = c->op_bytes;
3814                 c->dst.val = (c->d & ByteOp) ? (s8) c->src.val :
3815                                                         (s16) c->src.val;
3816                 break;
3817         case 0xc0 ... 0xc1:     /* xadd */
3818                 emulate_2op_SrcV("add", c->src, c->dst, ctxt->eflags);
3819                 /* Write back the register source. */
3820                 c->src.val = c->dst.orig_val;
3821                 write_register_operand(&c->src);
3822                 break;
3823         case 0xc3:              /* movnti */
3824                 c->dst.bytes = c->op_bytes;
3825                 c->dst.val = (c->op_bytes == 4) ? (u32) c->src.val :
3826                                                         (u64) c->src.val;
3827                 break;
3828         case 0xc7:              /* Grp9 (cmpxchg8b) */
3829                 rc = emulate_grp9(ctxt, ops);
3830                 if (rc != X86EMUL_CONTINUE)
3831                         goto done;
3832                 break;
3833         default:
3834                 goto cannot_emulate;
3835         }
3836         goto writeback;
3837
3838 cannot_emulate:
3839         DPRINTF("Cannot emulate %02x\n", c->b);
3840         return -1;
3841 }