book3s.c 23.3 KB
Newer Older
A
Alexander Graf 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * Copyright (C) 2009. SUSE Linux Products GmbH. All rights reserved.
 *
 * Authors:
 *    Alexander Graf <agraf@suse.de>
 *    Kevin Wolf <mail@kevin-wolf.de>
 *
 * Description:
 * This file is derived from arch/powerpc/kvm/44x.c,
 * by Hollis Blanchard <hollisb@us.ibm.com>.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2, as
 * published by the Free Software Foundation.
 */

#include <linux/kvm_host.h>
#include <linux/err.h>
19
#include <linux/export.h>
20
#include <linux/slab.h>
21 22
#include <linux/module.h>
#include <linux/miscdevice.h>
A
Alexander Graf 已提交
23 24 25 26 27 28 29 30 31 32

#include <asm/reg.h>
#include <asm/cputable.h>
#include <asm/cacheflush.h>
#include <asm/tlbflush.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <asm/kvm_ppc.h>
#include <asm/kvm_book3s.h>
#include <asm/mmu_context.h>
33
#include <asm/page.h>
34
#include <linux/gfp.h>
A
Alexander Graf 已提交
35 36
#include <linux/sched.h>
#include <linux/vmalloc.h>
A
Alexander Graf 已提交
37
#include <linux/highmem.h>
A
Alexander Graf 已提交
38

39
#include "book3s.h"
40 41
#include "trace.h"

A
Alexander Graf 已提交
42 43 44
#define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU

/* #define EXIT_DEBUG */
45

A
Alexander Graf 已提交
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
struct kvm_stats_debugfs_item debugfs_entries[] = {
	{ "exits",       VCPU_STAT(sum_exits) },
	{ "mmio",        VCPU_STAT(mmio_exits) },
	{ "sig",         VCPU_STAT(signal_exits) },
	{ "sysc",        VCPU_STAT(syscall_exits) },
	{ "inst_emu",    VCPU_STAT(emulated_inst_exits) },
	{ "dec",         VCPU_STAT(dec_exits) },
	{ "ext_intr",    VCPU_STAT(ext_intr_exits) },
	{ "queue_intr",  VCPU_STAT(queue_intr) },
	{ "halt_wakeup", VCPU_STAT(halt_wakeup) },
	{ "pf_storage",  VCPU_STAT(pf_storage) },
	{ "sp_storage",  VCPU_STAT(sp_storage) },
	{ "pf_instruc",  VCPU_STAT(pf_instruc) },
	{ "sp_instruc",  VCPU_STAT(sp_instruc) },
	{ "ld",          VCPU_STAT(ld) },
	{ "ld_slow",     VCPU_STAT(ld_slow) },
	{ "st",          VCPU_STAT(st) },
	{ "st_slow",     VCPU_STAT(st_slow) },
	{ NULL }
};

void kvmppc_core_load_host_debugstate(struct kvm_vcpu *vcpu)
{
}

void kvmppc_core_load_guest_debugstate(struct kvm_vcpu *vcpu)
{
}

75 76 77 78 79 80 81 82 83 84 85
void kvmppc_unfixup_split_real(struct kvm_vcpu *vcpu)
{
	if (vcpu->arch.hflags & BOOK3S_HFLAG_SPLIT_HACK) {
		ulong pc = kvmppc_get_pc(vcpu);
		if ((pc & SPLIT_HACK_MASK) == SPLIT_HACK_OFFS)
			kvmppc_set_pc(vcpu, pc & ~SPLIT_HACK_MASK);
		vcpu->arch.hflags &= ~BOOK3S_HFLAG_SPLIT_HACK;
	}
}
EXPORT_SYMBOL_GPL(kvmppc_unfixup_split_real);

86 87
static inline unsigned long kvmppc_interrupt_offset(struct kvm_vcpu *vcpu)
{
88
	if (!is_kvmppc_hv_enabled(vcpu->kvm))
89 90 91 92 93 94 95
		return to_book3s(vcpu)->hior;
	return 0;
}

static inline void kvmppc_update_int_pending(struct kvm_vcpu *vcpu,
			unsigned long pending_now, unsigned long old_pending)
{
96
	if (is_kvmppc_hv_enabled(vcpu->kvm))
97 98
		return;
	if (pending_now)
99
		kvmppc_set_int_pending(vcpu, 1);
100
	else if (old_pending)
101
		kvmppc_set_int_pending(vcpu, 0);
102 103 104 105 106 107 108 109
}

static inline bool kvmppc_critical_section(struct kvm_vcpu *vcpu)
{
	ulong crit_raw;
	ulong crit_r1;
	bool crit;

110
	if (is_kvmppc_hv_enabled(vcpu->kvm))
111 112
		return false;

113
	crit_raw = kvmppc_get_critical(vcpu);
114 115 116
	crit_r1 = kvmppc_get_gpr(vcpu, 1);

	/* Truncate crit indicators in 32 bit mode */
117
	if (!(kvmppc_get_msr(vcpu) & MSR_SF)) {
118 119 120 121 122 123 124
		crit_raw &= 0xffffffff;
		crit_r1 &= 0xffffffff;
	}

	/* Critical section when crit == r1 */
	crit = (crit_raw == crit_r1);
	/* ... and we're in supervisor mode */
125
	crit = crit && !(kvmppc_get_msr(vcpu) & MSR_PR);
126 127 128 129

	return crit;
}

