arch/powerpc/kvm/emulate.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  *
  17  * Authors: Hollis Blanchard <hollisb@us.ibm.com>
  18  */
  19
  20 #include <linux/jiffies.h>
  21 #include <linux/timer.h>
  22 #include <linux/types.h>
  23 #include <linux/string.h>
  24 #include <linux/kvm_host.h>
  25
  26 #include <asm/reg.h>
  27 #include <asm/time.h>
  28 #include <asm/byteorder.h>
  29 #include <asm/kvm_ppc.h>
  30 #include <asm/disassemble.h>
  31 #include "timing.h"
  32
  33 void kvmppc_emulate_dec(struct kvm_vcpu *vcpu)
  34 {
  35         if (vcpu->arch.tcr & TCR_DIE) {
  36                 /* The decrementer ticks at the same rate as the timebase, so
  37                  * that's how we convert the guest DEC value to the number of
  38                  * host ticks. */
  39                 unsigned long nr_jiffies;
  40
  41                 nr_jiffies = vcpu->arch.dec / tb_ticks_per_jiffy;
  42                 mod_timer(&vcpu->arch.dec_timer,
  43                           get_jiffies_64() + nr_jiffies);
  44         } else {
  45                 del_timer(&vcpu->arch.dec_timer);
  46         }
  47 }
  48
  49 /* XXX to do:
  50  * lhax
  51  * lhaux
  52  * lswx
  53  * lswi
  54  * stswx
  55  * stswi
  56  * lha
  57  * lhau
  58  * lmw
  59  * stmw
  60  *
  61  * XXX is_bigendian should depend on MMU mapping or MSR[LE]
  62  */
  63 /* XXX Should probably auto-generate instruction decoding for a particular core
  64  * from opcode tables in the future. */
  65 int kvmppc_emulate_instruction(struct kvm_run *run, struct kvm_vcpu *vcpu)
  66 {
  67         u32 inst = vcpu->arch.last_inst;
  68         u32 ea;
  69         int ra;
  70         int rb;
  71         int rs;
  72         int rt;
  73         int sprn;
  74         enum emulation_result emulated = EMULATE_DONE;
  75         int advance = 1;
  76
  77         /* this default type might be overwritten by subcategories */
  78         kvmppc_set_exit_type(vcpu, EMULATED_INST_EXITS);
  79
  80         switch (get_op(inst)) {
  81         case 3:                                             /* trap */
  82                 vcpu->arch.esr |= ESR_PTR;
  83                 kvmppc_core_queue_program(vcpu);
  84                 advance = 0;
  85                 break;
  86
  87         case 31:
  88                 switch (get_xop(inst)) {
  89
  90                 case 23:                                        /* lwzx */
  91                         rt = get_rt(inst);
  92                         emulated = kvmppc_handle_load(run, vcpu, rt, 4, 1);
  93                         break;
  94
  95                 case 87:                                        /* lbzx */
  96                         rt = get_rt(inst);
  97                         emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1);
  98                         break;
  99
 100                 case 151:                                       /* stwx */
 101                         rs = get_rs(inst);
 102                         emulated = kvmppc_handle_store(run, vcpu,
 103                                                        vcpu->arch.gpr[rs],
 104                                                        4, 1);
 105                         break;
 106
 107                 case 215:                                       /* stbx */
 108                         rs = get_rs(inst);
 109                         emulated = kvmppc_handle_store(run, vcpu,
 110                                                        vcpu->arch.gpr[rs],
 111                                                        1, 1);
 112                         break;
 113
 114                 case 247:                                       /* stbux */
 115                         rs = get_rs(inst);
 116                         ra = get_ra(inst);
 117                         rb = get_rb(inst);
 118
 119                         ea = vcpu->arch.gpr[rb];
 120                         if (ra)
 121                                 ea += vcpu->arch.gpr[ra];
 122
 123                         emulated = kvmppc_handle_store(run, vcpu,
 124                                                        vcpu->arch.gpr[rs],
 125                                                        1, 1);
 126                         vcpu->arch.gpr[rs] = ea;
 127                         break;
 128
 129                 case 279:                                       /* lhzx */
 130                         rt = get_rt(inst);
 131                         emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1);
 132                         break;
 133
 134                 case 311:                                       /* lhzux */
 135                         rt = get_rt(inst);
 136                         ra = get_ra(inst);
 137                         rb = get_rb(inst);
 138
 139                         ea = vcpu->arch.gpr[rb];
 140                         if (ra)
 141                                 ea += vcpu->arch.gpr[ra];
 142
 143                         emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1);
 144                         vcpu->arch.gpr[ra] = ea;
 145                         break;
 146
 147                 case 339:                                       /* mfspr */
 148                         sprn = get_sprn(inst);
 149                         rt = get_rt(inst);
 150
 151                         switch (sprn) {
 152                         case SPRN_SRR0:
 153                                 vcpu->arch.gpr[rt] = vcpu->arch.srr0; break;
 154                         case SPRN_SRR1:
 155                                 vcpu->arch.gpr[rt] = vcpu->arch.srr1; break;
 156                         case SPRN_PVR:
 157                                 vcpu->arch.gpr[rt] = vcpu->arch.pvr; break;
 158
 159                         /* Note: mftb and TBRL/TBWL are user-accessible, so
 160                          * the guest can always access the real TB anyways.
 161                          * In fact, we probably will never see these traps. */
 162                         case SPRN_TBWL:
 163                                 vcpu->arch.gpr[rt] = mftbl(); break;
 164                         case SPRN_TBWU:
 165                                 vcpu->arch.gpr[rt] = mftbu(); break;
 166
 167                         case SPRN_SPRG0:
 168                                 vcpu->arch.gpr[rt] = vcpu->arch.sprg0; break;
 169                         case SPRN_SPRG1:
 170                                 vcpu->arch.gpr[rt] = vcpu->arch.sprg1; break;
 171                         case SPRN_SPRG2:
 172                                 vcpu->arch.gpr[rt] = vcpu->arch.sprg2; break;
 173                         case SPRN_SPRG3:
 174                                 vcpu->arch.gpr[rt] = vcpu->arch.sprg3; break;
 175                         /* Note: SPRG4-7 are user-readable, so we don't get
 176                          * a trap. */
 177
 178                         default:
 179                                 emulated = kvmppc_core_emulate_mfspr(vcpu, sprn, rt);
 180                                 if (emulated == EMULATE_FAIL) {
 181                                         printk("mfspr: unknown spr %x\n", sprn);
 182                                         vcpu->arch.gpr[rt] = 0;
 183                                 }
 184                                 break;
 185                         }
 186                         break;
 187
 188                 case 407:                                       /* sthx */
 189                         rs = get_rs(inst);
 190                         ra = get_ra(inst);
 191                         rb = get_rb(inst);
 192
 193                         emulated = kvmppc_handle_store(run, vcpu,
 194                                                        vcpu->arch.gpr[rs],
 195                                                        2, 1);
 196                         break;
 197
 198                 case 439:                                       /* sthux */
 199                         rs = get_rs(inst);
 200                         ra = get_ra(inst);
 201                         rb = get_rb(inst);
 202
 203                         ea = vcpu->arch.gpr[rb];
 204                         if (ra)
 205                                 ea += vcpu->arch.gpr[ra];
 206
 207                         emulated = kvmppc_handle_store(run, vcpu,
 208                                                        vcpu->arch.gpr[rs],
 209                                                        2, 1);
 210                         vcpu->arch.gpr[ra] = ea;
 211                         break;
 212
 213                 case 467:                                       /* mtspr */
 214                         sprn = get_sprn(inst);
 215                         rs = get_rs(inst);
 216                         switch (sprn) {
 217                         case SPRN_SRR0:
 218                                 vcpu->arch.srr0 = vcpu->arch.gpr[rs]; break;
 219                         case SPRN_SRR1:
 220                                 vcpu->arch.srr1 = vcpu->arch.gpr[rs]; break;
 221
 222                         /* XXX We need to context-switch the timebase for
 223                          * watchdog and FIT. */
 224                         case SPRN_TBWL: break;
 225                         case SPRN_TBWU: break;
 226
 227                         case SPRN_DEC:
 228                                 vcpu->arch.dec = vcpu->arch.gpr[rs];
 229                                 kvmppc_emulate_dec(vcpu);
 230                                 break;
 231
 232                         case SPRN_SPRG0:
 233                                 vcpu->arch.sprg0 = vcpu->arch.gpr[rs]; break;
 234                         case SPRN_SPRG1:
 235                                 vcpu->arch.sprg1 = vcpu->arch.gpr[rs]; break;
 236                         case SPRN_SPRG2:
 237                                 vcpu->arch.sprg2 = vcpu->arch.gpr[rs]; break;
 238                         case SPRN_SPRG3:
 239                                 vcpu->arch.sprg3 = vcpu->arch.gpr[rs]; break;
 240
 241                         default:
 242                                 emulated = kvmppc_core_emulate_mtspr(vcpu, sprn, rs);
 243                                 if (emulated == EMULATE_FAIL)
 244                                         printk("mtspr: unknown spr %x\n", sprn);
 245                                 break;
 246                         }
 247                         break;
 248
 249                 case 470:                                       /* dcbi */
 250                         /* Do nothing. The guest is performing dcbi because
 251                          * hardware DMA is not snooped by the dcache, but
 252                          * emulated DMA either goes through the dcache as
 253                          * normal writes, or the host kernel has handled dcache
 254                          * coherence. */
 255                         break;
 256
 257                 case 534:                                       /* lwbrx */
 258                         rt = get_rt(inst);
 259                         emulated = kvmppc_handle_load(run, vcpu, rt, 4, 0);
 260                         break;
 261
 262                 case 566:                                       /* tlbsync */
 263                         break;
 264
 265                 case 662:                                       /* stwbrx */
 266                         rs = get_rs(inst);
 267                         ra = get_ra(inst);
 268                         rb = get_rb(inst);
 269
 270                         emulated = kvmppc_handle_store(run, vcpu,
 271                                                        vcpu->arch.gpr[rs],
 272                                                        4, 0);
 273                         break;
 274
 275                 case 790:                                       /* lhbrx */
 276                         rt = get_rt(inst);
 277                         emulated = kvmppc_handle_load(run, vcpu, rt, 2, 0);
 278                         break;
 279
 280                 case 918:                                       /* sthbrx */
 281                         rs = get_rs(inst);
 282                         ra = get_ra(inst);
 283                         rb = get_rb(inst);
 284
 285                         emulated = kvmppc_handle_store(run, vcpu,
 286                                                        vcpu->arch.gpr[rs],
 287                                                        2, 0);
 288                         break;
 289
 290                 default:
 291                         /* Attempt core-specific emulation below. */
 292                         emulated = EMULATE_FAIL;
 293                 }
 294                 break;
 295
 296         case 32:                                                /* lwz */
 297                 rt = get_rt(inst);
 298                 emulated = kvmppc_handle_load(run, vcpu, rt, 4, 1);
 299                 break;
 300
 301         case 33:                                                /* lwzu */
 302                 ra = get_ra(inst);
 303                 rt = get_rt(inst);
 304                 emulated = kvmppc_handle_load(run, vcpu, rt, 4, 1);
 305                 vcpu->arch.gpr[ra] = vcpu->arch.paddr_accessed;
 306                 break;
 307
 308         case 34:                                                /* lbz */
 309                 rt = get_rt(inst);
 310                 emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1);
 311                 break;
 312
 313         case 35:                                                /* lbzu */
 314                 ra = get_ra(inst);
 315                 rt = get_rt(inst);
 316                 emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1);
 317                 vcpu->arch.gpr[ra] = vcpu->arch.paddr_accessed;
 318                 break;
 319
 320         case 36:                                                /* stw */
 321                 rs = get_rs(inst);
 322                 emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs],
 323                                                4, 1);
 324                 break;
 325
 326         case 37:                                                /* stwu */
 327                 ra = get_ra(inst);
 328                 rs = get_rs(inst);
 329                 emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs],
 330                                                4, 1);
 331                 vcpu->arch.gpr[ra] = vcpu->arch.paddr_accessed;
 332                 break;
 333
 334         case 38:                                                /* stb */
 335                 rs = get_rs(inst);
 336                 emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs],
 337                                                1, 1);
 338                 break;
 339
 340         case 39:                                                /* stbu */
 341                 ra = get_ra(inst);
 342                 rs = get_rs(inst);
 343                 emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs],
 344                                                1, 1);
 345                 vcpu->arch.gpr[ra] = vcpu->arch.paddr_accessed;
 346                 break;
 347
 348         case 40:                                                /* lhz */
 349                 rt = get_rt(inst);
 350                 emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1);
 351                 break;
 352
 353         case 41:                                                /* lhzu */
 354                 ra = get_ra(inst);
 355                 rt = get_rt(inst);
 356                 emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1);
 357                 vcpu->arch.gpr[ra] = vcpu->arch.paddr_accessed;
 358                 break;
 359
 360         case 44:                                                /* sth */
 361                 rs = get_rs(inst);
 362                 emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs],
 363                                                2, 1);
 364                 break;
 365
 366         case 45:                                                /* sthu */
 367                 ra = get_ra(inst);
 368                 rs = get_rs(inst);
 369                 emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs],
 370                                                2, 1);
 371                 vcpu->arch.gpr[ra] = vcpu->arch.paddr_accessed;
 372                 break;
 373
 374         default:
 375                 emulated = EMULATE_FAIL;
 376         }
 377
 378         if (emulated == EMULATE_FAIL) {
 379                 emulated = kvmppc_core_emulate_op(run, vcpu, inst, &advance);
 380                 if (emulated == EMULATE_FAIL) {
 381                         advance = 0;
 382                         printk(KERN_ERR "Couldn't emulate instruction 0x%08x "
 383                                "(op %d xop %d)\n", inst, get_op(inst), get_xop(inst));
 384                 }
 385         }
 386
 387         KVMTRACE_3D(PPC_INSTR, vcpu, inst, (int)vcpu->arch.pc, emulated, entryexit);
 388
 389         if (advance)
 390                 vcpu->arch.pc += 4; /* Advance past emulated instruction. */
 391
 392         return emulated;
 393 }