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  * Copyright 2011 Freescale Semiconductor, Inc.
  17  *
  18  * Authors: Hollis Blanchard <[email protected]>
  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 void kvmppc_emulate_dec(struct kvm_vcpu *vcpu)
  38 {
  39         unsigned long dec_nsec;
  40         unsigned long long dec_time;
  41
  42         pr_debug("mtDEC: %lx\n", vcpu->arch.dec);
  43         hrtimer_try_to_cancel(&vcpu->arch.dec_timer);
  44
  45 #ifdef CONFIG_PPC_BOOK3S
  46         /* mtdec lowers the interrupt line when positive. */
  47         kvmppc_core_dequeue_dec(vcpu);
  48 #endif
  49
  50 #ifdef CONFIG_BOOKE
  51         /* On BOOKE, DEC = 0 is as good as decrementer not enabled */
  52         if (vcpu->arch.dec == 0)
  53                 return;
  54 #endif
  55
  56         /*
  57          * The decrementer ticks at the same rate as the timebase, so
  58          * that's how we convert the guest DEC value to the number of
  59          * host ticks.
  60          */
  61
  62         dec_time = vcpu->arch.dec;
  63         /*
  64          * Guest timebase ticks at the same frequency as host decrementer.
  65          * So use the host decrementer calculations for decrementer emulation.
  66          */
  67         dec_time = dec_time << decrementer_clockevent.shift;
  68         do_div(dec_time, decrementer_clockevent.mult);
  69         dec_nsec = do_div(dec_time, NSEC_PER_SEC);
  70         hrtimer_start(&vcpu->arch.dec_timer,
  71                 ktime_set(dec_time, dec_nsec), HRTIMER_MODE_REL);
  72         vcpu->arch.dec_jiffies = get_tb();
  73 }
  74
  75 u32 kvmppc_get_dec(struct kvm_vcpu *vcpu, u64 tb)
  76 {
  77         u64 jd = tb - vcpu->arch.dec_jiffies;
  78
  79 #ifdef CONFIG_BOOKE
  80         if (vcpu->arch.dec < jd)
  81                 return 0;
  82 #endif
  83
  84         return vcpu->arch.dec - jd;
  85 }
  86
  87 static int kvmppc_emulate_mtspr(struct kvm_vcpu *vcpu, int sprn, int rs)
  88 {
  89         enum emulation_result emulated = EMULATE_DONE;
  90         ulong spr_val = kvmppc_get_gpr(vcpu, rs);
  91
  92         switch (sprn) {
  93         case SPRN_SRR0:
  94                 kvmppc_set_srr0(vcpu, spr_val);
  95                 break;
  96         case SPRN_SRR1:
  97                 kvmppc_set_srr1(vcpu, spr_val);
  98                 break;
  99
 100         /* XXX We need to context-switch the timebase for
 101          * watchdog and FIT. */
 102         case SPRN_TBWL: break;
 103         case SPRN_TBWU: break;
 104
 105         case SPRN_DEC:
 106                 vcpu->arch.dec = (u32) spr_val;
 107                 kvmppc_emulate_dec(vcpu);
 108                 break;
 109
 110         case SPRN_SPRG0:
 111                 kvmppc_set_sprg0(vcpu, spr_val);
 112                 break;
 113         case SPRN_SPRG1:
 114                 kvmppc_set_sprg1(vcpu, spr_val);
 115                 break;
 116         case SPRN_SPRG2:
 117                 kvmppc_set_sprg2(vcpu, spr_val);
 118                 break;
 119         case SPRN_SPRG3:
 120                 kvmppc_set_sprg3(vcpu, spr_val);
 121                 break;
 122
 123         /* PIR can legally be written, but we ignore it */
 124         case SPRN_PIR: break;
 125
 126         default:
 127                 emulated = vcpu->kvm->arch.kvm_ops->emulate_mtspr(vcpu, sprn,
 128                                                                   spr_val);
 129                 if (emulated == EMULATE_FAIL)
 130                         printk(KERN_INFO "mtspr: unknown spr "
 131                                 "0x%x\n", sprn);
 132                 break;
 133         }
 134
 135         kvmppc_set_exit_type(vcpu, EMULATED_MTSPR_EXITS);
 136
 137         return emulated;
 138 }
 139
 140 static int kvmppc_emulate_mfspr(struct kvm_vcpu *vcpu, int sprn, int rt)
 141 {
 142         enum emulation_result emulated = EMULATE_DONE;
 143         ulong spr_val = 0;
 144
 145         switch (sprn) {
 146         case SPRN_SRR0:
 147                 spr_val = kvmppc_get_srr0(vcpu);
 148                 break;
 149         case SPRN_SRR1:
 150                 spr_val = kvmppc_get_srr1(vcpu);
 151                 break;
 152         case SPRN_PVR:
 153                 spr_val = vcpu->arch.pvr;
 154                 break;
 155         case SPRN_PIR:
 156                 spr_val = vcpu->vcpu_id;
 157                 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                 spr_val = get_tb() >> 32;
 164                 break;
 165         case SPRN_TBWU:
 166                 spr_val = get_tb();
 167                 break;
 168
 169         case SPRN_SPRG0:
 170                 spr_val = kvmppc_get_sprg0(vcpu);
 171                 break;
 172         case SPRN_SPRG1:
 173                 spr_val = kvmppc_get_sprg1(vcpu);
 174                 break;
 175         case SPRN_SPRG2:
 176                 spr_val = kvmppc_get_sprg2(vcpu);
 177                 break;
 178         case SPRN_SPRG3:
 179                 spr_val = kvmppc_get_sprg3(vcpu);
 180                 break;
 181         /* Note: SPRG4-7 are user-readable, so we don't get
 182          * a trap. */
 183
 184         case SPRN_DEC:
 185                 spr_val = kvmppc_get_dec(vcpu, get_tb());
 186                 break;
 187         default:
 188                 emulated = vcpu->kvm->arch.kvm_ops->emulate_mfspr(vcpu, sprn,
 189                                                                   &spr_val);
 190                 if (unlikely(emulated == EMULATE_FAIL)) {
 191                         printk(KERN_INFO "mfspr: unknown spr "
 192                                 "0x%x\n", sprn);
 193                 }
 194                 break;
 195         }
 196
 197         if (emulated == EMULATE_DONE)
 198                 kvmppc_set_gpr(vcpu, rt, spr_val);
 199         kvmppc_set_exit_type(vcpu, EMULATED_MFSPR_EXITS);
 200
 201         return emulated;
 202 }
 203
 204 /* XXX Should probably auto-generate instruction decoding for a particular core
 205  * from opcode tables in the future. */
 206 int kvmppc_emulate_instruction(struct kvm_run *run, struct kvm_vcpu *vcpu)
 207 {
 208         u32 inst;
 209         int rs, rt, sprn;
 210         enum emulation_result emulated;
 211         int advance = 1;
 212
 213         /* this default type might be overwritten by subcategories */
 214         kvmppc_set_exit_type(vcpu, EMULATED_INST_EXITS);
 215
 216         emulated = kvmppc_get_last_inst(vcpu, INST_GENERIC, &inst);
 217         if (emulated != EMULATE_DONE)
 218                 return emulated;
 219
 220         pr_debug("Emulating opcode %d / %d\n", get_op(inst), get_xop(inst));
 221
 222         rs = get_rs(inst);
 223         rt = get_rt(inst);
 224         sprn = get_sprn(inst);
 225
 226         switch (get_op(inst)) {
 227         case OP_TRAP:
 228 #ifdef CONFIG_PPC_BOOK3S
 229         case OP_TRAP_64:
 230                 kvmppc_core_queue_program(vcpu, SRR1_PROGTRAP);
 231 #else
 232                 kvmppc_core_queue_program(vcpu,
 233                                           vcpu->arch.shared->esr | ESR_PTR);
 234 #endif
 235                 advance = 0;
 236                 break;
 237
 238         case 31:
 239                 switch (get_xop(inst)) {
 240
 241                 case OP_31_XOP_TRAP:
 242 #ifdef CONFIG_64BIT
 243                 case OP_31_XOP_TRAP_64:
 244 #endif
 245 #ifdef CONFIG_PPC_BOOK3S
 246                         kvmppc_core_queue_program(vcpu, SRR1_PROGTRAP);
 247 #else
 248                         kvmppc_core_queue_program(vcpu,
 249                                         vcpu->arch.shared->esr | ESR_PTR);
 250 #endif
 251                         advance = 0;
 252                         break;
 253
 254                 case OP_31_XOP_MFSPR:
 255                         emulated = kvmppc_emulate_mfspr(vcpu, sprn, rt);
 256                         if (emulated == EMULATE_AGAIN) {
 257                                 emulated = EMULATE_DONE;
 258                                 advance = 0;
 259                         }
 260                         break;
 261
 262                 case OP_31_XOP_MTSPR:
 263                         emulated = kvmppc_emulate_mtspr(vcpu, sprn, rs);
 264                         if (emulated == EMULATE_AGAIN) {
 265                                 emulated = EMULATE_DONE;
 266                                 advance = 0;
 267                         }
 268                         break;
 269
 270                 case OP_31_XOP_TLBSYNC:
 271                         break;
 272
 273                 default:
 274                         /* Attempt core-specific emulation below. */
 275                         emulated = EMULATE_FAIL;
 276                 }
 277                 break;
 278
 279         case 0:
 280                 /*
 281                  * Instruction with primary opcode 0. Based on PowerISA
 282                  * these are illegal instructions.
 283                  */
 284                 if (inst == KVMPPC_INST_SW_BREAKPOINT) {
 285                         run->exit_reason = KVM_EXIT_DEBUG;
 286                         run->debug.arch.address = kvmppc_get_pc(vcpu);
 287                         emulated = EMULATE_EXIT_USER;
 288                         advance = 0;
 289                 } else
 290                         emulated = EMULATE_FAIL;
 291
 292                 break;
 293
 294         default:
 295                 emulated = EMULATE_FAIL;
 296         }
 297
 298         if (emulated == EMULATE_FAIL) {
 299                 emulated = vcpu->kvm->arch.kvm_ops->emulate_op(run, vcpu, inst,
 300                                                                &advance);
 301                 if (emulated == EMULATE_AGAIN) {
 302                         advance = 0;
 303                 } else if (emulated == EMULATE_FAIL) {
 304                         advance = 0;
 305                         printk(KERN_ERR "Couldn't emulate instruction 0x%08x "
 306                                "(op %d xop %d)\n", inst, get_op(inst), get_xop(inst));
 307                 }
 308         }
 309
 310         trace_kvm_ppc_instr(inst, kvmppc_get_pc(vcpu), emulated);
 311
 312         /* Advance past emulated instruction. */
 313         if (advance)
 314                 kvmppc_set_pc(vcpu, kvmppc_get_pc(vcpu) + 4);
 315
 316         return emulated;
 317 }
 318 EXPORT_SYMBOL_GPL(kvmppc_emulate_instruction);