A
Alexander Graf 已提交
130 131
void kvmppc_inject_interrupt(struct kvm_vcpu *vcpu, int vec, u64 flags)
{
132
	kvmppc_unfixup_split_real(vcpu);
133 134
	kvmppc_set_srr0(vcpu, kvmppc_get_pc(vcpu));
	kvmppc_set_srr1(vcpu, kvmppc_get_msr(vcpu) | flags);
135
	kvmppc_set_pc(vcpu, kvmppc_interrupt_offset(vcpu) + vec);
A
Alexander Graf 已提交
136 137 138
	vcpu->arch.mmu.reset_msr(vcpu);
}

139
static int kvmppc_book3s_vec2irqprio(unsigned int vec)
A
Alexander Graf 已提交
140 141 142 143 144 145 146 147 148 149 150
{
	unsigned int prio;

	switch (vec) {
	case 0x100: prio = BOOK3S_IRQPRIO_SYSTEM_RESET;		break;
	case 0x200: prio = BOOK3S_IRQPRIO_MACHINE_CHECK;	break;
	case 0x300: prio = BOOK3S_IRQPRIO_DATA_STORAGE;		break;
	case 0x380: prio = BOOK3S_IRQPRIO_DATA_SEGMENT;		break;
	case 0x400: prio = BOOK3S_IRQPRIO_INST_STORAGE;		break;
	case 0x480: prio = BOOK3S_IRQPRIO_INST_SEGMENT;		break;
	case 0x500: prio = BOOK3S_IRQPRIO_EXTERNAL;		break;
151
	case 0x501: prio = BOOK3S_IRQPRIO_EXTERNAL_LEVEL;	break;
A
Alexander Graf 已提交
152 153 154 155 156 157 158 159
	case 0x600: prio = BOOK3S_IRQPRIO_ALIGNMENT;		break;
	case 0x700: prio = BOOK3S_IRQPRIO_PROGRAM;		break;
	case 0x800: prio = BOOK3S_IRQPRIO_FP_UNAVAIL;		break;
	case 0x900: prio = BOOK3S_IRQPRIO_DECREMENTER;		break;
	case 0xc00: prio = BOOK3S_IRQPRIO_SYSCALL;		break;
	case 0xd00: prio = BOOK3S_IRQPRIO_DEBUG;		break;
	case 0xf20: prio = BOOK3S_IRQPRIO_ALTIVEC;		break;
	case 0xf40: prio = BOOK3S_IRQPRIO_VSX;			break;
160
	case 0xf60: prio = BOOK3S_IRQPRIO_FAC_UNAVAIL;		break;
A
Alexander Graf 已提交
161 162 163
	default:    prio = BOOK3S_IRQPRIO_MAX;			break;
	}

164 165 166
	return prio;
}

167
void kvmppc_book3s_dequeue_irqprio(struct kvm_vcpu *vcpu,
168 169
					  unsigned int vec)
{
170 171
	unsigned long old_pending = vcpu->arch.pending_exceptions;

172 173
	clear_bit(kvmppc_book3s_vec2irqprio(vec),
		  &vcpu->arch.pending_exceptions);
174

175 176
	kvmppc_update_int_pending(vcpu, vcpu->arch.pending_exceptions,
				  old_pending);
177 178
}

179 180 181 182 183 184
void kvmppc_book3s_queue_irqprio(struct kvm_vcpu *vcpu, unsigned int vec)
{
	vcpu->stat.queue_intr++;

	set_bit(kvmppc_book3s_vec2irqprio(vec),
		&vcpu->arch.pending_exceptions);
A
Alexander Graf 已提交
185 186 187 188
#ifdef EXIT_DEBUG
	printk(KERN_INFO "Queueing interrupt %x\n", vec);
#endif
}
189
EXPORT_SYMBOL_GPL(kvmppc_book3s_queue_irqprio);
A
Alexander Graf 已提交
190

191
void kvmppc_core_queue_program(struct kvm_vcpu *vcpu, ulong flags)
A
Alexander Graf 已提交
192
{
193 194
	/* might as well deliver this straight away */
	kvmppc_inject_interrupt(vcpu, BOOK3S_INTERRUPT_PROGRAM, flags);
A
Alexander Graf 已提交
195
}
196
EXPORT_SYMBOL_GPL(kvmppc_core_queue_program);
A
Alexander Graf 已提交
197 198 199 200 201

void kvmppc_core_queue_dec(struct kvm_vcpu *vcpu)
{
	kvmppc_book3s_queue_irqprio(vcpu, BOOK3S_INTERRUPT_DECREMENTER);
}
202
EXPORT_SYMBOL_GPL(kvmppc_core_queue_dec);
A
Alexander Graf 已提交
203 204 205

int kvmppc_core_pending_dec(struct kvm_vcpu *vcpu)
{
206
	return test_bit(BOOK3S_IRQPRIO_DECREMENTER, &vcpu->arch.pending_exceptions);
A
Alexander Graf 已提交
207
}
208
EXPORT_SYMBOL_GPL(kvmppc_core_pending_dec);
A
Alexander Graf 已提交
209

