lapic.c 29.3 KB
Newer Older
E
Eddie Dong 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

/*
 * Local APIC virtualization
 *
 * Copyright (C) 2006 Qumranet, Inc.
 * Copyright (C) 2007 Novell
 * Copyright (C) 2007 Intel
 *
 * 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.
 */

20
#include <linux/kvm_host.h>
E
Eddie Dong 已提交
21 22 23 24 25 26 27
#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 已提交
28
#include <linux/math64.h>
E
Eddie Dong 已提交
29 30 31 32 33 34
#include <asm/processor.h>
#include <asm/msr.h>
#include <asm/page.h>
#include <asm/current.h>
#include <asm/apicdef.h>
#include <asm/atomic.h>
G
Gleb Natapov 已提交
35
#include <asm/apicdef.h>
36
#include "kvm_cache_regs.h"
E
Eddie Dong 已提交
37
#include "irq.h"
38
#include "trace.h"
39
#include "x86.h"
E
Eddie Dong 已提交
40

41 42 43 44 45 46
#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 已提交
47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
#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)
69

E
Eddie Dong 已提交
70 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
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)
{
102
	return (apic)->vcpu->arch.apic_base & MSR_IA32_APICBASE_ENABLE;
E
Eddie Dong 已提交
103 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
}

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;
}

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

147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
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 已提交
162 163 164 165 166
static inline int apic_x2apic_mode(struct kvm_lapic *apic)
{
	return apic->vcpu->arch.apic_base & X2APIC_ENABLE;
}

E
Eddie Dong 已提交
167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
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)
{
191
	apic->irr_pending = true;
E
Eddie Dong 已提交
192 193 194
	return apic_test_and_set_vector(vec, apic->regs + APIC_IRR);
}

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

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

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

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

	return result;
}

213 214 215 216 217 218 219 220
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;
}

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

226 227 228 229 230
	/* 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.
	 */
231 232 233 234 235 236 237
	if (!apic)
		return 0;
	highest_irr = apic_find_highest_irr(apic);

	return highest_irr;
}

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

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

245 246
	return __apic_accept_irq(apic, irq->delivery_mode, irq->vector,
			irq->level, irq->trig_mode);
E
Eddie Dong 已提交
247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
}

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)
{
	u32 tpr, isrv, ppr;
	int isr;

	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);

	apic_set_reg(apic, APIC_PROCPRI, ppr);
}

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)
{
287
	return dest == 0xff || kvm_apic_id(apic) == dest;
E
Eddie Dong 已提交
288 289 290 291 292
}

int kvm_apic_match_logical_addr(struct kvm_lapic *apic, u8 mda)
{
	int result = 0;
G
Gleb Natapov 已提交
293 294 295 296 297 298
	u32 logical_id;

	if (apic_x2apic_mode(apic)) {
		logical_id = apic_get_reg(apic, APIC_LDR);
		return logical_id & mda;
	}
E
Eddie Dong 已提交
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320

	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;
}

