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