210 211 212 213
void kvmppc_core_dequeue_dec(struct kvm_vcpu *vcpu)
{
	kvmppc_book3s_dequeue_irqprio(vcpu, BOOK3S_INTERRUPT_DECREMENTER);
}
214
EXPORT_SYMBOL_GPL(kvmppc_core_dequeue_dec);
215

A
Alexander Graf 已提交
216 217 218
void kvmppc_core_queue_external(struct kvm_vcpu *vcpu,
                                struct kvm_interrupt *irq)
{
219 220 221 222 223 224
	unsigned int vec = BOOK3S_INTERRUPT_EXTERNAL;

	if (irq->irq == KVM_INTERRUPT_SET_LEVEL)
		vec = BOOK3S_INTERRUPT_EXTERNAL_LEVEL;

	kvmppc_book3s_queue_irqprio(vcpu, vec);
A
Alexander Graf 已提交
225 226
}

227
void kvmppc_core_dequeue_external(struct kvm_vcpu *vcpu)
228 229
{
	kvmppc_book3s_dequeue_irqprio(vcpu, BOOK3S_INTERRUPT_EXTERNAL);
230
	kvmppc_book3s_dequeue_irqprio(vcpu, BOOK3S_INTERRUPT_EXTERNAL_LEVEL);
231 232
}

233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
void kvmppc_core_queue_data_storage(struct kvm_vcpu *vcpu, ulong dar,
				    ulong flags)
{
	kvmppc_set_dar(vcpu, dar);
	kvmppc_set_dsisr(vcpu, flags);
	kvmppc_book3s_queue_irqprio(vcpu, BOOK3S_INTERRUPT_DATA_STORAGE);
}

void kvmppc_core_queue_inst_storage(struct kvm_vcpu *vcpu, ulong flags)
{
	u64 msr = kvmppc_get_msr(vcpu);
	msr &= ~(SRR1_ISI_NOPT | SRR1_ISI_N_OR_G | SRR1_ISI_PROT);
	msr |= flags & (SRR1_ISI_NOPT | SRR1_ISI_N_OR_G | SRR1_ISI_PROT);
	kvmppc_set_msr_fast(vcpu, msr);
	kvmppc_book3s_queue_irqprio(vcpu, BOOK3S_INTERRUPT_INST_STORAGE);
}

A
Alexander Graf 已提交
250 251 252 253
int kvmppc_book3s_irqprio_deliver(struct kvm_vcpu *vcpu, unsigned int priority)
{
	int deliver = 1;
	int vec = 0;
254
	bool crit = kvmppc_critical_section(vcpu);
A
Alexander Graf 已提交
255 256 257

	switch (priority) {
	case BOOK3S_IRQPRIO_DECREMENTER:
258
		deliver = (kvmppc_get_msr(vcpu) & MSR_EE) && !crit;
A
Alexander Graf 已提交
259 260 261
		vec = BOOK3S_INTERRUPT_DECREMENTER;
		break;
	case BOOK3S_IRQPRIO_EXTERNAL:
262
	case BOOK3S_IRQPRIO_EXTERNAL_LEVEL:
263
		deliver = (kvmppc_get_msr(vcpu) & MSR_EE) && !crit;
A
Alexander Graf 已提交
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
		vec = BOOK3S_INTERRUPT_EXTERNAL;
		break;
	case BOOK3S_IRQPRIO_SYSTEM_RESET:
		vec = BOOK3S_INTERRUPT_SYSTEM_RESET;
		break;
	case BOOK3S_IRQPRIO_MACHINE_CHECK:
		vec = BOOK3S_INTERRUPT_MACHINE_CHECK;
		break;
	case BOOK3S_IRQPRIO_DATA_STORAGE:
		vec = BOOK3S_INTERRUPT_DATA_STORAGE;
		break;
	case BOOK3S_IRQPRIO_INST_STORAGE:
		vec = BOOK3S_INTERRUPT_INST_STORAGE;
		break;
	case BOOK3S_IRQPRIO_DATA_SEGMENT:
		vec = BOOK3S_INTERRUPT_DATA_SEGMENT;
		break;
	case BOOK3S_IRQPRIO_INST_SEGMENT:
		vec = BOOK3S_INTERRUPT_INST_SEGMENT;
		break;
	case BOOK3S_IRQPRIO_ALIGNMENT:
		vec = BOOK3S_INTERRUPT_ALIGNMENT;
		break;
	case BOOK3S_IRQPRIO_PROGRAM:
		vec = BOOK3S_INTERRUPT_PROGRAM;
		break;
	case BOOK3S_IRQPRIO_VSX:
		vec = BOOK3S_INTERRUPT_VSX;
		break;
	case BOOK3S_IRQPRIO_ALTIVEC:
		vec = BOOK3S_INTERRUPT_ALTIVEC;
		break;
	case BOOK3S_IRQPRIO_FP_UNAVAIL:
		vec = BOOK3S_INTERRUPT_FP_UNAVAIL;
		break;
	case BOOK3S_IRQPRIO_SYSCALL:
		vec = BOOK3S_INTERRUPT_SYSCALL;
		break;
	case BOOK3S_IRQPRIO_DEBUG:
		vec = BOOK3S_INTERRUPT_TRACE;
		break;
	case BOOK3S_IRQPRIO_PERFORMANCE_MONITOR:
		vec = BOOK3S_INTERRUPT_PERFMON;
		break;
308 309 310
	case BOOK3S_IRQPRIO_FAC_UNAVAIL:
		vec = BOOK3S_INTERRUPT_FAC_UNAVAIL;
		break;
A
Alexander Graf 已提交
311 312 313 314 315 316 317 318 319 320 321
	default:
		deliver = 0;
		printk(KERN_ERR "KVM: Unknown interrupt: 0x%x\n", priority);
		break;
	}

#if 0
	printk(KERN_INFO "Deliver interrupt 0x%x? %x\n", vec, deliver);
#endif

	if (deliver)
322
		kvmppc_inject_interrupt(vcpu, vec, 0);
A
Alexander Graf 已提交
323 324 325 326

	return deliver;
}