321
int kvm_apic_match_dest(struct kvm_vcpu *vcpu, struct kvm_lapic *source,
E
Eddie Dong 已提交
322 323 324
			   int short_hand, int dest, int dest_mode)
{
	int result = 0;
325
	struct kvm_lapic *target = vcpu->arch.apic;
E
Eddie Dong 已提交
326 327

	apic_debug("target %p, source %p, dest 0x%x, "
328
		   "dest_mode 0x%x, short_hand 0x%x\n",
E
Eddie Dong 已提交
329 330 331 332 333
		   target, source, dest, dest_mode, short_hand);

	ASSERT(!target);
	switch (short_hand) {
	case APIC_DEST_NOSHORT:
334
		if (dest_mode == 0)
E
Eddie Dong 已提交
335
			/* Physical mode. */
336 337
			result = kvm_apic_match_physical_addr(target, dest);
		else
E
Eddie Dong 已提交
338 339 340 341
			/* Logical mode. */
			result = kvm_apic_match_logical_addr(target, dest);
		break;
	case APIC_DEST_SELF:
342
		result = (target == source);
E
Eddie Dong 已提交
343 344 345 346 347
		break;
	case APIC_DEST_ALLINC:
		result = 1;
		break;
	case APIC_DEST_ALLBUT:
348
		result = (target != source);
E
Eddie Dong 已提交
349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365
		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)
{
366
	int result = 0;
367
	struct kvm_vcpu *vcpu = apic->vcpu;
E
Eddie Dong 已提交
368 369 370

	switch (delivery_mode) {
	case APIC_DM_LOWEST:
371 372
		vcpu->arch.apic_arb_prio++;
	case APIC_DM_FIXED:
E
Eddie Dong 已提交
373 374 375 376
		/* FIXME add logic for vcpu on reset */
		if (unlikely(!apic_enabled(apic)))
			break;

377
		result = !apic_test_and_set_irr(vector, apic);
378 379
		trace_kvm_apic_accept_irq(vcpu->vcpu_id, delivery_mode,
					  trig_mode, vector, result);
380 381 382 383
		if (!result) {
			if (trig_mode)
				apic_debug("level trig mode repeatedly for "
						"vector %d", vector);
E
Eddie Dong 已提交
384 385 386 387 388 389 390 391
			break;
		}

		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);
392
		kvm_vcpu_kick(vcpu);
E
Eddie Dong 已提交
393 394 395 396 397 398 399 400 401
		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;
402

E
Eddie Dong 已提交
403
	case APIC_DM_NMI:
404
		result = 1;
405
		kvm_inject_nmi(vcpu);
J
Jan Kiszka 已提交
406
		kvm_vcpu_kick(vcpu);
E
Eddie Dong 已提交
407 408 409
		break;

	case APIC_DM_INIT:
410
		if (level) {
411
			result = 1;
412
			if (vcpu->arch.mp_state == KVM_MP_STATE_RUNNABLE)
413 414 415
				printk(KERN_DEBUG
				       "INIT on a runnable vcpu %d\n",
				       vcpu->vcpu_id);
416
			vcpu->arch.mp_state = KVM_MP_STATE_INIT_RECEIVED;
417 418
			kvm_vcpu_kick(vcpu);
		} else {
419 420
			apic_debug("Ignoring de-assert INIT to vcpu %d\n",
				   vcpu->vcpu_id);
421
		}
E
Eddie Dong 已提交
422 423 424
		break;

	case APIC_DM_STARTUP:
425 426
		apic_debug("SIPI to vcpu %d vector 0x%02x\n",
			   vcpu->vcpu_id, vector);
427
		if (vcpu->arch.mp_state == KVM_MP_STATE_INIT_RECEIVED) {
428
			result = 1;
429
			vcpu->arch.sipi_vector = vector;
430
			vcpu->arch.mp_state = KVM_MP_STATE_SIPI_RECEIVED;
431
			kvm_vcpu_kick(vcpu);
432
		}
E
Eddie Dong 已提交
433 434
		break;

435 436 437 438 439 440 441 442
	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 已提交
443 444 445 446 447 448 449 450
	default:
		printk(KERN_ERR "TODO: unsupported delivery mode %x\n",
		       delivery_mode);
		break;
	}
	return result;
}

451
int kvm_apic_compare_prio(struct kvm_vcpu *vcpu1, struct kvm_vcpu *vcpu2)
452
{
453
	return vcpu1->arch.apic_arb_prio - vcpu2->arch.apic_arb_prio;
454 455
}

