lapic.c 30.5 KB
Newer Older
E
Eddie Dong 已提交
1 2 3 4 5 6 7

/*
 * Local APIC virtualization
 *
 * Copyright (C) 2006 Qumranet, Inc.
 * Copyright (C) 2007 Novell
 * Copyright (C) 2007 Intel
N
Nicolas Kaiser 已提交
8
 * Copyright 2009 Red Hat, Inc. and/or its affiliates.
E
Eddie Dong 已提交
9 10 11 12 13 14 15 16 17 18 19 20
 *
 * Authors:
 *   Dor Laor <dor.laor@qumranet.com>
 *   Gregory Haskins <ghaskins@novell.com>
 *   Yaozu (Eddie) Dong <eddie.dong@intel.com>
 *
 * Based on Xen 3.1 code, Copyright (c) 2004, Intel Corporation.
 *
 * This work is licensed under the terms of the GNU GPL, version 2.  See
 * the COPYING file in the top-level directory.
 */

21
#include <linux/kvm_host.h>
E
Eddie Dong 已提交
22 23 24 25 26 27 28
#include <linux/kvm.h>
#include <linux/mm.h>
#include <linux/highmem.h>
#include <linux/smp.h>
#include <linux/hrtimer.h>
#include <linux/io.h>
#include <linux/module.h>
R
Roman Zippel 已提交
29
#include <linux/math64.h>
30
#include <linux/slab.h>
E
Eddie Dong 已提交
31 32 33 34 35 36
#include <asm/processor.h>
#include <asm/msr.h>
#include <asm/page.h>
#include <asm/current.h>
#include <asm/apicdef.h>
#include <asm/atomic.h>
37
#include "kvm_cache_regs.h"
E
Eddie Dong 已提交
38
#include "irq.h"
39
#include "trace.h"
40
#include "x86.h"
E
Eddie Dong 已提交
41

42 43 44 45 46 47
#ifndef CONFIG_X86_64
#define mod_64(x, y) ((x) - (y) * div64_u64(x, y))
#else
#define mod_64(x, y) ((x) % (y))
#endif

E
Eddie Dong 已提交
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
#define PRId64 "d"
#define PRIx64 "llx"
#define PRIu64 "u"
#define PRIo64 "o"

#define APIC_BUS_CYCLE_NS 1

/* #define apic_debug(fmt,arg...) printk(KERN_WARNING fmt,##arg) */
#define apic_debug(fmt, arg...)

#define APIC_LVT_NUM			6
/* 14 is the version for Xeon and Pentium 8.4.8*/
#define APIC_VERSION			(0x14UL | ((APIC_LVT_NUM - 1) << 16))
#define LAPIC_MMIO_LENGTH		(1 << 12)
/* followed define is not in apicdef.h */
#define APIC_SHORT_MASK			0xc0000
#define APIC_DEST_NOSHORT		0x0
#define APIC_DEST_MASK			0x800
#define MAX_APIC_VECTOR			256

#define VEC_POS(v) ((v) & (32 - 1))
#define REG_POS(v) (((v) >> 5) << 4)
70

E
Eddie Dong 已提交
71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
static inline u32 apic_get_reg(struct kvm_lapic *apic, int reg_off)
{
	return *((u32 *) (apic->regs + reg_off));
}

static inline void apic_set_reg(struct kvm_lapic *apic, int reg_off, u32 val)
{
	*((u32 *) (apic->regs + reg_off)) = val;
}

static inline int apic_test_and_set_vector(int vec, void *bitmap)
{
	return test_and_set_bit(VEC_POS(vec), (bitmap) + REG_POS(vec));
}

static inline int apic_test_and_clear_vector(int vec, void *bitmap)
{
	return test_and_clear_bit(VEC_POS(vec), (bitmap) + REG_POS(vec));
}

static inline void apic_set_vector(int vec, void *bitmap)
{
	set_bit(VEC_POS(vec), (bitmap) + REG_POS(vec));
}

static inline void apic_clear_vector(int vec, void *bitmap)
{
	clear_bit(VEC_POS(vec), (bitmap) + REG_POS(vec));
}

static inline int apic_hw_enabled(struct kvm_lapic *apic)
{
103
	return (apic)->vcpu->arch.apic_base & MSR_IA32_APICBASE_ENABLE;
E
Eddie Dong 已提交
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
}

static inline int  apic_sw_enabled(struct kvm_lapic *apic)
{
	return apic_get_reg(apic, APIC_SPIV) & APIC_SPIV_APIC_ENABLED;
}

static inline int apic_enabled(struct kvm_lapic *apic)
{
	return apic_sw_enabled(apic) &&	apic_hw_enabled(apic);
}

#define LVT_MASK	\
	(APIC_LVT_MASKED | APIC_SEND_PENDING | APIC_VECTOR_MASK)

#define LINT_MASK	\
	(LVT_MASK | APIC_MODE_MASK | APIC_INPUT_POLARITY | \
	 APIC_LVT_REMOTE_IRR | APIC_LVT_LEVEL_TRIGGER)

static inline int kvm_apic_id(struct kvm_lapic *apic)
{
	return (apic_get_reg(apic, APIC_ID) >> 24) & 0xff;
}

static inline int apic_lvt_enabled(struct kvm_lapic *apic, int lvt_type)
{
	return !(apic_get_reg(apic, lvt_type) & APIC_LVT_MASKED);
}

static inline int apic_lvt_vector(struct kvm_lapic *apic, int lvt_type)
{
	return apic_get_reg(apic, lvt_type) & APIC_VECTOR_MASK;
}

static inline int apic_lvtt_period(struct kvm_lapic *apic)
{
	return apic_get_reg(apic, APIC_LVTT) & APIC_LVT_TIMER_PERIODIC;
}

143 144 145 146 147
static inline int apic_lvt_nmi_mode(u32 lvt_val)
{
	return (lvt_val & (APIC_MODE_MASK | APIC_LVT_MASKED)) == APIC_DM_NMI;
}

148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
void kvm_apic_set_version(struct kvm_vcpu *vcpu)
{
	struct kvm_lapic *apic = vcpu->arch.apic;
	struct kvm_cpuid_entry2 *feat;
	u32 v = APIC_VERSION;

	if (!irqchip_in_kernel(vcpu->kvm))
		return;

	feat = kvm_find_cpuid_entry(apic->vcpu, 0x1, 0);
	if (feat && (feat->ecx & (1 << (X86_FEATURE_X2APIC & 31))))
		v |= APIC_LVR_DIRECTED_EOI;
	apic_set_reg(apic, APIC_LVR, v);
}

G
Gleb Natapov 已提交
163 164 165 166 167
static inline int apic_x2apic_mode(struct kvm_lapic *apic)
{
	return apic->vcpu->arch.apic_base & X2APIC_ENABLE;
}