327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
/*
 * This function determines if an irqprio should be cleared once issued.
 */
static bool clear_irqprio(struct kvm_vcpu *vcpu, unsigned int priority)
{
	switch (priority) {
		case BOOK3S_IRQPRIO_DECREMENTER:
			/* DEC interrupts get cleared by mtdec */
			return false;
		case BOOK3S_IRQPRIO_EXTERNAL_LEVEL:
			/* External interrupts get cleared by userspace */
			return false;
	}

	return true;
}

344
int kvmppc_core_prepare_to_enter(struct kvm_vcpu *vcpu)
A
Alexander Graf 已提交
345 346
{
	unsigned long *pending = &vcpu->arch.pending_exceptions;
347
	unsigned long old_pending = vcpu->arch.pending_exceptions;
A
Alexander Graf 已提交
348 349 350 351 352 353 354
	unsigned int priority;

#ifdef EXIT_DEBUG
	if (vcpu->arch.pending_exceptions)
		printk(KERN_EMERG "KVM: Check pending: %lx\n", vcpu->arch.pending_exceptions);
#endif
	priority = __ffs(*pending);
A
Alexander Graf 已提交
355
	while (priority < BOOK3S_IRQPRIO_MAX) {
356
		if (kvmppc_book3s_irqprio_deliver(vcpu, priority) &&
357
		    clear_irqprio(vcpu, priority)) {
A
Alexander Graf 已提交
358 359 360 361 362 363 364 365
			clear_bit(priority, &vcpu->arch.pending_exceptions);
			break;
		}

		priority = find_next_bit(pending,
					 BITS_PER_BYTE * sizeof(*pending),
					 priority + 1);
	}
366 367

	/* Tell the guest about our interrupt status */
368
	kvmppc_update_int_pending(vcpu, *pending, old_pending);
369 370

	return 0;
A
Alexander Graf 已提交
371
}
372
EXPORT_SYMBOL_GPL(kvmppc_core_prepare_to_enter);
A
Alexander Graf 已提交
373

374
pfn_t kvmppc_gpa_to_pfn(struct kvm_vcpu *vcpu, gpa_t gpa, bool writing,
375
			bool *writable)
376
{
377 378
	ulong mp_pa = vcpu->arch.magic_page_pa & KVM_PAM;
	gfn_t gfn = gpa >> PAGE_SHIFT;
379

380
	if (!(kvmppc_get_msr(vcpu) & MSR_SF))
381 382
		mp_pa = (uint32_t)mp_pa;

383
	/* Magic page override */
384 385
	gpa &= ~0xFFFULL;
	if (unlikely(mp_pa) && unlikely((gpa & KVM_PAM) == mp_pa)) {
386 387 388 389 390
		ulong shared_page = ((ulong)vcpu->arch.shared) & PAGE_MASK;
		pfn_t pfn;

		pfn = (pfn_t)virt_to_phys((void*)shared_page) >> PAGE_SHIFT;
		get_page(pfn_to_page(pfn));
391 392
		if (writable)
			*writable = true;
393 394 395
		return pfn;
	}

396
	return gfn_to_pfn_prot(vcpu->kvm, gfn, writing, writable);
397
}
398
EXPORT_SYMBOL_GPL(kvmppc_gpa_to_pfn);
399

400 401
int kvmppc_xlate(struct kvm_vcpu *vcpu, ulong eaddr, enum xlate_instdata xlid,
		 enum xlate_readwrite xlrw, struct kvmppc_pte *pte)