E
Eddie Dong 已提交
456 457 458
static void apic_set_eoi(struct kvm_lapic *apic)
{
	int vector = apic_find_highest_isr(apic);
M
Marcelo Tosatti 已提交
459
	int trigger_mode;
E
Eddie Dong 已提交
460 461 462 463 464 465 466 467 468 469 470
	/*
	 * 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 已提交
471 472 473
		trigger_mode = IOAPIC_LEVEL_TRIG;
	else
		trigger_mode = IOAPIC_EDGE_TRIG;
474 475 476 477 478
	if (!(apic_get_reg(apic, APIC_SPIV) & APIC_SPIV_DIRECTED_EOI)) {
		mutex_lock(&apic->vcpu->kvm->irq_lock);
		kvm_ioapic_update_eoi(apic->vcpu->kvm, vector, trigger_mode);
		mutex_unlock(&apic->vcpu->kvm->irq_lock);
	}
E
Eddie Dong 已提交
479 480 481 482 483 484
}

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);
485
	struct kvm_lapic_irq irq;
E
Eddie Dong 已提交
486

487 488 489 490 491 492
	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 已提交
493 494 495 496
	if (apic_x2apic_mode(apic))
		irq.dest_id = icr_high;
	else
		irq.dest_id = GET_APIC_DEST_FIELD(icr_high);
E
Eddie Dong 已提交
497

498 499
	trace_kvm_apic_ipi(icr_low, irq.dest_id);

E
Eddie Dong 已提交
500 501 502
	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 已提交
503
		   icr_high, icr_low, irq.shorthand, irq.dest_id,
504 505 506
		   irq.trig_mode, irq.level, irq.dest_mode, irq.delivery_mode,
		   irq.vector);

507
	mutex_lock(&apic->vcpu->kvm->irq_lock);
508
	kvm_irq_delivery_to_apic(apic->vcpu->kvm, apic, &irq);
509
	mutex_unlock(&apic->vcpu->kvm->irq_lock);
E
Eddie Dong 已提交
510 511 512 513
}

static u32 apic_get_tmcct(struct kvm_lapic *apic)
{
514 515
	ktime_t remaining;
	s64 ns;
516
	u32 tmcct;
E
Eddie Dong 已提交
517 518 519

	ASSERT(apic != NULL);

520
	/* if initial count is 0, current count should also be 0 */
521
	if (apic_get_reg(apic, APIC_TMICT) == 0)
522 523
		return 0;

524
	remaining = hrtimer_expires_remaining(&apic->lapic_timer.timer);
525 526 527
	if (ktime_to_ns(remaining) < 0)
		remaining = ktime_set(0, 0);

528 529 530
	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 已提交
531 532 533 534

	return tmcct;
}

535 536 537 538 539 540
static void __report_tpr_access(struct kvm_lapic *apic, bool write)
{
	struct kvm_vcpu *vcpu = apic->vcpu;
	struct kvm_run *run = vcpu->run;

	set_bit(KVM_REQ_REPORT_TPR_ACCESS, &vcpu->requests);
541
	run->tpr_access.rip = kvm_rip_read(vcpu);
542 543 544 545 546 547 548 549 550
	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 已提交
551 552 553 554 555 556 557 558
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 已提交
559 560 561 562 563 564
	case APIC_ID:
		if (apic_x2apic_mode(apic))
			val = kvm_apic_id(apic);
		else
			val = kvm_apic_id(apic) << 24;
		break;
E
Eddie Dong 已提交
565 566 567 568 569 570 571 572 573
	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;

574 575 576
	case APIC_TASKPRI:
		report_tpr_access(apic, false);
		/* fall thru */
E
Eddie Dong 已提交
577
	default:
578
		apic_update_ppr(apic);
E
Eddie Dong 已提交
579 580 581 582 583 584 585
		val = apic_get_reg(apic, offset);
		break;
	}

	return val;
}

G
Gregory Haskins 已提交
586 587 588 589 590
static inline struct kvm_lapic *to_lapic(struct kvm_io_device *dev)
{
	return container_of(dev, struct kvm_lapic, dev);
}

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

	if ((alignment + len) > 4) {
600 601
		apic_debug("KVM_APIC_READ: alignment error %x %d\n",
			   offset, len);
G
Gleb Natapov 已提交
602
		return 1;
E
Eddie Dong 已提交
603
	}
G
Gleb Natapov 已提交
604 605

	if (offset > 0x3f0 || !(rmask & (1ULL << (offset >> 4)))) {
606 607
		apic_debug("KVM_APIC_READ: read reserved register %x\n",
			   offset);
G
Gleb Natapov 已提交
608 609 610
		return 1;
	}

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

613 614
	trace_kvm_apic_read(offset, result);