E
Eddie Dong 已提交
168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
static unsigned int apic_lvt_mask[APIC_LVT_NUM] = {
	LVT_MASK | APIC_LVT_TIMER_PERIODIC,	/* LVTT */
	LVT_MASK | APIC_MODE_MASK,	/* LVTTHMR */
	LVT_MASK | APIC_MODE_MASK,	/* LVTPC */
	LINT_MASK, LINT_MASK,	/* LVT0-1 */
	LVT_MASK		/* LVTERR */
};

static int find_highest_vector(void *bitmap)
{
	u32 *word = bitmap;
	int word_offset = MAX_APIC_VECTOR >> 5;

	while ((word_offset != 0) && (word[(--word_offset) << 2] == 0))
		continue;

	if (likely(!word_offset && !word[0]))
		return -1;
	else
		return fls(word[word_offset << 2]) - 1 + (word_offset << 5);
}

static inline int apic_test_and_set_irr(int vec, struct kvm_lapic *apic)
{
192
	apic->irr_pending = true;
E
Eddie Dong 已提交
193 194 195
	return apic_test_and_set_vector(vec, apic->regs + APIC_IRR);
}

196
static inline int apic_search_irr(struct kvm_lapic *apic)
E
Eddie Dong 已提交
197
{
198
	return find_highest_vector(apic->regs + APIC_IRR);
E
Eddie Dong 已提交
199 200 201 202 203 204
}

static inline int apic_find_highest_irr(struct kvm_lapic *apic)
{
	int result;

205 206 207 208
	if (!apic->irr_pending)
		return -1;

	result = apic_search_irr(apic);
E
Eddie Dong 已提交
209 210 211 212 213
	ASSERT(result == -1 || result >= 16);

	return result;
}

214 215 216 217 218 219 220 221
static inline void apic_clear_irr(int vec, struct kvm_lapic *apic)
{
	apic->irr_pending = false;
	apic_clear_vector(vec, apic->regs + APIC_IRR);
	if (apic_search_irr(apic) != -1)
		apic->irr_pending = true;
}

222 223
int kvm_lapic_find_highest_irr(struct kvm_vcpu *vcpu)
{
224
	struct kvm_lapic *apic = vcpu->arch.apic;
225 226
	int highest_irr;

227 228 229 230 231
	/* This may race with setting of irr in __apic_accept_irq() and
	 * value returned may be wrong, but kvm_vcpu_kick() in __apic_accept_irq
	 * will cause vmexit immediately and the value will be recalculated
	 * on the next vmentry.
	 */
232 233 234 235 236 237 238
	if (!apic)
		return 0;
	highest_irr = apic_find_highest_irr(apic);

	return highest_irr;
}

239 240 241
static int __apic_accept_irq(struct kvm_lapic *apic, int delivery_mode,
			     int vector, int level, int trig_mode);

242
int kvm_apic_set_irq(struct kvm_vcpu *vcpu, struct kvm_lapic_irq *irq)
E
Eddie Dong 已提交
243
{
244
	struct kvm_lapic *apic = vcpu->arch.apic;
245

246 247
	return __apic_accept_irq(apic, irq->delivery_mode, irq->vector,
			irq->level, irq->trig_mode);
E
Eddie Dong 已提交
248 249 250 251 252 253 254 255 256 257 258 259 260 261
}

static inline int apic_find_highest_isr(struct kvm_lapic *apic)
{
	int result;

	result = find_highest_vector(apic->regs + APIC_ISR);
	ASSERT(result == -1 || result >= 16);

	return result;
}

static void apic_update_ppr(struct kvm_lapic *apic)
{
262
	u32 tpr, isrv, ppr, old_ppr;
E
Eddie Dong 已提交
263 264
	int isr;

265
	old_ppr = apic_get_reg(apic, APIC_PROCPRI);
E
Eddie Dong 已提交
266 267 268 269 270 271 272 273 274 275 276 277
	tpr = apic_get_reg(apic, APIC_TASKPRI);
	isr = apic_find_highest_isr(apic);
	isrv = (isr != -1) ? isr : 0;

	if ((tpr & 0xf0) >= (isrv & 0xf0))
		ppr = tpr & 0xff;
	else
		ppr = isrv & 0xf0;

	apic_debug("vlapic %p, ppr 0x%x, isr 0x%x, isrv 0x%x",
		   apic, ppr, isr, isrv);

278 279 280 281
	if (old_ppr != ppr) {
		apic_set_reg(apic, APIC_PROCPRI, ppr);
		kvm_make_request(KVM_REQ_EVENT, apic->vcpu);
	}
E
Eddie Dong 已提交
282 283 284 285 286 287 288 289 290 291
}

static void apic_set_tpr(struct kvm_lapic *apic, u32 tpr)
{
	apic_set_reg(apic, APIC_TASKPRI, tpr);
	apic_update_ppr(apic);
}

int kvm_apic_match_physical_addr(struct kvm_lapic *apic, u16 dest)
{
292
	return dest == 0xff || kvm_apic_id(apic) == dest;
E
Eddie Dong 已提交
293 294 295 296 297
}

int kvm_apic_match_logical_addr(struct kvm_lapic *apic, u8 mda)
{
	int result = 0;
G
Gleb Natapov 已提交
298 299 300 301 302 303
	u32 logical_id;

	if (apic_x2apic_mode(apic)) {
		logical_id = apic_get_reg(apic, APIC_LDR);
		return logical_id & mda;
	}
E
Eddie Dong 已提交
304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325

	logical_id = GET_APIC_LOGICAL_ID(apic_get_reg(apic, APIC_LDR));

	switch (apic_get_reg(apic, APIC_DFR)) {
	case APIC_DFR_FLAT:
		if (logical_id & mda)
			result = 1;
		break;
	case APIC_DFR_CLUSTER:
		if (((logical_id >> 4) == (mda >> 0x4))
		    && (logical_id & mda & 0xf))
			result = 1;
		break;
	default:
		printk(KERN_WARNING "Bad DFR vcpu %d: %08x\n",
		       apic->vcpu->vcpu_id, apic_get_reg(apic, APIC_DFR));
		break;
	}

	return result;
}

326
int kvm_apic_match_dest(struct kvm_vcpu *vcpu, struct kvm_lapic *source,
E
Eddie Dong 已提交
327 328 329
			   int short_hand, int dest, int dest_mode)
{
	int result = 0;
330
	struct kvm_lapic *target = vcpu->arch.apic;
E
Eddie Dong 已提交
331 332

	apic_debug("target %p, source %p, dest 0x%x, "
333
		   "dest_mode 0x%x, short_hand 0x%x\n",
E
Eddie Dong 已提交
334 335
		   target, source, dest, dest_mode, short_hand);

Z
Zachary Amsden 已提交
336
	ASSERT(target);
E
Eddie Dong 已提交
337 338
	switch (short_hand) {
	case APIC_DEST_NOSHORT:
339
		if (dest_mode == 0)
E
Eddie Dong 已提交
340
			/* Physical mode. */
341 342
			result = kvm_apic_match_physical_addr(target, dest);
		else
E
Eddie Dong 已提交
343 344 345 346
			/* Logical mode. */
			result = kvm_apic_match_logical_addr(target, dest);
		break;
	case APIC_DEST_SELF:
347
		result = (target == source);
E
Eddie Dong 已提交
348 349 350 351 352
		break;
	case APIC_DEST_ALLINC:
		result = 1;
		break;
	case APIC_DEST_ALLBUT:
353
		result = (target != source);
E
Eddie Dong 已提交
354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
		break;
	default:
		printk(KERN_WARNING "Bad dest shorthand value %x\n",
		       short_hand);
		break;
	}

	return result;
}

