arch/powerpc/kvm/emulate_loadstore.c

   1 /*
   2  * This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License, version 2, as
   4  * published by the Free Software Foundation.
   5  *
   6  * This program is distributed in the hope that it will be useful,
   7  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   8  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9  * GNU General Public License for more details.
  10  *
  11  * You should have received a copy of the GNU General Public License
  12  * along with this program; if not, write to the Free Software
  13  * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  14  *
  15  * Copyright IBM Corp. 2007
  16  * Copyright 2011 Freescale Semiconductor, Inc.
  17  *
  18  * Authors: Hollis Blanchard <hollisb@us.ibm.com>
  19  */
  20
  21 #include <linux/jiffies.h>
  22 #include <linux/hrtimer.h>
  23 #include <linux/types.h>
  24 #include <linux/string.h>
  25 #include <linux/kvm_host.h>
  26 #include <linux/clockchips.h>
  27
  28 #include <asm/reg.h>
  29 #include <asm/time.h>
  30 #include <asm/byteorder.h>
  31 #include <asm/kvm_ppc.h>
  32 #include <asm/disassemble.h>
  33 #include <asm/ppc-opcode.h>
  34 #include "timing.h"
  35 #include "trace.h"
  36
  37 #ifdef CONFIG_PPC_FPU
  38 static bool kvmppc_check_fp_disabled(struct kvm_vcpu *vcpu)
  39 {
  40         if (!(kvmppc_get_msr(vcpu) & MSR_FP)) {
  41                 kvmppc_core_queue_fpunavail(vcpu);
  42                 return true;
  43         }
  44
  45         return false;
  46 }
  47 #endif /* CONFIG_PPC_FPU */
  48
  49 #ifdef CONFIG_VSX
  50 static bool kvmppc_check_vsx_disabled(struct kvm_vcpu *vcpu)
  51 {
  52         if (!(kvmppc_get_msr(vcpu) & MSR_VSX)) {
  53                 kvmppc_core_queue_vsx_unavail(vcpu);
  54                 return true;
  55         }
  56
  57         return false;
  58 }
  59 #endif /* CONFIG_VSX */
  60
  61 /*
  62  * XXX to do:
  63  * lfiwax, lfiwzx
  64  * vector loads and stores
  65  *
  66  * Instructions that trap when used on cache-inhibited mappings
  67  * are not emulated here: multiple and string instructions,
  68  * lq/stq, and the load-reserve/store-conditional instructions.
  69  */
  70 int kvmppc_emulate_loadstore(struct kvm_vcpu *vcpu)
  71 {
  72         struct kvm_run *run = vcpu->run;
  73         u32 inst;
  74         int ra, rs, rt;
  75         enum emulation_result emulated;
  76         int advance = 1;
  77
  78         /* this default type might be overwritten by subcategories */
  79         kvmppc_set_exit_type(vcpu, EMULATED_INST_EXITS);
  80
  81         emulated = kvmppc_get_last_inst(vcpu, INST_GENERIC, &inst);
  82         if (emulated != EMULATE_DONE)
  83                 return emulated;
  84
  85         ra = get_ra(inst);
  86         rs = get_rs(inst);
  87         rt = get_rt(inst);
  88
  89         /*
  90          * if mmio_vsx_tx_sx_enabled == 0, copy data between
  91          * VSR[0..31] and memory
  92          * if mmio_vsx_tx_sx_enabled == 1, copy data between
  93          * VSR[32..63] and memory
  94          */
  95         vcpu->arch.mmio_vsx_tx_sx_enabled = get_tx_or_sx(inst);
  96         vcpu->arch.mmio_vsx_copy_nums = 0;
  97         vcpu->arch.mmio_vsx_offset = 0;
  98         vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_NONE;
  99         vcpu->arch.mmio_sp64_extend = 0;
 100         vcpu->arch.mmio_sign_extend = 0;
 101
 102         switch (get_op(inst)) {
 103         case 31:
 104                 switch (get_xop(inst)) {
 105                 case OP_31_XOP_LWZX:
 106                         emulated = kvmppc_handle_load(run, vcpu, rt, 4, 1);
 107                         break;
 108
 109                 case OP_31_XOP_LWZUX:
 110                         emulated = kvmppc_handle_load(run, vcpu, rt, 4, 1);
 111                         kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 112                         break;
 113
 114                 case OP_31_XOP_LBZX:
 115                         emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1);
 116                         break;
 117
 118                 case OP_31_XOP_LBZUX:
 119                         emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1);
 120                         kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 121                         break;
 122
 123                 case OP_31_XOP_STDX:
 124                         emulated = kvmppc_handle_store(run, vcpu,
 125                                         kvmppc_get_gpr(vcpu, rs), 8, 1);
 126                         break;
 127
 128                 case OP_31_XOP_STDUX:
 129                         emulated = kvmppc_handle_store(run, vcpu,
 130                                         kvmppc_get_gpr(vcpu, rs), 8, 1);
 131                         kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 132                         break;
 133
 134                 case OP_31_XOP_STWX:
 135                         emulated = kvmppc_handle_store(run, vcpu,
 136                                         kvmppc_get_gpr(vcpu, rs), 4, 1);
 137                         break;
 138
 139                 case OP_31_XOP_STWUX:
 140                         emulated = kvmppc_handle_store(run, vcpu,
 141                                         kvmppc_get_gpr(vcpu, rs), 4, 1);
 142                         kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 143                         break;
 144
 145                 case OP_31_XOP_STBX:
 146                         emulated = kvmppc_handle_store(run, vcpu,
 147                                         kvmppc_get_gpr(vcpu, rs), 1, 1);
 148                         break;
 149
 150                 case OP_31_XOP_STBUX:
 151                         emulated = kvmppc_handle_store(run, vcpu,
 152                                         kvmppc_get_gpr(vcpu, rs), 1, 1);
 153                         kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 154                         break;
 155
 156                 case OP_31_XOP_LHAX:
 157                         emulated = kvmppc_handle_loads(run, vcpu, rt, 2, 1);
 158                         break;
 159
 160                 case OP_31_XOP_LHAUX:
 161                         emulated = kvmppc_handle_loads(run, vcpu, rt, 2, 1);
 162                         kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 163                         break;
 164
 165                 case OP_31_XOP_LHZX:
 166                         emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1);
 167                         break;
 168
 169                 case OP_31_XOP_LHZUX:
 170                         emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1);
 171                         kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 172                         break;
 173
 174                 case OP_31_XOP_STHX:
 175                         emulated = kvmppc_handle_store(run, vcpu,
 176                                         kvmppc_get_gpr(vcpu, rs), 2, 1);
 177                         break;
 178
 179                 case OP_31_XOP_STHUX:
 180                         emulated = kvmppc_handle_store(run, vcpu,
 181                                         kvmppc_get_gpr(vcpu, rs), 2, 1);
 182                         kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 183                         break;
 184
 185                 case OP_31_XOP_DCBST:
 186                 case OP_31_XOP_DCBF:
 187                 case OP_31_XOP_DCBI:
 188                         /* Do nothing. The guest is performing dcbi because
 189                          * hardware DMA is not snooped by the dcache, but
 190                          * emulated DMA either goes through the dcache as
 191                          * normal writes, or the host kernel has handled dcache
 192                          * coherence. */
 193                         break;
 194
 195                 case OP_31_XOP_LWBRX:
 196                         emulated = kvmppc_handle_load(run, vcpu, rt, 4, 0);
 197                         break;
 198
 199                 case OP_31_XOP_STWBRX:
 200                         emulated = kvmppc_handle_store(run, vcpu,
 201                                         kvmppc_get_gpr(vcpu, rs), 4, 0);
 202                         break;
 203
 204                 case OP_31_XOP_LHBRX:
 205                         emulated = kvmppc_handle_load(run, vcpu, rt, 2, 0);
 206                         break;
 207
 208                 case OP_31_XOP_STHBRX:
 209                         emulated = kvmppc_handle_store(run, vcpu,
 210                                         kvmppc_get_gpr(vcpu, rs), 2, 0);
 211                         break;
 212
 213                 case OP_31_XOP_LDBRX:
 214                         emulated = kvmppc_handle_load(run, vcpu, rt, 8, 0);
 215                         break;
 216
 217                 case OP_31_XOP_STDBRX:
 218                         emulated = kvmppc_handle_store(run, vcpu,
 219                                         kvmppc_get_gpr(vcpu, rs), 8, 0);
 220                         break;
 221
 222                 case OP_31_XOP_LDX:
 223                         emulated = kvmppc_handle_load(run, vcpu, rt, 8, 1);
 224                         break;
 225
 226                 case OP_31_XOP_LDUX:
 227                         emulated = kvmppc_handle_load(run, vcpu, rt, 8, 1);
 228                         kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 229                         break;
 230
 231                 case OP_31_XOP_LWAX:
 232                         emulated = kvmppc_handle_loads(run, vcpu, rt, 4, 1);
 233                         break;
 234
 235                 case OP_31_XOP_LWAUX:
 236                         emulated = kvmppc_handle_loads(run, vcpu, rt, 4, 1);
 237                         kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 238                         break;
 239
 240 #ifdef CONFIG_PPC_FPU
 241                 case OP_31_XOP_LFSX:
 242                         if (kvmppc_check_fp_disabled(vcpu))
 243                                 return EMULATE_DONE;
 244                         vcpu->arch.mmio_sp64_extend = 1;
 245                         emulated = kvmppc_handle_load(run, vcpu,
 246                                 KVM_MMIO_REG_FPR|rt, 4, 1);
 247                         break;
 248
 249                 case OP_31_XOP_LFSUX:
 250                         if (kvmppc_check_fp_disabled(vcpu))
 251                                 return EMULATE_DONE;
 252                         vcpu->arch.mmio_sp64_extend = 1;
 253                         emulated = kvmppc_handle_load(run, vcpu,
 254                                 KVM_MMIO_REG_FPR|rt, 4, 1);
 255                         kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 256                         break;
 257
 258                 case OP_31_XOP_LFDX:
 259                         if (kvmppc_check_fp_disabled(vcpu))
 260                                 return EMULATE_DONE;
 261                         emulated = kvmppc_handle_load(run, vcpu,
 262                                 KVM_MMIO_REG_FPR|rt, 8, 1);
 263                         break;
 264
 265                 case OP_31_XOP_LFDUX:
 266                         if (kvmppc_check_fp_disabled(vcpu))
 267                                 return EMULATE_DONE;
 268                         emulated = kvmppc_handle_load(run, vcpu,
 269                                 KVM_MMIO_REG_FPR|rt, 8, 1);
 270                         kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 271                         break;
 272
 273                 case OP_31_XOP_LFIWAX:
 274                         if (kvmppc_check_fp_disabled(vcpu))
 275                                 return EMULATE_DONE;
 276                         emulated = kvmppc_handle_loads(run, vcpu,
 277                                 KVM_MMIO_REG_FPR|rt, 4, 1);
 278                         break;
 279
 280                 case OP_31_XOP_LFIWZX:
 281                         if (kvmppc_check_fp_disabled(vcpu))
 282                                 return EMULATE_DONE;
 283                         emulated = kvmppc_handle_load(run, vcpu,
 284                                 KVM_MMIO_REG_FPR|rt, 4, 1);
 285                         break;
 286
 287                 case OP_31_XOP_STFSX:
 288                         if (kvmppc_check_fp_disabled(vcpu))
 289                                 return EMULATE_DONE;
 290                         vcpu->arch.mmio_sp64_extend = 1;
 291                         emulated = kvmppc_handle_store(run, vcpu,
 292                                 VCPU_FPR(vcpu, rs), 4, 1);
 293                         break;
 294
 295                 case OP_31_XOP_STFSUX:
 296                         if (kvmppc_check_fp_disabled(vcpu))
 297                                 return EMULATE_DONE;
 298                         vcpu->arch.mmio_sp64_extend = 1;
 299                         emulated = kvmppc_handle_store(run, vcpu,
 300                                 VCPU_FPR(vcpu, rs), 4, 1);
 301                         kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 302                         break;
 303
 304                 case OP_31_XOP_STFDX:
 305                         if (kvmppc_check_fp_disabled(vcpu))
 306                                 return EMULATE_DONE;
 307                         emulated = kvmppc_handle_store(run, vcpu,
 308                                 VCPU_FPR(vcpu, rs), 8, 1);
 309                         break;
 310
 311                 case OP_31_XOP_STFDUX:
 312                         if (kvmppc_check_fp_disabled(vcpu))
 313                                 return EMULATE_DONE;
 314                         emulated = kvmppc_handle_store(run, vcpu,
 315                                 VCPU_FPR(vcpu, rs), 8, 1);
 316                         kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 317                         break;
 318
 319                 case OP_31_XOP_STFIWX:
 320                         if (kvmppc_check_fp_disabled(vcpu))
 321                                 return EMULATE_DONE;
 322                         emulated = kvmppc_handle_store(run, vcpu,
 323                                 VCPU_FPR(vcpu, rs), 4, 1);
 324                         break;
 325 #endif
 326
 327 #ifdef CONFIG_VSX
 328                 case OP_31_XOP_LXSDX:
 329                         if (kvmppc_check_vsx_disabled(vcpu))
 330                                 return EMULATE_DONE;
 331                         vcpu->arch.mmio_vsx_copy_nums = 1;
 332                         vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_DWORD;
 333                         emulated = kvmppc_handle_vsx_load(run, vcpu,
 334                                 KVM_MMIO_REG_VSX|rt, 8, 1, 0);
 335                         break;
 336
 337                 case OP_31_XOP_LXSSPX:
 338                         if (kvmppc_check_vsx_disabled(vcpu))
 339                                 return EMULATE_DONE;
 340                         vcpu->arch.mmio_vsx_copy_nums = 1;
 341                         vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_DWORD;
 342                         vcpu->arch.mmio_sp64_extend = 1;
 343                         emulated = kvmppc_handle_vsx_load(run, vcpu,
 344                                 KVM_MMIO_REG_VSX|rt, 4, 1, 0);
 345                         break;
 346
 347                 case OP_31_XOP_LXSIWAX:
 348                         if (kvmppc_check_vsx_disabled(vcpu))
 349                                 return EMULATE_DONE;
 350                         vcpu->arch.mmio_vsx_copy_nums = 1;
 351                         vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_DWORD;
 352                         emulated = kvmppc_handle_vsx_load(run, vcpu,
 353                                 KVM_MMIO_REG_VSX|rt, 4, 1, 1);
 354                         break;
 355
 356                 case OP_31_XOP_LXSIWZX:
 357                         if (kvmppc_check_vsx_disabled(vcpu))
 358                                 return EMULATE_DONE;
 359                         vcpu->arch.mmio_vsx_copy_nums = 1;
 360                         vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_DWORD;
 361                         emulated = kvmppc_handle_vsx_load(run, vcpu,
 362                                 KVM_MMIO_REG_VSX|rt, 4, 1, 0);
 363                         break;
 364
 365                 case OP_31_XOP_LXVD2X:
 366                 /*
 367                  * In this case, the official load/store process is like this:
 368                  * Step1, exit from vm by page fault isr, then kvm save vsr.
 369                  * Please see guest_exit_cont->store_fp_state->SAVE_32VSRS
 370                  * as reference.
 371                  *
 372                  * Step2, copy data between memory and VCPU
 373                  * Notice: for LXVD2X/STXVD2X/LXVW4X/STXVW4X, we use
 374                  * 2copies*8bytes or 4copies*4bytes
 375                  * to simulate one copy of 16bytes.
 376                  * Also there is an endian issue here, we should notice the
 377                  * layout of memory.
 378                  * Please see MARCO of LXVD2X_ROT/STXVD2X_ROT as more reference.
 379                  * If host is little-endian, kvm will call XXSWAPD for
 380                  * LXVD2X_ROT/STXVD2X_ROT.
 381                  * So, if host is little-endian,
 382                  * the postion of memeory should be swapped.
 383                  *
 384                  * Step3, return to guest, kvm reset register.
 385                  * Please see kvmppc_hv_entry->load_fp_state->REST_32VSRS
 386                  * as reference.
 387                  */
 388                         if (kvmppc_check_vsx_disabled(vcpu))
 389                                 return EMULATE_DONE;
 390                         vcpu->arch.mmio_vsx_copy_nums = 2;
 391                         vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_DWORD;
 392                         emulated = kvmppc_handle_vsx_load(run, vcpu,
 393                                 KVM_MMIO_REG_VSX|rt, 8, 1, 0);
 394                         break;
 395
 396                 case OP_31_XOP_LXVW4X:
 397                         if (kvmppc_check_vsx_disabled(vcpu))
 398                                 return EMULATE_DONE;
 399                         vcpu->arch.mmio_vsx_copy_nums = 4;
 400                         vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_WORD;
 401                         emulated = kvmppc_handle_vsx_load(run, vcpu,
 402                                 KVM_MMIO_REG_VSX|rt, 4, 1, 0);
 403                         break;
 404
 405                 case OP_31_XOP_LXVDSX:
 406                         if (kvmppc_check_vsx_disabled(vcpu))
 407                                 return EMULATE_DONE;
 408                         vcpu->arch.mmio_vsx_copy_nums = 1;
 409                         vcpu->arch.mmio_vsx_copy_type =
 410                                  KVMPPC_VSX_COPY_DWORD_LOAD_DUMP;
 411                         emulated = kvmppc_handle_vsx_load(run, vcpu,
 412                                 KVM_MMIO_REG_VSX|rt, 8, 1, 0);
 413                         break;
 414
 415                 case OP_31_XOP_STXSDX:
 416                         if (kvmppc_check_vsx_disabled(vcpu))
 417                                 return EMULATE_DONE;
 418                         vcpu->arch.mmio_vsx_copy_nums = 1;
 419                         vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_DWORD;
 420                         emulated = kvmppc_handle_vsx_store(run, vcpu,
 421                                                  rs, 8, 1);
 422                         break;
 423
 424                 case OP_31_XOP_STXSSPX:
 425                         if (kvmppc_check_vsx_disabled(vcpu))
 426                                 return EMULATE_DONE;
 427                         vcpu->arch.mmio_vsx_copy_nums = 1;
 428                         vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_DWORD;
 429                         vcpu->arch.mmio_sp64_extend = 1;
 430                         emulated = kvmppc_handle_vsx_store(run, vcpu,
 431                                                  rs, 4, 1);
 432                         break;
 433
 434                 case OP_31_XOP_STXSIWX:
 435                         if (kvmppc_check_vsx_disabled(vcpu))
 436                                 return EMULATE_DONE;
 437                         vcpu->arch.mmio_vsx_offset = 1;
 438                         vcpu->arch.mmio_vsx_copy_nums = 1;
 439                         vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_WORD;
 440                         emulated = kvmppc_handle_vsx_store(run, vcpu,
 441                                                          rs, 4, 1);
 442                         break;
 443
 444                 case OP_31_XOP_STXVD2X:
 445                         if (kvmppc_check_vsx_disabled(vcpu))
 446                                 return EMULATE_DONE;
 447                         vcpu->arch.mmio_vsx_copy_nums = 2;
 448                         vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_DWORD;
 449                         emulated = kvmppc_handle_vsx_store(run, vcpu,
 450                                                          rs, 8, 1);
 451                         break;
 452
 453                 case OP_31_XOP_STXVW4X:
 454                         if (kvmppc_check_vsx_disabled(vcpu))
 455                                 return EMULATE_DONE;
 456                         vcpu->arch.mmio_vsx_copy_nums = 4;
 457                         vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_WORD;
 458                         emulated = kvmppc_handle_vsx_store(run, vcpu,
 459                                                          rs, 4, 1);
 460                         break;
 461 #endif /* CONFIG_VSX */
 462                 default:
 463                         emulated = EMULATE_FAIL;
 464                         break;
 465                 }
 466                 break;
 467
 468         case OP_LWZ:
 469                 emulated = kvmppc_handle_load(run, vcpu, rt, 4, 1);
 470                 break;
 471
 472 #ifdef CONFIG_PPC_FPU
 473         case OP_STFS:
 474                 if (kvmppc_check_fp_disabled(vcpu))
 475                         return EMULATE_DONE;
 476                 vcpu->arch.mmio_sp64_extend = 1;
 477                 emulated = kvmppc_handle_store(run, vcpu,
 478                         VCPU_FPR(vcpu, rs),
 479                         4, 1);
 480                 break;
 481
 482         case OP_STFSU:
 483                 if (kvmppc_check_fp_disabled(vcpu))
 484                         return EMULATE_DONE;
 485                 vcpu->arch.mmio_sp64_extend = 1;
 486                 emulated = kvmppc_handle_store(run, vcpu,
 487                         VCPU_FPR(vcpu, rs),
 488                         4, 1);
 489                 kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 490                 break;
 491
 492         case OP_STFD:
 493                 if (kvmppc_check_fp_disabled(vcpu))
 494                         return EMULATE_DONE;
 495                 emulated = kvmppc_handle_store(run, vcpu,
 496                         VCPU_FPR(vcpu, rs),
 497                                        8, 1);
 498                 break;
 499
 500         case OP_STFDU:
 501                 if (kvmppc_check_fp_disabled(vcpu))
 502                         return EMULATE_DONE;
 503                 emulated = kvmppc_handle_store(run, vcpu,
 504                         VCPU_FPR(vcpu, rs),
 505                                        8, 1);
 506                 kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 507                 break;
 508 #endif
 509
 510         case OP_LD:
 511                 rt = get_rt(inst);
 512                 switch (inst & 3) {
 513                 case 0: /* ld */
 514                         emulated = kvmppc_handle_load(run, vcpu, rt, 8, 1);
 515                         break;
 516                 case 1: /* ldu */
 517                         emulated = kvmppc_handle_load(run, vcpu, rt, 8, 1);
 518                         kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 519                         break;
 520                 case 2: /* lwa */
 521                         emulated = kvmppc_handle_loads(run, vcpu, rt, 4, 1);
 522                         break;
 523                 default:
 524                         emulated = EMULATE_FAIL;
 525                 }
 526                 break;
 527
 528         case OP_LWZU:
 529                 emulated = kvmppc_handle_load(run, vcpu, rt, 4, 1);
 530                 kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 531                 break;
 532
 533         case OP_LBZ:
 534                 emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1);
 535                 break;
 536
 537         case OP_LBZU:
 538                 emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1);
 539                 kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 540                 break;
 541
 542         case OP_STW:
 543                 emulated = kvmppc_handle_store(run, vcpu,
 544                                                kvmppc_get_gpr(vcpu, rs),
 545                                                4, 1);
 546                 break;
 547
 548         case OP_STD:
 549                 rs = get_rs(inst);
 550                 switch (inst & 3) {
 551                 case 0: /* std */
 552                         emulated = kvmppc_handle_store(run, vcpu,
 553                                 kvmppc_get_gpr(vcpu, rs), 8, 1);
 554                         break;
 555                 case 1: /* stdu */
 556                         emulated = kvmppc_handle_store(run, vcpu,
 557                                 kvmppc_get_gpr(vcpu, rs), 8, 1);
 558                         kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 559                         break;
 560                 default:
 561                         emulated = EMULATE_FAIL;
 562                 }
 563                 break;
 564
 565         case OP_STWU:
 566                 emulated = kvmppc_handle_store(run, vcpu,
 567                                 kvmppc_get_gpr(vcpu, rs), 4, 1);
 568                 kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 569                 break;
 570
 571         case OP_STB:
 572                 emulated = kvmppc_handle_store(run, vcpu,
 573                                 kvmppc_get_gpr(vcpu, rs), 1, 1);
 574                 break;
 575
 576         case OP_STBU:
 577                 emulated = kvmppc_handle_store(run, vcpu,
 578                                 kvmppc_get_gpr(vcpu, rs), 1, 1);
 579                 kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 580                 break;
 581
 582         case OP_LHZ:
 583                 emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1);
 584                 break;
 585
 586         case OP_LHZU:
 587                 emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1);
 588                 kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 589                 break;
 590
 591         case OP_LHA:
 592                 emulated = kvmppc_handle_loads(run, vcpu, rt, 2, 1);
 593                 break;
 594
 595         case OP_LHAU:
 596                 emulated = kvmppc_handle_loads(run, vcpu, rt, 2, 1);
 597                 kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 598                 break;
 599
 600         case OP_STH:
 601                 emulated = kvmppc_handle_store(run, vcpu,
 602                                 kvmppc_get_gpr(vcpu, rs), 2, 1);
 603                 break;
 604
 605         case OP_STHU:
 606                 emulated = kvmppc_handle_store(run, vcpu,
 607                                 kvmppc_get_gpr(vcpu, rs), 2, 1);
 608                 kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 609                 break;
 610
 611 #ifdef CONFIG_PPC_FPU
 612         case OP_LFS:
 613                 if (kvmppc_check_fp_disabled(vcpu))
 614                         return EMULATE_DONE;
 615                 vcpu->arch.mmio_sp64_extend = 1;
 616                 emulated = kvmppc_handle_load(run, vcpu,
 617                         KVM_MMIO_REG_FPR|rt, 4, 1);
 618                 break;
 619
 620         case OP_LFSU:
 621                 if (kvmppc_check_fp_disabled(vcpu))
 622                         return EMULATE_DONE;
 623                 vcpu->arch.mmio_sp64_extend = 1;
 624                 emulated = kvmppc_handle_load(run, vcpu,
 625                         KVM_MMIO_REG_FPR|rt, 4, 1);
 626                 kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 627                 break;
 628
 629         case OP_LFD:
 630                 if (kvmppc_check_fp_disabled(vcpu))
 631                         return EMULATE_DONE;
 632                 emulated = kvmppc_handle_load(run, vcpu,
 633                         KVM_MMIO_REG_FPR|rt, 8, 1);
 634                 break;
 635
 636         case OP_LFDU:
 637                 if (kvmppc_check_fp_disabled(vcpu))
 638                         return EMULATE_DONE;
 639                 emulated = kvmppc_handle_load(run, vcpu,
 640                         KVM_MMIO_REG_FPR|rt, 8, 1);
 641                 kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
 642                 break;
 643 #endif
 644
 645         default:
 646                 emulated = EMULATE_FAIL;
 647                 break;
 648         }
 649
 650         if (emulated == EMULATE_FAIL) {
 651                 advance = 0;
 652                 kvmppc_core_queue_program(vcpu, 0);
 653         }
 654
 655         trace_kvm_ppc_instr(inst, kvmppc_get_pc(vcpu), emulated);
 656
 657         /* Advance past emulated instruction. */
 658         if (advance)
 659                 kvmppc_set_pc(vcpu, kvmppc_get_pc(vcpu) + 4);
 660
 661         return emulated;
 662 }