A
Alexander Graf 已提交
402
{
403 404
	bool data = (xlid == XLATE_DATA);
	bool iswrite = (xlrw == XLATE_WRITE);
405
	int relocated = (kvmppc_get_msr(vcpu) & (data ? MSR_DR : MSR_IR));
A
Alexander Graf 已提交
406 407 408
	int r;

	if (relocated) {
409
		r = vcpu->arch.mmu.xlate(vcpu, eaddr, pte, data, iswrite);
A
Alexander Graf 已提交
410 411
	} else {
		pte->eaddr = eaddr;
A
Alexander Graf 已提交
412
		pte->raddr = eaddr & KVM_PAM;
413
		pte->vpage = VSID_REAL | eaddr >> 12;
A
Alexander Graf 已提交
414 415 416 417
		pte->may_read = true;
		pte->may_write = true;
		pte->may_execute = true;
		r = 0;
418 419 420 421 422 423 424

		if ((kvmppc_get_msr(vcpu) & (MSR_IR | MSR_DR)) == MSR_DR &&
		    !data) {
			if ((vcpu->arch.hflags & BOOK3S_HFLAG_SPLIT_HACK) &&
			    ((eaddr & SPLIT_HACK_MASK) == SPLIT_HACK_OFFS))
			pte->raddr &= ~SPLIT_HACK_MASK;
		}
A
Alexander Graf 已提交
425 426 427 428 429
	}

	return r;
}

430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446
int kvmppc_load_last_inst(struct kvm_vcpu *vcpu, enum instruction_type type,
					 u32 *inst)
{
	ulong pc = kvmppc_get_pc(vcpu);
	int r;

	if (type == INST_SC)
		pc -= 4;

	r = kvmppc_ld(vcpu, &pc, sizeof(u32), inst, false);
	if (r == EMULATE_DONE)
		return r;
	else
		return EMULATE_AGAIN;
}
EXPORT_SYMBOL_GPL(kvmppc_load_last_inst);

A
Alexander Graf 已提交
447 448 449 450 451
int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
{
	return 0;
}

452 453 454 455 456 457 458 459 460
int kvmppc_subarch_vcpu_init(struct kvm_vcpu *vcpu)
{
	return 0;
}

void kvmppc_subarch_vcpu_uninit(struct kvm_vcpu *vcpu)
{
}

461 462 463
int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
				  struct kvm_sregs *sregs)
{
464
	return vcpu->kvm->arch.kvm_ops->get_sregs(vcpu, sregs);
465 466 467 468 469
}

int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
				  struct kvm_sregs *sregs)
{
470
	return vcpu->kvm->arch.kvm_ops->set_sregs(vcpu, sregs);
471 472
}

A
Alexander Graf 已提交
473 474 475 476
int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
{
	int i;

477
	regs->pc = kvmppc_get_pc(vcpu);
478
	regs->cr = kvmppc_get_cr(vcpu);
479 480
	regs->ctr = kvmppc_get_ctr(vcpu);
	regs->lr = kvmppc_get_lr(vcpu);
481
	regs->xer = kvmppc_get_xer(vcpu);
482 483 484
	regs->msr = kvmppc_get_msr(vcpu);
	regs->srr0 = kvmppc_get_srr0(vcpu);
	regs->srr1 = kvmppc_get_srr1(vcpu);
A
Alexander Graf 已提交
485
	regs->pid = vcpu->arch.pid;
486 487 488 489 490 491 492 493
	regs->sprg0 = kvmppc_get_sprg0(vcpu);
	regs->sprg1 = kvmppc_get_sprg1(vcpu);
	regs->sprg2 = kvmppc_get_sprg2(vcpu);
	regs->sprg3 = kvmppc_get_sprg3(vcpu);
	regs->sprg4 = kvmppc_get_sprg4(vcpu);
	regs->sprg5 = kvmppc_get_sprg5(vcpu);
	regs->sprg6 = kvmppc_get_sprg6(vcpu);
	regs->sprg7 = kvmppc_get_sprg7(vcpu);
A
Alexander Graf 已提交
494 495

	for (i = 0; i < ARRAY_SIZE(regs->gpr); i++)
496
		regs->gpr[i] = kvmppc_get_gpr(vcpu, i);
A
Alexander Graf 已提交
497 498 499 500 501 502 503 504

	return 0;
}

int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
{
	int i;

505
	kvmppc_set_pc(vcpu, regs->pc);
506
	kvmppc_set_cr(vcpu, regs->cr);
507 508
	kvmppc_set_ctr(vcpu, regs->ctr);
	kvmppc_set_lr(vcpu, regs->lr);
509
	kvmppc_set_xer(vcpu, regs->xer);
A
Alexander Graf 已提交
510
	kvmppc_set_msr(vcpu, regs->msr);
511 512 513 514 515 516 517 518 519 520
	kvmppc_set_srr0(vcpu, regs->srr0);
	kvmppc_set_srr1(vcpu, regs->srr1);
	kvmppc_set_sprg0(vcpu, regs->sprg0);
	kvmppc_set_sprg1(vcpu, regs->sprg1);
	kvmppc_set_sprg2(vcpu, regs->sprg2);
	kvmppc_set_sprg3(vcpu, regs->sprg3);
	kvmppc_set_sprg4(vcpu, regs->sprg4);
	kvmppc_set_sprg5(vcpu, regs->sprg5);
	kvmppc_set_sprg6(vcpu, regs->sprg6);
	kvmppc_set_sprg7(vcpu, regs->sprg7);
A
Alexander Graf 已提交
521

522 523
	for (i = 0; i < ARRAY_SIZE(regs->gpr); i++)
		kvmppc_set_gpr(vcpu, i, regs->gpr[i]);
A
Alexander Graf 已提交
524 525 526 527 528 529 530 531 532 533 534 535 536 537

	return 0;
}