E
Eddie Dong 已提交
615 616 617 618 619 620 621 622 623 624 625
	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;
	}
626
	return 0;
E
Eddie Dong 已提交
627 628
}

G
Gleb Natapov 已提交
629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649
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 已提交
650 651 652 653 654 655 656
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;
657
	apic->divide_count = 0x1 << (tmp2 & 0x7);
E
Eddie Dong 已提交
658 659

	apic_debug("timer divide count is 0x%x\n",
G
Glauber Costa 已提交
660
				   apic->divide_count);
E
Eddie Dong 已提交
661 662 663 664
}

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

667 668 669
	apic->lapic_timer.period = apic_get_reg(apic, APIC_TMICT) *
		    APIC_BUS_CYCLE_NS * apic->divide_count;
	atomic_set(&apic->lapic_timer.pending, 0);
670

671
	if (!apic->lapic_timer.period)
672 673
		return;

674 675
	hrtimer_start(&apic->lapic_timer.timer,
		      ktime_add_ns(now, apic->lapic_timer.period),
E
Eddie Dong 已提交
676 677 678 679 680
		      HRTIMER_MODE_ABS);

	apic_debug("%s: bus cycle is %" PRId64 "ns, now 0x%016"
			   PRIx64 ", "
			   "timer initial count 0x%x, period %lldns, "
681
			   "expire @ 0x%016" PRIx64 ".\n", __func__,
E
Eddie Dong 已提交
682 683
			   APIC_BUS_CYCLE_NS, ktime_to_ns(now),
			   apic_get_reg(apic, APIC_TMICT),
684
			   apic->lapic_timer.period,
E
Eddie Dong 已提交
685
			   ktime_to_ns(ktime_add_ns(now,
686
					apic->lapic_timer.period)));
E
Eddie Dong 已提交
687 688
}

689 690 691 692 693 694 695 696 697 698 699 700 701 702
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 已提交
703
static int apic_reg_write(struct kvm_lapic *apic, u32 reg, u32 val)
E
Eddie Dong 已提交
704
{
G
Gleb Natapov 已提交
705
	int ret = 0;
E
Eddie Dong 已提交
706

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

G
Gleb Natapov 已提交
709
	switch (reg) {
E
Eddie Dong 已提交
710
	case APIC_ID:		/* Local APIC ID */
G
Gleb Natapov 已提交
711 712 713 714
		if (!apic_x2apic_mode(apic))
			apic_set_reg(apic, APIC_ID, val);
		else
			ret = 1;
E
Eddie Dong 已提交
715 716 717
		break;

	case APIC_TASKPRI:
718
		report_tpr_access(apic, true);
E
Eddie Dong 已提交
719 720 721 722 723 724 725 726
		apic_set_tpr(apic, val & 0xff);
		break;

	case APIC_EOI:
		apic_set_eoi(apic);
		break;

	case APIC_LDR:
G
Gleb Natapov 已提交
727 728 729 730
		if (!apic_x2apic_mode(apic))
			apic_set_reg(apic, APIC_LDR, val & APIC_LDR_MASK);
		else
			ret = 1;
E
Eddie Dong 已提交
731 732 733
		break;

	case APIC_DFR:
G
Gleb Natapov 已提交
734 735 736 737
		if (!apic_x2apic_mode(apic))
			apic_set_reg(apic, APIC_DFR, val | 0x0FFFFFFF);
		else
			ret = 1;
E
Eddie Dong 已提交
738 739
		break;

740 741 742 743 744
	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 已提交
745 746 747 748 749 750 751 752 753 754
		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);
			}
755
			atomic_set(&apic->lapic_timer.pending, 0);
E
Eddie Dong 已提交
756 757 758

		}
		break;
759
	}
E
Eddie Dong 已提交
760 761 762 763 764 765 766
	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 已提交
767 768 769
		if (!apic_x2apic_mode(apic))
			val &= 0xff000000;
		apic_set_reg(apic, APIC_ICR2, val);
E
Eddie Dong 已提交
770 771
		break;

772
	case APIC_LVT0:
773
		apic_manage_nmi_watchdog(apic, val);
E
Eddie Dong 已提交
774 775 776 777 778 779 780 781 782
	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 已提交
783 784
		val &= apic_lvt_mask[(reg - APIC_LVTT) >> 4];
		apic_set_reg(apic, reg, val);
E
Eddie Dong 已提交
785 786 787 788

		break;

	case APIC_TMICT:
789
		hrtimer_cancel(&apic->lapic_timer.timer);
E
Eddie Dong 已提交
790 791
		apic_set_reg(apic, APIC_TMICT, val);
		start_apic_timer(apic);
G
Gleb Natapov 已提交
792
		break;
E
Eddie Dong 已提交
793 794 795 796 797 798 799 800

	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 已提交
801 802 803 804 805 806 807 808 809 810 811 812 813
	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 已提交
814
	default:
G
Gleb Natapov 已提交
815
		ret = 1;
E
Eddie Dong 已提交
816 817
		break;
	}
G
Gleb Natapov 已提交
818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840
	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);
841
		return 0;
G
Gleb Natapov 已提交
842 843 844 845 846 847 848 849 850 851 852
	}

	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);

853
	return 0;
E
Eddie Dong 已提交
854 855
}

856
void kvm_free_lapic(struct kvm_vcpu *vcpu)
E
Eddie Dong 已提交
857
{
858
	if (!vcpu->arch.apic)
E
Eddie Dong 已提交
859 860
		return;

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

863 864
	if (vcpu->arch.apic->regs_page)
		__free_page(vcpu->arch.apic->regs_page);
E
Eddie Dong 已提交
865

866
	kfree(vcpu->arch.apic);
E
Eddie Dong 已提交
867 868 869 870 871 872 873 874 875 876
}

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

void kvm_lapic_set_tpr(struct kvm_vcpu *vcpu, unsigned long cr8)
{
877
	struct kvm_lapic *apic = vcpu->arch.apic;
E
Eddie Dong 已提交
878 879 880

	if (!apic)
		return;
A
Avi Kivity 已提交
881 882
	apic_set_tpr(apic, ((cr8 & 0x0f) << 4)
		     | (apic_get_reg(apic, APIC_TASKPRI) & 4));
E
Eddie Dong 已提交
883 884 885 886
}

u64 kvm_lapic_get_cr8(struct kvm_vcpu *vcpu)
{
887
	struct kvm_lapic *apic = vcpu->arch.apic;
E
Eddie Dong 已提交
888 889 890 891 892 893 894 895 896 897 898
	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)
{
899
	struct kvm_lapic *apic = vcpu->arch.apic;
E
Eddie Dong 已提交
900 901 902

	if (!apic) {
		value |= MSR_IA32_APICBASE_BSP;
903
		vcpu->arch.apic_base = value;
E
Eddie Dong 已提交
904 905
		return;
	}
906 907

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

910
	vcpu->arch.apic_base = value;
G
Gleb Natapov 已提交
911 912 913 914 915
	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);
	}
916
	apic->base_address = apic->vcpu->arch.apic_base &
E
Eddie Dong 已提交
917 918 919 920
			     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 "
921
		   "0x%lx.\n", apic->vcpu->arch.apic_base, apic->base_address);
E
Eddie Dong 已提交
922 923 924

}

925
void kvm_lapic_reset(struct kvm_vcpu *vcpu)
E
Eddie Dong 已提交
926 927 928 929
{
	struct kvm_lapic *apic;
	int i;

930
	apic_debug("%s\n", __func__);
E
Eddie Dong 已提交
931 932

	ASSERT(vcpu);
933
	apic = vcpu->arch.apic;
E
Eddie Dong 已提交
934 935 936
	ASSERT(apic != NULL);

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

	apic_set_reg(apic, APIC_ID, vcpu->vcpu_id << 24);
940
	kvm_apic_set_version(apic->vcpu);
E
Eddie Dong 已提交
941 942 943

	for (i = 0; i < APIC_LVT_NUM; i++)
		apic_set_reg(apic, APIC_LVTT + 0x10 * i, APIC_LVT_MASKED);
Q
Qing He 已提交
944 945
	apic_set_reg(apic, APIC_LVT0,
		     SET_APIC_DELIVERY_MODE(0, APIC_MODE_EXTINT));
E
Eddie Dong 已提交
946 947 948 949 950 951 952 953 954 955 956 957 958 959 960

	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);
	}