/*
 * Add a pending IRQ into lapic.
 * Return 1 if successfully added and 0 if discarded.
 */
static int __apic_accept_irq(struct kvm_lapic *apic, int delivery_mode,
			     int vector, int level, int trig_mode)
{
371
	int result = 0;
372
	struct kvm_vcpu *vcpu = apic->vcpu;
E
Eddie Dong 已提交
373 374 375

	switch (delivery_mode) {
	case APIC_DM_LOWEST:
376 377
		vcpu->arch.apic_arb_prio++;
	case APIC_DM_FIXED:
E
Eddie Dong 已提交
378 379 380 381
		/* FIXME add logic for vcpu on reset */
		if (unlikely(!apic_enabled(apic)))
			break;

382 383 384 385 386 387
		if (trig_mode) {
			apic_debug("level trig mode for vector %d", vector);
			apic_set_vector(vector, apic->regs + APIC_TMR);
		} else
			apic_clear_vector(vector, apic->regs + APIC_TMR);

388
		result = !apic_test_and_set_irr(vector, apic);
389
		trace_kvm_apic_accept_irq(vcpu->vcpu_id, delivery_mode,
390
					  trig_mode, vector, !result);
391 392 393 394
		if (!result) {
			if (trig_mode)
				apic_debug("level trig mode repeatedly for "
						"vector %d", vector);
E
Eddie Dong 已提交
395 396 397
			break;
		}

398
		kvm_make_request(KVM_REQ_EVENT, vcpu);
399
		kvm_vcpu_kick(vcpu);
E
Eddie Dong 已提交
400 401 402 403 404 405 406 407 408
		break;

	case APIC_DM_REMRD:
		printk(KERN_DEBUG "Ignoring delivery mode 3\n");
		break;

	case APIC_DM_SMI:
		printk(KERN_DEBUG "Ignoring guest SMI\n");
		break;
409

E
Eddie Dong 已提交
410
	case APIC_DM_NMI:
411
		result = 1;
412
		kvm_inject_nmi(vcpu);
J
Jan Kiszka 已提交
413
		kvm_vcpu_kick(vcpu);
E
Eddie Dong 已提交
414 415 416
		break;

	case APIC_DM_INIT:
417
		if (level) {
418
			result = 1;
419
			if (vcpu->arch.mp_state == KVM_MP_STATE_RUNNABLE)
420 421 422
				printk(KERN_DEBUG
				       "INIT on a runnable vcpu %d\n",
				       vcpu->vcpu_id);
423
			vcpu->arch.mp_state = KVM_MP_STATE_INIT_RECEIVED;
424
			kvm_make_request(KVM_REQ_EVENT, vcpu);
425 426
			kvm_vcpu_kick(vcpu);
		} else {
427 428
			apic_debug("Ignoring de-assert INIT to vcpu %d\n",
				   vcpu->vcpu_id);
429
		}
E
Eddie Dong 已提交
430 431 432
		break;

	case APIC_DM_STARTUP:
433 434
		apic_debug("SIPI to vcpu %d vector 0x%02x\n",
			   vcpu->vcpu_id, vector);
435
		if (vcpu->arch.mp_state == KVM_MP_STATE_INIT_RECEIVED) {
436
			result = 1;
437
			vcpu->arch.sipi_vector = vector;
438
			vcpu->arch.mp_state = KVM_MP_STATE_SIPI_RECEIVED;
439
			kvm_make_request(KVM_REQ_EVENT, vcpu);
440
			kvm_vcpu_kick(vcpu);
441
		}
E
Eddie Dong 已提交
442 443
		break;

444 445 446 447 448 449 450 451
	case APIC_DM_EXTINT:
		/*
		 * Should only be called by kvm_apic_local_deliver() with LVT0,
		 * before NMI watchdog was enabled. Already handled by
		 * kvm_apic_accept_pic_intr().
		 */
		break;

E
Eddie Dong 已提交
452 453 454 455 456 457 458 459
	default:
		printk(KERN_ERR "TODO: unsupported delivery mode %x\n",
		       delivery_mode);
		break;
	}
	return result;
}

460
int kvm_apic_compare_prio(struct kvm_vcpu *vcpu1, struct kvm_vcpu *vcpu2)
461
{
462
	return vcpu1->arch.apic_arb_prio - vcpu2->arch.apic_arb_prio;
463 464
}

E
Eddie Dong 已提交
465 466 467
static void apic_set_eoi(struct kvm_lapic *apic)
{
	int vector = apic_find_highest_isr(apic);
M
Marcelo Tosatti 已提交
468
	int trigger_mode;
E
Eddie Dong 已提交
469 470 471 472 473 474 475 476 477 478 479
	/*
	 * Not every write EOI will has corresponding ISR,
	 * one example is when Kernel check timer on setup_IO_APIC
	 */
	if (vector == -1)
		return;

	apic_clear_vector(vector, apic->regs + APIC_ISR);
	apic_update_ppr(apic);

	if (apic_test_and_clear_vector(vector, apic->regs + APIC_TMR))
M
Marcelo Tosatti 已提交
480 481 482
		trigger_mode = IOAPIC_LEVEL_TRIG;
	else
		trigger_mode = IOAPIC_EDGE_TRIG;
G
Gleb Natapov 已提交
483
	if (!(apic_get_reg(apic, APIC_SPIV) & APIC_SPIV_DIRECTED_EOI))
484
		kvm_ioapic_update_eoi(apic->vcpu->kvm, vector, trigger_mode);
485
	kvm_make_request(KVM_REQ_EVENT, apic->vcpu);
E
Eddie Dong 已提交
486 487 488 489 490 491
}