int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
{
	return -ENOTSUPP;
}

int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
{
	return -ENOTSUPP;
}

538 539 540 541 542
int kvm_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg)
{
	int r;
	union kvmppc_one_reg val;
	int size;
543
	long int i;
544 545 546 547 548

	size = one_reg_size(reg->id);
	if (size > sizeof(val))
		return -EINVAL;

549
	r = vcpu->kvm->arch.kvm_ops->get_one_reg(vcpu, reg->id, &val);
550 551 552 553
	if (r == -EINVAL) {
		r = 0;
		switch (reg->id) {
		case KVM_REG_PPC_DAR:
554
			val = get_reg_val(reg->id, kvmppc_get_dar(vcpu));
555 556
			break;
		case KVM_REG_PPC_DSISR:
557
			val = get_reg_val(reg->id, kvmppc_get_dsisr(vcpu));
558
			break;
559 560
		case KVM_REG_PPC_FPR0 ... KVM_REG_PPC_FPR31:
			i = reg->id - KVM_REG_PPC_FPR0;
561
			val = get_reg_val(reg->id, VCPU_FPR(vcpu, i));
562 563
			break;
		case KVM_REG_PPC_FPSCR:
564
			val = get_reg_val(reg->id, vcpu->arch.fp.fpscr);
565 566 567 568 569 570 571
			break;
#ifdef CONFIG_ALTIVEC
		case KVM_REG_PPC_VR0 ... KVM_REG_PPC_VR31:
			if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
				r = -ENXIO;
				break;
			}
572
			val.vval = vcpu->arch.vr.vr[reg->id - KVM_REG_PPC_VR0];
573 574 575 576 577 578
			break;
		case KVM_REG_PPC_VSCR:
			if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
				r = -ENXIO;
				break;
			}
579
			val = get_reg_val(reg->id, vcpu->arch.vr.vscr.u[3]);
580
			break;
581 582 583
		case KVM_REG_PPC_VRSAVE:
			val = get_reg_val(reg->id, vcpu->arch.vrsave);
			break;
584
#endif /* CONFIG_ALTIVEC */
585 586 587 588 589 590 591 592 593 594 595
#ifdef CONFIG_VSX
		case KVM_REG_PPC_VSR0 ... KVM_REG_PPC_VSR31:
			if (cpu_has_feature(CPU_FTR_VSX)) {
				long int i = reg->id - KVM_REG_PPC_VSR0;
				val.vsxval[0] = vcpu->arch.fp.fpr[i][0];
				val.vsxval[1] = vcpu->arch.fp.fpr[i][1];
			} else {
				r = -ENXIO;
			}
			break;
#endif /* CONFIG_VSX */
596 597 598 599 600 601
		case KVM_REG_PPC_DEBUG_INST: {
			u32 opcode = INS_TW;
			r = copy_to_user((u32 __user *)(long)reg->addr,
					 &opcode, sizeof(u32));
			break;
		}
602 603 604 605 606 607 608 609 610
#ifdef CONFIG_KVM_XICS
		case KVM_REG_PPC_ICP_STATE:
			if (!vcpu->arch.icp) {
				r = -ENXIO;
				break;
			}
			val = get_reg_val(reg->id, kvmppc_xics_get_icp(vcpu));
			break;
#endif /* CONFIG_KVM_XICS */
611 612 613
		case KVM_REG_PPC_FSCR:
			val = get_reg_val(reg->id, vcpu->arch.fscr);
			break;
614 615 616
		case KVM_REG_PPC_TAR:
			val = get_reg_val(reg->id, vcpu->arch.tar);
			break;
617 618 619 620 621 622 623 624 625
		case KVM_REG_PPC_EBBHR:
			val = get_reg_val(reg->id, vcpu->arch.ebbhr);
			break;
		case KVM_REG_PPC_EBBRR:
			val = get_reg_val(reg->id, vcpu->arch.ebbrr);
			break;
		case KVM_REG_PPC_BESCR:
			val = get_reg_val(reg->id, vcpu->arch.bescr);
			break;
626 627 628
		case KVM_REG_PPC_VTB:
			val = get_reg_val(reg->id, vcpu->arch.vtb);
			break;
629 630 631
		case KVM_REG_PPC_IC:
			val = get_reg_val(reg->id, vcpu->arch.ic);
			break;
632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650
		default:
			r = -EINVAL;
			break;
		}
	}
	if (r)
		return r;

	if (copy_to_user((char __user *)(unsigned long)reg->addr, &val, size))
		r = -EFAULT;

	return r;
}