961
	apic->irr_pending = false;
962
	update_divide_count(apic);
963
	atomic_set(&apic->lapic_timer.pending, 0);
964
	if (kvm_vcpu_is_bsp(vcpu))
965
		vcpu->arch.apic_base |= MSR_IA32_APICBASE_BSP;
E
Eddie Dong 已提交
966 967
	apic_update_ppr(apic);

968 969
	vcpu->arch.apic_arb_prio = 0;

E
Eddie Dong 已提交
970
	apic_debug(KERN_INFO "%s: vcpu=%p, id=%d, base_msr="
971
		   "0x%016" PRIx64 ", base_address=0x%0lx.\n", __func__,
E
Eddie Dong 已提交
972
		   vcpu, kvm_apic_id(apic),
973
		   vcpu->arch.apic_base, apic->base_address);
E
Eddie Dong 已提交
974 975
}

976
bool kvm_apic_present(struct kvm_vcpu *vcpu)
E
Eddie Dong 已提交
977
{
978 979
	return vcpu->arch.apic && apic_hw_enabled(vcpu->arch.apic);
}
E
Eddie Dong 已提交
980

981 982 983
int kvm_lapic_enabled(struct kvm_vcpu *vcpu)
{
	return kvm_apic_present(vcpu) && apic_sw_enabled(vcpu->arch.apic);
E
Eddie Dong 已提交
984 985 986 987 988 989 990
}

/*
 *----------------------------------------------------------------------
 * timer interface
 *----------------------------------------------------------------------
 */
991

992
static bool lapic_is_periodic(struct kvm_timer *ktimer)
E
Eddie Dong 已提交
993
{
994 995 996
	struct kvm_lapic *apic = container_of(ktimer, struct kvm_lapic,
					      lapic_timer);
	return apic_lvtt_period(apic);
E
Eddie Dong 已提交
997 998
}

999 1000 1001 1002
int apic_has_pending_timer(struct kvm_vcpu *vcpu)
{
	struct kvm_lapic *lapic = vcpu->arch.apic;

1003
	if (lapic && apic_enabled(lapic) && apic_lvt_enabled(lapic, APIC_LVTT))
1004
		return atomic_read(&lapic->lapic_timer.pending);
1005 1006 1007 1008

	return 0;
}

1009
static int kvm_apic_local_deliver(struct kvm_lapic *apic, int lvt_type)
1010
{
1011
	u32 reg = apic_get_reg(apic, lvt_type);
1012 1013
	int vector, mode, trig_mode;

1014
	if (apic_hw_enabled(apic) && !(reg & APIC_LVT_MASKED)) {
1015 1016 1017 1018 1019 1020 1021
		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;
}
1022

1023
void kvm_apic_nmi_wd_deliver(struct kvm_vcpu *vcpu)
1024
{
1025 1026 1027 1028
	struct kvm_lapic *apic = vcpu->arch.apic;

	if (apic)
		kvm_apic_local_deliver(apic, APIC_LVT0);
1029 1030
}

1031
static struct kvm_timer_ops lapic_timer_ops = {
1032 1033
	.is_periodic = lapic_is_periodic,
};
E
Eddie Dong 已提交
1034

G
Gregory Haskins 已提交
1035 1036 1037 1038 1039
static const struct kvm_io_device_ops apic_mmio_ops = {
	.read     = apic_mmio_read,
	.write    = apic_mmio_write,
};

E
Eddie Dong 已提交
1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
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;

1051
	vcpu->arch.apic = apic;
E
Eddie Dong 已提交
1052 1053 1054 1055 1056

	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);
1057
		goto nomem_free_apic;