static void apic_send_ipi(struct kvm_lapic *apic)
{
	u32 icr_low = apic_get_reg(apic, APIC_ICR);
	u32 icr_high = apic_get_reg(apic, APIC_ICR2);
492
	struct kvm_lapic_irq irq;
E
Eddie Dong 已提交
493

494 495 496 497 498 499
	irq.vector = icr_low & APIC_VECTOR_MASK;
	irq.delivery_mode = icr_low & APIC_MODE_MASK;
	irq.dest_mode = icr_low & APIC_DEST_MASK;
	irq.level = icr_low & APIC_INT_ASSERT;
	irq.trig_mode = icr_low & APIC_INT_LEVELTRIG;
	irq.shorthand = icr_low & APIC_SHORT_MASK;
G
Gleb Natapov 已提交
500 501 502 503
	if (apic_x2apic_mode(apic))
		irq.dest_id = icr_high;
	else
		irq.dest_id = GET_APIC_DEST_FIELD(icr_high);
E
Eddie Dong 已提交
504

505 506
	trace_kvm_apic_ipi(icr_low, irq.dest_id);

E
Eddie Dong 已提交
507 508 509
	apic_debug("icr_high 0x%x, icr_low 0x%x, "
		   "short_hand 0x%x, dest 0x%x, trig_mode 0x%x, level 0x%x, "
		   "dest_mode 0x%x, delivery_mode 0x%x, vector 0x%x\n",
G
Glauber Costa 已提交
510
		   icr_high, icr_low, irq.shorthand, irq.dest_id,
511 512 513 514
		   irq.trig_mode, irq.level, irq.dest_mode, irq.delivery_mode,
		   irq.vector);

	kvm_irq_delivery_to_apic(apic->vcpu->kvm, apic, &irq);
E
Eddie Dong 已提交
515 516 517 518
}

static u32 apic_get_tmcct(struct kvm_lapic *apic)
{
519 520
	ktime_t remaining;
	s64 ns;
521
	u32 tmcct;
E
Eddie Dong 已提交
522 523 524

	ASSERT(apic != NULL);

525
	/* if initial count is 0, current count should also be 0 */
526
	if (apic_get_reg(apic, APIC_TMICT) == 0)
527 528
		return 0;

529
	remaining = hrtimer_get_remaining(&apic->lapic_timer.timer);
530 531 532
	if (ktime_to_ns(remaining) < 0)
		remaining = ktime_set(0, 0);

533 534 535
	ns = mod_64(ktime_to_ns(remaining), apic->lapic_timer.period);
	tmcct = div64_u64(ns,
			 (APIC_BUS_CYCLE_NS * apic->divide_count));
E
Eddie Dong 已提交
536 537 538 539

	return tmcct;
}

540 541 542 543 544
static void __report_tpr_access(struct kvm_lapic *apic, bool write)
{
	struct kvm_vcpu *vcpu = apic->vcpu;
	struct kvm_run *run = vcpu->run;

545
	kvm_make_request(KVM_REQ_REPORT_TPR_ACCESS, vcpu);
546
	run->tpr_access.rip = kvm_rip_read(vcpu);
547 548 549 550 551 552 553 554 555
	run->tpr_access.is_write = write;
}

static inline void report_tpr_access(struct kvm_lapic *apic, bool write)
{
	if (apic->vcpu->arch.tpr_access_reporting)
		__report_tpr_access(apic, write);
}

E
Eddie Dong 已提交
556 557 558 559 560 561 562 563
static u32 __apic_read(struct kvm_lapic *apic, unsigned int offset)
{
	u32 val = 0;

	if (offset >= LAPIC_MMIO_LENGTH)
		return 0;

	switch (offset) {
G
Gleb Natapov 已提交
564 565 566 567 568 569
	case APIC_ID:
		if (apic_x2apic_mode(apic))
			val = kvm_apic_id(apic);
		else
			val = kvm_apic_id(apic) << 24;
		break;
E
Eddie Dong 已提交
570 571 572 573 574 575 576 577 578
	case APIC_ARBPRI:
		printk(KERN_WARNING "Access APIC ARBPRI register "
		       "which is for P6\n");
		break;

	case APIC_TMCCT:	/* Timer CCR */
		val = apic_get_tmcct(apic);
		break;

579 580 581
	case APIC_TASKPRI:
		report_tpr_access(apic, false);
		/* fall thru */
E
Eddie Dong 已提交
582
	default:
583
		apic_update_ppr(apic);
E
Eddie Dong 已提交
584 585 586 587 588 589 590
		val = apic_get_reg(apic, offset);
		break;
	}

	return val;
}

G
Gregory Haskins 已提交
591 592 593 594 595
static inline struct kvm_lapic *to_lapic(struct kvm_io_device *dev)
{
	return container_of(dev, struct kvm_lapic, dev);
}

G
Gleb Natapov 已提交
596 597
static int apic_reg_read(struct kvm_lapic *apic, u32 offset, int len,
		void *data)
E
Eddie Dong 已提交
598 599 600
{
	unsigned char alignment = offset & 0xf;
	u32 result;
G
Gleb Natapov 已提交
601 602
	/* this bitmask has a bit cleared for each reserver register */
	static const u64 rmask = 0x43ff01ffffffe70cULL;
E
Eddie Dong 已提交
603 604

	if ((alignment + len) > 4) {
605 606
		apic_debug("KVM_APIC_READ: alignment error %x %d\n",
			   offset, len);
G
Gleb Natapov 已提交
607
		return 1;
E
Eddie Dong 已提交
608
	}
G
Gleb Natapov 已提交
609 610

	if (offset > 0x3f0 || !(rmask & (1ULL << (offset >> 4)))) {
611 612
		apic_debug("KVM_APIC_READ: read reserved register %x\n",
			   offset);
G
Gleb Natapov 已提交
613 614 615
		return 1;
	}

E
Eddie Dong 已提交
616 617
	result = __apic_read(apic, offset & ~0xf);

618 619
	trace_kvm_apic_read(offset, result);

E
Eddie Dong 已提交
620 621 622 623 624 625 626 627 628 629 630
	switch (len) {
	case 1:
	case 2:
	case 4:
		memcpy(data, (char *)&result + alignment, len);
		break;
	default:
		printk(KERN_ERR "Local APIC read with len = %x, "
		       "should be 1,2, or 4 instead\n", len);
		break;
	}
631
	return 0;
E
Eddie Dong 已提交
632 633
}

G
Gleb Natapov 已提交
634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
static int apic_mmio_in_range(struct kvm_lapic *apic, gpa_t addr)
{
	return apic_hw_enabled(apic) &&
	    addr >= apic->base_address &&
	    addr < apic->base_address + LAPIC_MMIO_LENGTH;
}

static int apic_mmio_read(struct kvm_io_device *this,
			   gpa_t address, int len, void *data)
{
	struct kvm_lapic *apic = to_lapic(this);
	u32 offset = address - apic->base_address;

	if (!apic_mmio_in_range(apic, address))
		return -EOPNOTSUPP;

	apic_reg_read(apic, offset, len, data);

	return 0;
}

E
Eddie Dong 已提交
655 656 657 658 659 660 661
static void update_divide_count(struct kvm_lapic *apic)
{
	u32 tmp1, tmp2, tdcr;

	tdcr = apic_get_reg(apic, APIC_TDCR);
	tmp1 = tdcr & 0xf;
	tmp2 = ((tmp1 & 0x3) | ((tmp1 & 0x8) >> 1)) + 1;
662
	apic->divide_count = 0x1 << (tmp2 & 0x7);
E
Eddie Dong 已提交
663 664

	apic_debug("timer divide count is 0x%x\n",
G
Glauber Costa 已提交
665
				   apic->divide_count);
E
Eddie Dong 已提交
666 667 668 669
}