int kvm_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg)
{
	int r;
	union kvmppc_one_reg val;
	int size;
651
	long int i;
652 653 654 655 656 657 658 659

	size = one_reg_size(reg->id);
	if (size > sizeof(val))
		return -EINVAL;

	if (copy_from_user(&val, (char __user *)(unsigned long)reg->addr, size))
		return -EFAULT;

660
	r = vcpu->kvm->arch.kvm_ops->set_one_reg(vcpu, reg->id, &val);
661 662 663 664
	if (r == -EINVAL) {
		r = 0;
		switch (reg->id) {
		case KVM_REG_PPC_DAR:
665
			kvmppc_set_dar(vcpu, set_reg_val(reg->id, val));
666 667
			break;
		case KVM_REG_PPC_DSISR:
668
			kvmppc_set_dsisr(vcpu, set_reg_val(reg->id, val));
669
			break;
670 671
		case KVM_REG_PPC_FPR0 ... KVM_REG_PPC_FPR31:
			i = reg->id - KVM_REG_PPC_FPR0;
672
			VCPU_FPR(vcpu, i) = set_reg_val(reg->id, val);
673 674
			break;
		case KVM_REG_PPC_FPSCR:
675
			vcpu->arch.fp.fpscr = set_reg_val(reg->id, val);
676 677 678 679 680 681 682
			break;
#ifdef CONFIG_ALTIVEC
		case KVM_REG_PPC_VR0 ... KVM_REG_PPC_VR31:
			if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
				r = -ENXIO;
				break;
			}
683
			vcpu->arch.vr.vr[reg->id - KVM_REG_PPC_VR0] = val.vval;
684 685 686 687 688 689
			break;
		case KVM_REG_PPC_VSCR:
			if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
				r = -ENXIO;
				break;
			}
690
			vcpu->arch.vr.vscr.u[3] = set_reg_val(reg->id, val);
691
			break;
692 693 694 695 696 697 698
		case KVM_REG_PPC_VRSAVE:
			if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
				r = -ENXIO;
				break;
			}
			vcpu->arch.vrsave = set_reg_val(reg->id, val);
			break;
699
#endif /* CONFIG_ALTIVEC */
700 701 702 703 704 705 706 707 708 709 710
#ifdef CONFIG_VSX
		case KVM_REG_PPC_VSR0 ... KVM_REG_PPC_VSR31:
			if (cpu_has_feature(CPU_FTR_VSX)) {
				long int i = reg->id - KVM_REG_PPC_VSR0;
				vcpu->arch.fp.fpr[i][0] = val.vsxval[0];
				vcpu->arch.fp.fpr[i][1] = val.vsxval[1];
			} else {
				r = -ENXIO;
			}
			break;
#endif /* CONFIG_VSX */
711 712 713 714 715 716 717 718 719 720
#ifdef CONFIG_KVM_XICS
		case KVM_REG_PPC_ICP_STATE:
			if (!vcpu->arch.icp) {
				r = -ENXIO;
				break;
			}
			r = kvmppc_xics_set_icp(vcpu,
						set_reg_val(reg->id, val));
			break;
#endif /* CONFIG_KVM_XICS */
721 722 723
		case KVM_REG_PPC_FSCR:
			vcpu->arch.fscr = set_reg_val(reg->id, val);
			break;
724 725 726
		case KVM_REG_PPC_TAR:
			vcpu->arch.tar = set_reg_val(reg->id, val);
			break;
727 728 729 730 731 732 733 734 735
		case KVM_REG_PPC_EBBHR:
			vcpu->arch.ebbhr = set_reg_val(reg->id, val);
			break;
		case KVM_REG_PPC_EBBRR:
			vcpu->arch.ebbrr = set_reg_val(reg->id, val);
			break;
		case KVM_REG_PPC_BESCR:
			vcpu->arch.bescr = set_reg_val(reg->id, val);
			break;
736 737 738
		case KVM_REG_PPC_VTB:
			vcpu->arch.vtb = set_reg_val(reg->id, val);
			break;
739 740 741
		case KVM_REG_PPC_IC:
			vcpu->arch.ic = set_reg_val(reg->id, val);
			break;
742 743 744 745 746 747 748 749 750
		default:
			r = -EINVAL;
			break;
		}
	}

	return r;
}

751 752
void kvmppc_core_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
{
753
	vcpu->kvm->arch.kvm_ops->vcpu_load(vcpu, cpu);
754 755 756 757
}

void kvmppc_core_vcpu_put(struct kvm_vcpu *vcpu)
{
758
	vcpu->kvm->arch.kvm_ops->vcpu_put(vcpu);
759 760 761 762
}

void kvmppc_set_msr(struct kvm_vcpu *vcpu, u64 msr)
{
763
	vcpu->kvm->arch.kvm_ops->set_msr(vcpu, msr);
764
}
765
EXPORT_SYMBOL_GPL(kvmppc_set_msr);
766 767 768

int kvmppc_vcpu_run(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu)
{
769
	return vcpu->kvm->arch.kvm_ops->vcpu_run(kvm_run, vcpu);
770 771
}

A
Alexander Graf 已提交
772 773 774 775 776 777
int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
                                  struct kvm_translation *tr)
{
	return 0;
}

778 779 780 781 782 783
int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
					struct kvm_guest_debug *dbg)
{
	return -EINVAL;
}

784 785 786 787 788 789 790
void kvmppc_decrementer_func(unsigned long data)
{
	struct kvm_vcpu *vcpu = (struct kvm_vcpu *)data;

	kvmppc_core_queue_dec(vcpu);
	kvm_vcpu_kick(vcpu);
}
791 792 793

struct kvm_vcpu *kvmppc_core_vcpu_create(struct kvm *kvm, unsigned int id)
{
794
	return kvm->arch.kvm_ops->vcpu_create(kvm, id);
795 796 797 798
}