E
Eddie Dong 已提交
1058 1059 1060 1061 1062
	}
	apic->regs = page_address(apic->regs_page);
	memset(apic->regs, 0, PAGE_SIZE);
	apic->vcpu = vcpu;

1063 1064 1065 1066 1067
	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;
1068
	apic->lapic_timer.vcpu = vcpu;
1069

E
Eddie Dong 已提交
1070
	apic->base_address = APIC_DEFAULT_PHYS_BASE;
1071
	vcpu->arch.apic_base = APIC_DEFAULT_PHYS_BASE;
E
Eddie Dong 已提交
1072

1073
	kvm_lapic_reset(vcpu);
G
Gregory Haskins 已提交
1074
	kvm_iodevice_init(&apic->dev, &apic_mmio_ops);
E
Eddie Dong 已提交
1075 1076

	return 0;
1077 1078
nomem_free_apic:
	kfree(apic);
E
Eddie Dong 已提交
1079 1080 1081 1082 1083 1084
nomem:
	return -ENOMEM;
}

int kvm_apic_has_interrupt(struct kvm_vcpu *vcpu)
{
1085
	struct kvm_lapic *apic = vcpu->arch.apic;
E
Eddie Dong 已提交
1086 1087 1088 1089 1090
	int highest_irr;

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

1091
	apic_update_ppr(apic);
E
Eddie Dong 已提交
1092 1093 1094 1095 1096 1097 1098
	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 已提交
1099 1100
int kvm_apic_accept_pic_intr(struct kvm_vcpu *vcpu)
{
1101
	u32 lvt0 = apic_get_reg(vcpu->arch.apic, APIC_LVT0);
Q
Qing He 已提交
1102 1103
	int r = 0;

1104
	if (kvm_vcpu_is_bsp(vcpu)) {
1105
		if (!apic_hw_enabled(vcpu->arch.apic))
Q
Qing He 已提交
1106 1107 1108 1109 1110 1111 1112 1113
			r = 1;
		if ((lvt0 & APIC_LVT_MASKED) == 0 &&
		    GET_APIC_DELIVERY_MODE(lvt0) == APIC_MODE_EXTINT)
			r = 1;
	}
	return r;
}

1114 1115
void kvm_inject_apic_timer_irqs(struct kvm_vcpu *vcpu)
{
1116
	struct kvm_lapic *apic = vcpu->arch.apic;
1117

1118
	if (apic && atomic_read(&apic->lapic_timer.pending) > 0) {
1119
		if (kvm_apic_local_deliver(apic, APIC_LVTT))
1120
			atomic_dec(&apic->lapic_timer.pending);
1121 1122 1123
	}
}

E
Eddie Dong 已提交
1124 1125 1126
int kvm_get_apic_interrupt(struct kvm_vcpu *vcpu)
{
	int vector = kvm_apic_has_interrupt(vcpu);
1127
	struct kvm_lapic *apic = vcpu->arch.apic;
E
Eddie Dong 已提交
1128 1129 1130 1131 1132 1133 1134 1135 1136

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

	apic_set_vector(vector, apic->regs + APIC_ISR);
	apic_update_ppr(apic);
	apic_clear_irr(vector, apic);
	return vector;
}
1137 1138 1139

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

1142
	apic->base_address = vcpu->arch.apic_base &
1143
			     MSR_IA32_APICBASE_BASE;
1144 1145
	kvm_apic_set_version(vcpu);

1146
	apic_update_ppr(apic);
1147
	hrtimer_cancel(&apic->lapic_timer.timer);
1148 1149 1150
	update_divide_count(apic);
	start_apic_timer(apic);
}
1151

1152
void __kvm_migrate_apic_timer(struct kvm_vcpu *vcpu)
1153
{
1154
	struct kvm_lapic *apic = vcpu->arch.apic;
1155 1156 1157 1158 1159
	struct hrtimer *timer;

	if (!apic)
		return;

1160
	timer = &apic->lapic_timer.timer;
1161
	if (hrtimer_cancel(timer))
1162
		hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
1163
}
A
Avi Kivity 已提交
1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 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

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 已提交
1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243

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;
}