static void start_apic_timer(struct kvm_lapic *apic)
{
670
	ktime_t now = apic->lapic_timer.timer.base->get_time();
E
Eddie Dong 已提交
671

672
	apic->lapic_timer.period = (u64)apic_get_reg(apic, APIC_TMICT) *
673 674
		    APIC_BUS_CYCLE_NS * apic->divide_count;
	atomic_set(&apic->lapic_timer.pending, 0);
675

676
	if (!apic->lapic_timer.period)
677
		return;
678 679 680 681 682 683 684 685 686
	/*
	 * Do not allow the guest to program periodic timers with small
	 * interval, since the hrtimers are not throttled by the host
	 * scheduler.
	 */
	if (apic_lvtt_period(apic)) {
		if (apic->lapic_timer.period < NSEC_PER_MSEC/2)
			apic->lapic_timer.period = NSEC_PER_MSEC/2;
	}
687

688 689
	hrtimer_start(&apic->lapic_timer.timer,
		      ktime_add_ns(now, apic->lapic_timer.period),
E
Eddie Dong 已提交
690 691 692 693 694
		      HRTIMER_MODE_ABS);

	apic_debug("%s: bus cycle is %" PRId64 "ns, now 0x%016"
			   PRIx64 ", "
			   "timer initial count 0x%x, period %lldns, "
695
			   "expire @ 0x%016" PRIx64 ".\n", __func__,
E
Eddie Dong 已提交
696 697
			   APIC_BUS_CYCLE_NS, ktime_to_ns(now),
			   apic_get_reg(apic, APIC_TMICT),
698
			   apic->lapic_timer.period,
E
Eddie Dong 已提交
699
			   ktime_to_ns(ktime_add_ns(now,
700
					apic->lapic_timer.period)));
E
Eddie Dong 已提交
701 702
}

703 704 705 706 707 708 709 710 711 712 713 714 715 716
static void apic_manage_nmi_watchdog(struct kvm_lapic *apic, u32 lvt0_val)
{
	int nmi_wd_enabled = apic_lvt_nmi_mode(apic_get_reg(apic, APIC_LVT0));

	if (apic_lvt_nmi_mode(lvt0_val)) {
		if (!nmi_wd_enabled) {
			apic_debug("Receive NMI setting on APIC_LVT0 "
				   "for cpu %d\n", apic->vcpu->vcpu_id);
			apic->vcpu->kvm->arch.vapics_in_nmi_mode++;
		}
	} else if (nmi_wd_enabled)
		apic->vcpu->kvm->arch.vapics_in_nmi_mode--;
}

G
Gleb Natapov 已提交
717
static int apic_reg_write(struct kvm_lapic *apic, u32 reg, u32 val)
E
Eddie Dong 已提交
718
{
G
Gleb Natapov 已提交
719
	int ret = 0;
E
Eddie Dong 已提交
720

G
Gleb Natapov 已提交
721
	trace_kvm_apic_write(reg, val);
E
Eddie Dong 已提交
722

G
Gleb Natapov 已提交
723
	switch (reg) {
E
Eddie Dong 已提交
724
	case APIC_ID:		/* Local APIC ID */
G
Gleb Natapov 已提交
725 726 727 728
		if (!apic_x2apic_mode(apic))
			apic_set_reg(apic, APIC_ID, val);
		else
			ret = 1;
E
Eddie Dong 已提交
729 730 731
		break;

	case APIC_TASKPRI:
732
		report_tpr_access(apic, true);
E
Eddie Dong 已提交
733 734 735 736 737 738 739 740
		apic_set_tpr(apic, val & 0xff);
		break;

	case APIC_EOI:
		apic_set_eoi(apic);
		break;

	case APIC_LDR:
G
Gleb Natapov 已提交
741 742 743 744
		if (!apic_x2apic_mode(apic))
			apic_set_reg(apic, APIC_LDR, val & APIC_LDR_MASK);
		else
			ret = 1;
E
Eddie Dong 已提交
745 746 747
		break;

	case APIC_DFR:
G
Gleb Natapov 已提交
748 749 750 751
		if (!apic_x2apic_mode(apic))
			apic_set_reg(apic, APIC_DFR, val | 0x0FFFFFFF);
		else
			ret = 1;
E
Eddie Dong 已提交
752 753
		break;

754 755 756 757 758
	case APIC_SPIV: {
		u32 mask = 0x3ff;
		if (apic_get_reg(apic, APIC_LVR) & APIC_LVR_DIRECTED_EOI)
			mask |= APIC_SPIV_DIRECTED_EOI;
		apic_set_reg(apic, APIC_SPIV, val & mask);
E
Eddie Dong 已提交
759 760 761 762 763 764 765 766 767 768
		if (!(val & APIC_SPIV_APIC_ENABLED)) {
			int i;
			u32 lvt_val;

			for (i = 0; i < APIC_LVT_NUM; i++) {
				lvt_val = apic_get_reg(apic,
						       APIC_LVTT + 0x10 * i);
				apic_set_reg(apic, APIC_LVTT + 0x10 * i,
					     lvt_val | APIC_LVT_MASKED);
			}
769
			atomic_set(&apic->lapic_timer.pending, 0);
E
Eddie Dong 已提交
770 771 772

		}
		break;
773
	}
E
Eddie Dong 已提交
774 775 776 777 778 779 780
	case APIC_ICR:
		/* No delay here, so we always clear the pending bit */
		apic_set_reg(apic, APIC_ICR, val & ~(1 << 12));
		apic_send_ipi(apic);
		break;

	case APIC_ICR2:
G
Gleb Natapov 已提交
781 782 783
		if (!apic_x2apic_mode(apic))
			val &= 0xff000000;
		apic_set_reg(apic, APIC_ICR2, val);
E
Eddie Dong 已提交
784 785
		break;

786
	case APIC_LVT0:
787
		apic_manage_nmi_watchdog(apic, val);
E
Eddie Dong 已提交
788 789 790 791 792 793 794 795 796
	case APIC_LVTT:
	case APIC_LVTTHMR:
	case APIC_LVTPC:
	case APIC_LVT1:
	case APIC_LVTERR:
		/* TODO: Check vector */
		if (!apic_sw_enabled(apic))
			val |= APIC_LVT_MASKED;

G
Gleb Natapov 已提交
797 798
		val &= apic_lvt_mask[(reg - APIC_LVTT) >> 4];
		apic_set_reg(apic, reg, val);
E
Eddie Dong 已提交
799 800 801 802

		break;

	case APIC_TMICT:
803
		hrtimer_cancel(&apic->lapic_timer.timer);
E
Eddie Dong 已提交
804 805
		apic_set_reg(apic, APIC_TMICT, val);
		start_apic_timer(apic);
G
Gleb Natapov 已提交
806
		break;
E
Eddie Dong 已提交
807 808 809 810 811 812 813 814

	case APIC_TDCR:
		if (val & 4)
			printk(KERN_ERR "KVM_WRITE:TDCR %x\n", val);
		apic_set_reg(apic, APIC_TDCR, val);
		update_divide_count(apic);
		break;

G
Gleb Natapov 已提交
815 816 817 818 819 820 821 822 823 824 825 826 827
	case APIC_ESR:
		if (apic_x2apic_mode(apic) && val != 0) {
			printk(KERN_ERR "KVM_WRITE:ESR not zero %x\n", val);
			ret = 1;
		}
		break;

	case APIC_SELF_IPI:
		if (apic_x2apic_mode(apic)) {
			apic_reg_write(apic, APIC_ICR, 0x40000 | (val & 0xff));
		} else
			ret = 1;
		break;
E
Eddie Dong 已提交
828
	default:
G
Gleb Natapov 已提交
829
		ret = 1;
E
Eddie Dong 已提交
830 831
		break;
	}
G
Gleb Natapov 已提交
832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854
	if (ret)
		apic_debug("Local APIC Write to read-only register %x\n", reg);
	return ret;
}