void kvmppc_core_vcpu_free(struct kvm_vcpu *vcpu)
{
799
	vcpu->kvm->arch.kvm_ops->vcpu_free(vcpu);
800 801 802 803
}

int kvmppc_core_check_requests(struct kvm_vcpu *vcpu)
{
804
	return vcpu->kvm->arch.kvm_ops->check_requests(vcpu);
805 806 807 808
}

int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, struct kvm_dirty_log *log)
{
809
	return kvm->arch.kvm_ops->get_dirty_log(kvm, log);
810 811
}

812
void kvmppc_core_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free,
813 814
			      struct kvm_memory_slot *dont)
{
815
	kvm->arch.kvm_ops->free_memslot(free, dont);
816 817
}

818
int kvmppc_core_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
819 820
			       unsigned long npages)
{
821
	return kvm->arch.kvm_ops->create_memslot(slot, npages);
822 823 824 825
}

void kvmppc_core_flush_memslot(struct kvm *kvm, struct kvm_memory_slot *memslot)
{
826
	kvm->arch.kvm_ops->flush_memslot(kvm, memslot);
827 828 829 830 831 832
}

int kvmppc_core_prepare_memory_region(struct kvm *kvm,
				struct kvm_memory_slot *memslot,
				struct kvm_userspace_memory_region *mem)
{
833
	return kvm->arch.kvm_ops->prepare_memory_region(kvm, memslot, mem);
834 835 836 837 838 839
}

void kvmppc_core_commit_memory_region(struct kvm *kvm,
				struct kvm_userspace_memory_region *mem,
				const struct kvm_memory_slot *old)
{
840
	kvm->arch.kvm_ops->commit_memory_region(kvm, mem, old);
841 842 843 844
}

int kvm_unmap_hva(struct kvm *kvm, unsigned long hva)
{
845
	return kvm->arch.kvm_ops->unmap_hva(kvm, hva);
846
}
847
EXPORT_SYMBOL_GPL(kvm_unmap_hva);
848 849 850

int kvm_unmap_hva_range(struct kvm *kvm, unsigned long start, unsigned long end)
{
851
	return kvm->arch.kvm_ops->unmap_hva_range(kvm, start, end);
852 853 854 855
}

int kvm_age_hva(struct kvm *kvm, unsigned long hva)
{
856
	return kvm->arch.kvm_ops->age_hva(kvm, hva);
857 858 859 860
}

int kvm_test_age_hva(struct kvm *kvm, unsigned long hva)
{
861
	return kvm->arch.kvm_ops->test_age_hva(kvm, hva);
862 863 864 865
}

void kvm_set_spte_hva(struct kvm *kvm, unsigned long hva, pte_t pte)
{
866
	kvm->arch.kvm_ops->set_spte_hva(kvm, hva, pte);
867 868 869 870
}

void kvmppc_mmu_destroy(struct kvm_vcpu *vcpu)
{
871
	vcpu->kvm->arch.kvm_ops->mmu_destroy(vcpu);
872 873 874 875 876 877 878 879 880 881
}

int kvmppc_core_init_vm(struct kvm *kvm)
{

#ifdef CONFIG_PPC64
	INIT_LIST_HEAD(&kvm->arch.spapr_tce_tables);
	INIT_LIST_HEAD(&kvm->arch.rtas_tokens);
#endif

882
	return kvm->arch.kvm_ops->init_vm(kvm);
883 884 885 886
}

void kvmppc_core_destroy_vm(struct kvm *kvm)
{
887
	kvm->arch.kvm_ops->destroy_vm(kvm);
888 889 890 891 892 893 894 895 896

#ifdef CONFIG_PPC64
	kvmppc_rtas_tokens_free(kvm);
	WARN_ON(!list_empty(&kvm->arch.spapr_tce_tables));
#endif
}

int kvmppc_core_check_processor_compat(void)
{
897 898 899 900 901 902 903 904
	/*
	 * We always return 0 for book3s. We check
	 * for compatability while loading the HV
	 * or PR module
	 */
	return 0;
}

905 906 907 908 909
int kvmppc_book3s_hcall_implemented(struct kvm *kvm, unsigned long hcall)
{
	return kvm->arch.kvm_ops->hcall_implemented(hcall);
}

910 911 912 913 914 915 916
static int kvmppc_book3s_init(void)
{
	int r;

	r = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
	if (r)
		return r;
917
#ifdef CONFIG_KVM_BOOK3S_32_HANDLER
918 919 920 921 922 923 924 925
	r = kvmppc_book3s_init_pr();
#endif
	return r;

}

static void kvmppc_book3s_exit(void)
{
926
#ifdef CONFIG_KVM_BOOK3S_32_HANDLER
927 928 929
	kvmppc_book3s_exit_pr();
#endif
	kvm_exit();
930
}
931 932 933

module_init(kvmppc_book3s_init);
module_exit(kvmppc_book3s_exit);
934 935

/* On 32bit this is our one and only kernel module */
936
#ifdef CONFIG_KVM_BOOK3S_32_HANDLER
937 938 939
MODULE_ALIAS_MISCDEV(KVM_MINOR);
MODULE_ALIAS("devname:kvm");
#endif