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