static int apic_mmio_write(struct kvm_io_device *this,
			    gpa_t address, int len, const void *data)
{
	struct kvm_lapic *apic = to_lapic(this);
	unsigned int offset = address - apic->base_address;
	u32 val;

	if (!apic_mmio_in_range(apic, address))
		return -EOPNOTSUPP;

	/*
	 * APIC register must be aligned on 128-bits boundary.
	 * 32/64/128 bits registers must be accessed thru 32 bits.
	 * Refer SDM 8.4.1
	 */
	if (len != 4 || (offset & 0xf)) {
		/* Don't shout loud, $infamous_os would cause only noise. */
		apic_debug("apic write: bad size=%d %lx\n", len, (long)address);
855
		return 0;
G
Gleb Natapov 已提交
856 857 858 859 860 861 862 863 864 865 866
	}

	val = *(u32*)data;

	/* too common printing */
	if (offset != APIC_EOI)
		apic_debug("%s: offset 0x%x with length 0x%x, and value is "
			   "0x%x\n", __func__, offset, len, val);

	apic_reg_write(apic, offset & 0xff0, val);

867
	return 0;
E
Eddie Dong 已提交
868 869
}

870
void kvm_free_lapic(struct kvm_vcpu *vcpu)
E
Eddie Dong 已提交
871
{
872
	if (!vcpu->arch.apic)
E
Eddie Dong 已提交
873 874
		return;

875
	hrtimer_cancel(&vcpu->arch.apic->lapic_timer.timer);
E
Eddie Dong 已提交
876

877 878
	if (vcpu->arch.apic->regs_page)
		__free_page(vcpu->arch.apic->regs_page);
E
Eddie Dong 已提交
879

880
	kfree(vcpu->arch.apic);
E
Eddie Dong 已提交
881 882 883 884 885 886 887 888 889 890
}

/*
 *----------------------------------------------------------------------
 * LAPIC interface
 *----------------------------------------------------------------------
 */

void kvm_lapic_set_tpr(struct kvm_vcpu *vcpu, unsigned long cr8)
{
891
	struct kvm_lapic *apic = vcpu->arch.apic;
E
Eddie Dong 已提交
892 893 894

	if (!apic)
		return;
A
Avi Kivity 已提交
895 896
	apic_set_tpr(apic, ((cr8 & 0x0f) << 4)
		     | (apic_get_reg(apic, APIC_TASKPRI) & 4));
E
Eddie Dong 已提交
897 898 899 900
}

u64 kvm_lapic_get_cr8(struct kvm_vcpu *vcpu)
{
901
	struct kvm_lapic *apic = vcpu->arch.apic;
E
Eddie Dong 已提交
902 903 904 905 906 907 908 909 910 911 912
	u64 tpr;

	if (!apic)
		return 0;
	tpr = (u64) apic_get_reg(apic, APIC_TASKPRI);

	return (tpr & 0xf0) >> 4;
}

void kvm_lapic_set_base(struct kvm_vcpu *vcpu, u64 value)
{
913
	struct kvm_lapic *apic = vcpu->arch.apic;
E
Eddie Dong 已提交
914 915 916

	if (!apic) {
		value |= MSR_IA32_APICBASE_BSP;
917
		vcpu->arch.apic_base = value;
E
Eddie Dong 已提交
918 919
		return;
	}
920 921

	if (!kvm_vcpu_is_bsp(apic->vcpu))
E
Eddie Dong 已提交
922 923
		value &= ~MSR_IA32_APICBASE_BSP;

924
	vcpu->arch.apic_base = value;
G
Gleb Natapov 已提交
925 926 927 928 929
	if (apic_x2apic_mode(apic)) {
		u32 id = kvm_apic_id(apic);
		u32 ldr = ((id & ~0xf) << 16) | (1 << (id & 0xf));
		apic_set_reg(apic, APIC_LDR, ldr);
	}
930
	apic->base_address = apic->vcpu->arch.apic_base &
E
Eddie Dong 已提交
931 932 933 934
			     MSR_IA32_APICBASE_BASE;

	/* with FSB delivery interrupt, we can restart APIC functionality */
	apic_debug("apic base msr is 0x%016" PRIx64 ", and base address is "
935
		   "0x%lx.\n", apic->vcpu->arch.apic_base, apic->base_address);
E
Eddie Dong 已提交
936 937 938

}

939
void kvm_lapic_reset(struct kvm_vcpu *vcpu)
E
Eddie Dong 已提交
940 941 942 943
{
	struct kvm_lapic *apic;
	int i;

944
	apic_debug("%s\n", __func__);
E
Eddie Dong 已提交
945 946

	ASSERT(vcpu);
947
	apic = vcpu->arch.apic;
E
Eddie Dong 已提交
948 949 950
	ASSERT(apic != NULL);

	/* Stop the timer in case it's a reset to an active apic */
951
	hrtimer_cancel(&apic->lapic_timer.timer);
E
Eddie Dong 已提交
952 953

	apic_set_reg(apic, APIC_ID, vcpu->vcpu_id << 24);
954
	kvm_apic_set_version(apic->vcpu);
E
Eddie Dong 已提交
955 956 957

	for (i = 0; i < APIC_LVT_NUM; i++)
		apic_set_reg(apic, APIC_LVTT + 0x10 * i, APIC_LVT_MASKED);
Q
Qing He 已提交
958 959
	apic_set_reg(apic, APIC_LVT0,
		     SET_APIC_DELIVERY_MODE(0, APIC_MODE_EXTINT));
E
Eddie Dong 已提交
960 961 962 963 964 965 966 967 968 969 970 971 972 973 974

	apic_set_reg(apic, APIC_DFR, 0xffffffffU);
	apic_set_reg(apic, APIC_SPIV, 0xff);
	apic_set_reg(apic, APIC_TASKPRI, 0);
	apic_set_reg(apic, APIC_LDR, 0);
	apic_set_reg(apic, APIC_ESR, 0);
	apic_set_reg(apic, APIC_ICR, 0);
	apic_set_reg(apic, APIC_ICR2, 0);
	apic_set_reg(apic, APIC_TDCR, 0);
	apic_set_reg(apic, APIC_TMICT, 0);
	for (i = 0; i < 8; i++) {
		apic_set_reg(apic, APIC_IRR + 0x10 * i, 0);
		apic_set_reg(apic, APIC_ISR + 0x10 * i, 0);
		apic_set_reg(apic, APIC_TMR + 0x10 * i, 0);
	}
975
	apic->irr_pending = false;
976
	update_divide_count(apic);
977
	atomic_set(&apic->lapic_timer.pending, 0);
978
	if (kvm_vcpu_is_bsp(vcpu))
979
		vcpu->arch.apic_base |= MSR_IA32_APICBASE_BSP;
E
Eddie Dong 已提交
980 981
	apic_update_ppr(apic);

982 983
	vcpu->arch.apic_arb_prio = 0;

E
Eddie Dong 已提交
984
	apic_debug(KERN_INFO "%s: vcpu=%p, id=%d, base_msr="
985
		   "0x%016" PRIx64 ", base_address=0x%0lx.\n", __func__,
E
Eddie Dong 已提交
986
		   vcpu, kvm_apic_id(apic),
987
		   vcpu->arch.apic_base, apic->base_address);
E
Eddie Dong 已提交
988 989
}

990
bool kvm_apic_present(struct kvm_vcpu *vcpu)
E
Eddie Dong 已提交
991
{
992 993
	return vcpu->arch.apic && apic_hw_enabled(vcpu->arch.apic);
}
E
Eddie Dong 已提交
994

995 996 997
int kvm_lapic_enabled(struct kvm_vcpu *vcpu)
{
	return kvm_apic_present(vcpu) && apic_sw_enabled(vcpu->arch.apic);
E
Eddie Dong 已提交
998 999 1000 1001 1002 1003 1004
}

/*
 *----------------------------------------------------------------------
 * timer interface
 *----------------------------------------------------------------------
 */
1005

1006
static bool lapic_is_periodic(struct kvm_timer *ktimer)
E
Eddie Dong 已提交
1007
{
1008 1009 1010
	struct kvm_lapic *apic = container_of(ktimer, struct kvm_lapic,
					      lapic_timer);
	return apic_lvtt_period(apic);
E
Eddie Dong 已提交
1011 1012
}

1013 1014 1015 1016
int apic_has_pending_timer(struct kvm_vcpu *vcpu)
{
	struct kvm_lapic *lapic = vcpu->arch.apic;

1017
	if (lapic && apic_enabled(lapic) && apic_lvt_enabled(lapic, APIC_LVTT))
1018
		return atomic_read(&lapic->lapic_timer.pending);
1019 1020 1021 1022

	return 0;
}

1023
static int kvm_apic_local_deliver(struct kvm_lapic *apic, int lvt_type)
1024
{
1025
	u32 reg = apic_get_reg(apic, lvt_type);
1026 1027
	int vector, mode, trig_mode;

1028
	if (apic_hw_enabled(apic) && !(reg & APIC_LVT_MASKED)) {
1029 1030 1031 1032 1033 1034 1035
		vector = reg & APIC_VECTOR_MASK;
		mode = reg & APIC_MODE_MASK;
		trig_mode = reg & APIC_LVT_LEVEL_TRIGGER;
		return __apic_accept_irq(apic, mode, vector, 1, trig_mode);
	}
	return 0;
}
1036

1037
void kvm_apic_nmi_wd_deliver(struct kvm_vcpu *vcpu)
1038
{
1039 1040 1041 1042
	struct kvm_lapic *apic = vcpu->arch.apic;

	if (apic)
		kvm_apic_local_deliver(apic, APIC_LVT0);
1043 1044
}

1045
static struct kvm_timer_ops lapic_timer_ops = {
1046 1047
	.is_periodic = lapic_is_periodic,
};
E
Eddie Dong 已提交
1048

G
Gregory Haskins 已提交
1049 1050 1051 1052 1053
static const struct kvm_io_device_ops apic_mmio_ops = {
	.read     = apic_mmio_read,
	.write    = apic_mmio_write,
};

E
Eddie Dong 已提交
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
int kvm_create_lapic(struct kvm_vcpu *vcpu)
{
	struct kvm_lapic *apic;

	ASSERT(vcpu != NULL);
	apic_debug("apic_init %d\n", vcpu->vcpu_id);

	apic = kzalloc(sizeof(*apic), GFP_KERNEL);
	if (!apic)
		goto nomem;

1065
	vcpu->arch.apic = apic;
E
Eddie Dong 已提交
1066 1067 1068 1069 1070

	apic->regs_page = alloc_page(GFP_KERNEL);
	if (apic->regs_page == NULL) {
		printk(KERN_ERR "malloc apic regs error for vcpu %x\n",
		       vcpu->vcpu_id);
1071
		goto nomem_free_apic;
E
Eddie Dong 已提交
1072 1073 1074 1075 1076
	}
	apic->regs = page_address(apic->regs_page);
	memset(apic->regs, 0, PAGE_SIZE);
	apic->vcpu = vcpu;

1077 1078 1079 1080 1081
	hrtimer_init(&apic->lapic_timer.timer, CLOCK_MONOTONIC,
		     HRTIMER_MODE_ABS);
	apic->lapic_timer.timer.function = kvm_timer_fn;
	apic->lapic_timer.t_ops = &lapic_timer_ops;
	apic->lapic_timer.kvm = vcpu->kvm;
1082
	apic->lapic_timer.vcpu = vcpu;
1083

E
Eddie Dong 已提交
1084
	apic->base_address = APIC_DEFAULT_PHYS_BASE;
1085
	vcpu->arch.apic_base = APIC_DEFAULT_PHYS_BASE;
E
Eddie Dong 已提交
1086

1087
	kvm_lapic_reset(vcpu);
G
Gregory Haskins 已提交
1088
	kvm_iodevice_init(&apic->dev, &apic_mmio_ops);
E
Eddie Dong 已提交
1089 1090

	return 0;
1091 1092
nomem_free_apic:
	kfree(apic);
E
Eddie Dong 已提交
1093 1094 1095 1096 1097 1098
nomem:
	return -ENOMEM;
}

int kvm_apic_has_interrupt(struct kvm_vcpu *vcpu)
{
1099
	struct kvm_lapic *apic = vcpu->arch.apic;
E
Eddie Dong 已提交
1100 1101 1102 1103 1104
	int highest_irr;

	if (!apic || !apic_enabled(apic))
		return -1;

1105
	apic_update_ppr(apic);
E
Eddie Dong 已提交
1106 1107 1108 1109 1110 1111 1112
	highest_irr = apic_find_highest_irr(apic);
	if ((highest_irr == -1) ||
	    ((highest_irr & 0xF0) <= apic_get_reg(apic, APIC_PROCPRI)))
		return -1;
	return highest_irr;
}

Q
Qing He 已提交
1113 1114
int kvm_apic_accept_pic_intr(struct kvm_vcpu *vcpu)
{
1115
	u32 lvt0 = apic_get_reg(vcpu->arch.apic, APIC_LVT0);
Q
Qing He 已提交
1116 1117
	int r = 0;

1118 1119 1120 1121 1122
	if (!apic_hw_enabled(vcpu->arch.apic))
		r = 1;
	if ((lvt0 & APIC_LVT_MASKED) == 0 &&
	    GET_APIC_DELIVERY_MODE(lvt0) == APIC_MODE_EXTINT)
		r = 1;
Q
Qing He 已提交
1123 1124 1125
	return r;
}

1126 1127
void kvm_inject_apic_timer_irqs(struct kvm_vcpu *vcpu)
{
1128
	struct kvm_lapic *apic = vcpu->arch.apic;
1129

1130
	if (apic && atomic_read(&apic->lapic_timer.pending) > 0) {
1131
		if (kvm_apic_local_deliver(apic, APIC_LVTT))
1132
			atomic_dec(&apic->lapic_timer.pending);
1133 1134 1135
	}
}

E
Eddie Dong 已提交
1136 1137 1138
int kvm_get_apic_interrupt(struct kvm_vcpu *vcpu)
{
	int vector = kvm_apic_has_interrupt(vcpu);
1139
	struct kvm_lapic *apic = vcpu->arch.apic;
E
Eddie Dong 已提交
1140 1141 1142 1143 1144 1145 1146 1147 1148

	if (vector == -1)
		return -1;

	apic_set_vector(vector, apic->regs + APIC_ISR);
	apic_update_ppr(apic);
	apic_clear_irr(vector, apic);
	return vector;
}
1149 1150 1151

void kvm_apic_post_state_restore(struct kvm_vcpu *vcpu)
{
1152
	struct kvm_lapic *apic = vcpu->arch.apic;
1153

1154
	apic->base_address = vcpu->arch.apic_base &
1155
			     MSR_IA32_APICBASE_BASE;
1156 1157
	kvm_apic_set_version(vcpu);

1158
	apic_update_ppr(apic);
1159
	hrtimer_cancel(&apic->lapic_timer.timer);
1160 1161
	update_divide_count(apic);
	start_apic_timer(apic);
1162
	apic->irr_pending = true;
1163
	kvm_make_request(KVM_REQ_EVENT, vcpu);
1164
}
1165

1166
void __kvm_migrate_apic_timer(struct kvm_vcpu *vcpu)
1167
{
1168
	struct kvm_lapic *apic = vcpu->arch.apic;
1169 1170 1171 1172 1173
	struct hrtimer *timer;

	if (!apic)
		return;

1174
	timer = &apic->lapic_timer.timer;
1175
	if (hrtimer_cancel(timer))
1176
		hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
1177
}
A
Avi Kivity 已提交
1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225

void kvm_lapic_sync_from_vapic(struct kvm_vcpu *vcpu)
{
	u32 data;
	void *vapic;

	if (!irqchip_in_kernel(vcpu->kvm) || !vcpu->arch.apic->vapic_addr)
		return;

	vapic = kmap_atomic(vcpu->arch.apic->vapic_page, KM_USER0);
	data = *(u32 *)(vapic + offset_in_page(vcpu->arch.apic->vapic_addr));
	kunmap_atomic(vapic, KM_USER0);

	apic_set_tpr(vcpu->arch.apic, data & 0xff);
}

void kvm_lapic_sync_to_vapic(struct kvm_vcpu *vcpu)
{
	u32 data, tpr;
	int max_irr, max_isr;
	struct kvm_lapic *apic;
	void *vapic;

	if (!irqchip_in_kernel(vcpu->kvm) || !vcpu->arch.apic->vapic_addr)
		return;

	apic = vcpu->arch.apic;
	tpr = apic_get_reg(apic, APIC_TASKPRI) & 0xff;
	max_irr = apic_find_highest_irr(apic);
	if (max_irr < 0)
		max_irr = 0;
	max_isr = apic_find_highest_isr(apic);
	if (max_isr < 0)
		max_isr = 0;
	data = (tpr & 0xff) | ((max_isr & 0xf0) << 8) | (max_irr << 24);

	vapic = kmap_atomic(vcpu->arch.apic->vapic_page, KM_USER0);
	*(u32 *)(vapic + offset_in_page(vcpu->arch.apic->vapic_addr)) = data;
	kunmap_atomic(vapic, KM_USER0);
}

void kvm_lapic_set_vapic_addr(struct kvm_vcpu *vcpu, gpa_t vapic_addr)
{
	if (!irqchip_in_kernel(vcpu->kvm))
		return;

	vcpu->arch.apic->vapic_addr = vapic_addr;
}
G
Gleb Natapov 已提交
1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257

int kvm_x2apic_msr_write(struct kvm_vcpu *vcpu, u32 msr, u64 data)
{
	struct kvm_lapic *apic = vcpu->arch.apic;
	u32 reg = (msr - APIC_BASE_MSR) << 4;

	if (!irqchip_in_kernel(vcpu->kvm) || !apic_x2apic_mode(apic))
		return 1;

	/* if this is ICR write vector before command */
	if (msr == 0x830)
		apic_reg_write(apic, APIC_ICR2, (u32)(data >> 32));
	return apic_reg_write(apic, reg, (u32)data);
}

int kvm_x2apic_msr_read(struct kvm_vcpu *vcpu, u32 msr, u64 *data)
{
	struct kvm_lapic *apic = vcpu->arch.apic;
	u32 reg = (msr - APIC_BASE_MSR) << 4, low, high = 0;

	if (!irqchip_in_kernel(vcpu->kvm) || !apic_x2apic_mode(apic))
		return 1;

	if (apic_reg_read(apic, reg, 4, &low))
		return 1;
	if (msr == 0x830)
		apic_reg_read(apic, APIC_ICR2, 4, &high);

	*data = (((u64)high) << 32) | low;

	return 0;
}
G
Gleb Natapov 已提交
1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288

int kvm_hv_vapic_msr_write(struct kvm_vcpu *vcpu, u32 reg, u64 data)
{
	struct kvm_lapic *apic = vcpu->arch.apic;

	if (!irqchip_in_kernel(vcpu->kvm))
		return 1;

	/* if this is ICR write vector before command */
	if (reg == APIC_ICR)
		apic_reg_write(apic, APIC_ICR2, (u32)(data >> 32));
	return apic_reg_write(apic, reg, (u32)data);
}

int kvm_hv_vapic_msr_read(struct kvm_vcpu *vcpu, u32 reg, u64 *data)
{
	struct kvm_lapic *apic = vcpu->arch.apic;
	u32 low, high = 0;

	if (!irqchip_in_kernel(vcpu->kvm))
		return 1;

	if (apic_reg_read(apic, reg, 4, &low))
		return 1;
	if (reg == APIC_ICR)
		apic_reg_read(apic, APIC_ICR2, 4, &high);

	*data = (((u64)high) << 32) | low;

	return 0;
}