lapic.c 33.0 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
#include <asm/processor.h>
#include <asm/msr.h>
#include <asm/page.h>
#include <asm/current.h>
#include <asm/apicdef.h>
A
Arun Sharma 已提交
36
#include <linux/atomic.h>
37
#include "kvm_cache_regs.h"
E
Eddie Dong 已提交
38
#include "irq.h"
39
#include "trace.h"
40
#include "x86.h"
A
Avi Kivity 已提交
41
#include "cpuid.h"
E
Eddie Dong 已提交
42

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

72 73 74
static unsigned int min_timer_period_us = 500;
module_param(min_timer_period_us, uint, S_IRUGO | S_IWUSR);

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

142 143 144 145 146 147
static inline int apic_lvtt_oneshot(struct kvm_lapic *apic)
{
	return ((apic_get_reg(apic, APIC_LVTT) &
		apic->lapic_timer.timer_mode_mask) == APIC_LVT_TIMER_ONESHOT);
}

E
Eddie Dong 已提交
148 149
static inline int apic_lvtt_period(struct kvm_lapic *apic)
{
150 151 152 153 154 155 156 157 158
	return ((apic_get_reg(apic, APIC_LVTT) &
		apic->lapic_timer.timer_mode_mask) == APIC_LVT_TIMER_PERIODIC);
}

static inline int apic_lvtt_tscdeadline(struct kvm_lapic *apic)
{
	return ((apic_get_reg(apic, APIC_LVTT) &
		apic->lapic_timer.timer_mode_mask) ==
			APIC_LVT_TIMER_TSCDEADLINE);
E
Eddie Dong 已提交
159 160
}

161 162 163 164 165
static inline int apic_lvt_nmi_mode(u32 lvt_val)
{
	return (lvt_val & (APIC_MODE_MASK | APIC_LVT_MASKED)) == APIC_DM_NMI;
}

166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
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 已提交
181 182 183 184 185
static inline int apic_x2apic_mode(struct kvm_lapic *apic)
{
	return apic->vcpu->arch.apic_base & X2APIC_ENABLE;
}

E
Eddie Dong 已提交
186
static unsigned int apic_lvt_mask[APIC_LVT_NUM] = {
187
	LVT_MASK ,      /* part LVTT mask, timer mode mask added at runtime */
E
Eddie Dong 已提交
188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
	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)
{
210
	apic->irr_pending = true;
E
Eddie Dong 已提交
211 212 213
	return apic_test_and_set_vector(vec, apic->regs + APIC_IRR);
}

214
static inline int apic_search_irr(struct kvm_lapic *apic)
E
Eddie Dong 已提交
215
{
216
	return find_highest_vector(apic->regs + APIC_IRR);
E
Eddie Dong 已提交
217 218 219 220 221 222
}

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

223 224 225 226
	if (!apic->irr_pending)
		return -1;

	result = apic_search_irr(apic);
E
Eddie Dong 已提交
227 228 229 230 231
	ASSERT(result == -1 || result >= 16);

	return result;
}

232 233 234 235 236 237 238 239
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;
}

240 241
int kvm_lapic_find_highest_irr(struct kvm_vcpu *vcpu)
{
242
	struct kvm_lapic *apic = vcpu->arch.apic;
243 244
	int highest_irr;

245 246 247 248 249
	/* 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.
	 */
250 251 252 253 254 255 256
	if (!apic)
		return 0;
	highest_irr = apic_find_highest_irr(apic);

	return highest_irr;
}

257 258 259
static int __apic_accept_irq(struct kvm_lapic *apic, int delivery_mode,
			     int vector, int level, int trig_mode);

260
int kvm_apic_set_irq(struct kvm_vcpu *vcpu, struct kvm_lapic_irq *irq)
E
Eddie Dong 已提交
261
{
262
	struct kvm_lapic *apic = vcpu->arch.apic;
263

264 265
	return __apic_accept_irq(apic, irq->delivery_mode, irq->vector,
			irq->level, irq->trig_mode);
E
Eddie Dong 已提交
266 267 268 269 270 271 272 273 274 275 276 277 278 279
}

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)
{
280
	u32 tpr, isrv, ppr, old_ppr;
E
Eddie Dong 已提交
281 282
	int isr;

283
	old_ppr = apic_get_reg(apic, APIC_PROCPRI);
E
Eddie Dong 已提交
284 285 286 287 288 289 290 291 292 293 294 295
	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);

296 297
	if (old_ppr != ppr) {
		apic_set_reg(apic, APIC_PROCPRI, ppr);
298 299
		if (ppr < old_ppr)
			kvm_make_request(KVM_REQ_EVENT, apic->vcpu);
300
	}
E
Eddie Dong 已提交
301 302 303 304 305 306 307 308 309 310
}

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)
{
311
	return dest == 0xff || kvm_apic_id(apic) == dest;
E
Eddie Dong 已提交
312 313 314 315 316
}

int kvm_apic_match_logical_addr(struct kvm_lapic *apic, u8 mda)
{
	int result = 0;
G
Gleb Natapov 已提交
317 318 319 320 321 322
	u32 logical_id;

	if (apic_x2apic_mode(apic)) {
		logical_id = apic_get_reg(apic, APIC_LDR);
		return logical_id & mda;
	}
E
Eddie Dong 已提交
323 324 325 326 327 328 329 330 331 332 333 334 335 336

	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:
337 338
		apic_debug("Bad DFR vcpu %d: %08x\n",
			   apic->vcpu->vcpu_id, apic_get_reg(apic, APIC_DFR));
E
Eddie Dong 已提交
339 340 341 342 343 344
		break;
	}

	return result;
}

345
int kvm_apic_match_dest(struct kvm_vcpu *vcpu, struct kvm_lapic *source,
E
Eddie Dong 已提交
346 347 348
			   int short_hand, int dest, int dest_mode)
{
	int result = 0;
349
	struct kvm_lapic *target = vcpu->arch.apic;
E
Eddie Dong 已提交
350 351

	apic_debug("target %p, source %p, dest 0x%x, "
352
		   "dest_mode 0x%x, short_hand 0x%x\n",
E
Eddie Dong 已提交
353 354
		   target, source, dest, dest_mode, short_hand);

Z
Zachary Amsden 已提交
355
	ASSERT(target);
E
Eddie Dong 已提交
356 357
	switch (short_hand) {
	case APIC_DEST_NOSHORT:
358
		if (dest_mode == 0)
E
Eddie Dong 已提交
359
			/* Physical mode. */
360 361
			result = kvm_apic_match_physical_addr(target, dest);
		else
E
Eddie Dong 已提交
362 363 364 365
			/* Logical mode. */
			result = kvm_apic_match_logical_addr(target, dest);
		break;
	case APIC_DEST_SELF:
366
		result = (target == source);
E
Eddie Dong 已提交
367 368 369 370 371
		break;
	case APIC_DEST_ALLINC:
		result = 1;
		break;
	case APIC_DEST_ALLBUT:
372
		result = (target != source);
E
Eddie Dong 已提交
373 374
		break;
	default:
375 376
		apic_debug("kvm: apic: Bad dest shorthand value %x\n",
			   short_hand);
E
Eddie Dong 已提交
377 378 379 380 381 382 383 384 385 386 387 388 389
		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)
{
390
	int result = 0;
391
	struct kvm_vcpu *vcpu = apic->vcpu;
E
Eddie Dong 已提交
392 393 394

	switch (delivery_mode) {
	case APIC_DM_LOWEST:
395 396
		vcpu->arch.apic_arb_prio++;
	case APIC_DM_FIXED:
E
Eddie Dong 已提交
397 398 399 400
		/* FIXME add logic for vcpu on reset */
		if (unlikely(!apic_enabled(apic)))
			break;

401 402 403 404 405 406
		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);

407
		result = !apic_test_and_set_irr(vector, apic);
408
		trace_kvm_apic_accept_irq(vcpu->vcpu_id, delivery_mode,
409
					  trig_mode, vector, !result);
410 411 412 413
		if (!result) {
			if (trig_mode)
				apic_debug("level trig mode repeatedly for "
						"vector %d", vector);
E
Eddie Dong 已提交
414 415 416
			break;
		}

417
		kvm_make_request(KVM_REQ_EVENT, vcpu);
418
		kvm_vcpu_kick(vcpu);
E
Eddie Dong 已提交
419 420 421
		break;

	case APIC_DM_REMRD:
422
		apic_debug("Ignoring delivery mode 3\n");
E
Eddie Dong 已提交
423 424 425
		break;

	case APIC_DM_SMI:
426
		apic_debug("Ignoring guest SMI\n");
E
Eddie Dong 已提交
427
		break;
428

E
Eddie Dong 已提交
429
	case APIC_DM_NMI:
430
		result = 1;
431
		kvm_inject_nmi(vcpu);
J
Jan Kiszka 已提交
432
		kvm_vcpu_kick(vcpu);
E
Eddie Dong 已提交
433 434 435
		break;

	case APIC_DM_INIT:
436
		if (level) {
437
			result = 1;
438
			vcpu->arch.mp_state = KVM_MP_STATE_INIT_RECEIVED;
439
			kvm_make_request(KVM_REQ_EVENT, vcpu);
440 441
			kvm_vcpu_kick(vcpu);
		} else {
442 443
			apic_debug("Ignoring de-assert INIT to vcpu %d\n",
				   vcpu->vcpu_id);
444
		}
E
Eddie Dong 已提交
445 446 447
		break;

	case APIC_DM_STARTUP:
448 449
		apic_debug("SIPI to vcpu %d vector 0x%02x\n",
			   vcpu->vcpu_id, vector);
450
		if (vcpu->arch.mp_state == KVM_MP_STATE_INIT_RECEIVED) {
451
			result = 1;
452
			vcpu->arch.sipi_vector = vector;
453
			vcpu->arch.mp_state = KVM_MP_STATE_SIPI_RECEIVED;
454
			kvm_make_request(KVM_REQ_EVENT, vcpu);
455
			kvm_vcpu_kick(vcpu);
456
		}
E
Eddie Dong 已提交
457 458
		break;

459 460 461 462 463 464 465 466
	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 已提交
467 468 469 470 471 472 473 474
	default:
		printk(KERN_ERR "TODO: unsupported delivery mode %x\n",
		       delivery_mode);
		break;
	}
	return result;
}

475
int kvm_apic_compare_prio(struct kvm_vcpu *vcpu1, struct kvm_vcpu *vcpu2)
476
{
477
	return vcpu1->arch.apic_arb_prio - vcpu2->arch.apic_arb_prio;
478 479
}

E
Eddie Dong 已提交
480 481 482
static void apic_set_eoi(struct kvm_lapic *apic)
{
	int vector = apic_find_highest_isr(apic);
M
Marcelo Tosatti 已提交
483
	int trigger_mode;
E
Eddie Dong 已提交
484 485 486 487 488 489 490 491 492 493 494
	/*
	 * 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 已提交
495 496 497
		trigger_mode = IOAPIC_LEVEL_TRIG;
	else
		trigger_mode = IOAPIC_EDGE_TRIG;
G
Gleb Natapov 已提交
498
	if (!(apic_get_reg(apic, APIC_SPIV) & APIC_SPIV_DIRECTED_EOI))
499
		kvm_ioapic_update_eoi(apic->vcpu->kvm, vector, trigger_mode);
500
	kvm_make_request(KVM_REQ_EVENT, apic->vcpu);
E
Eddie Dong 已提交
501 502 503 504 505 506
}

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

509 510 511 512 513 514
	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 已提交
515 516 517 518
	if (apic_x2apic_mode(apic))
		irq.dest_id = icr_high;
	else
		irq.dest_id = GET_APIC_DEST_FIELD(icr_high);
E
Eddie Dong 已提交
519

520 521
	trace_kvm_apic_ipi(icr_low, irq.dest_id);

E
Eddie Dong 已提交
522 523 524
	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 已提交
525
		   icr_high, icr_low, irq.shorthand, irq.dest_id,
526 527 528 529
		   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 已提交
530 531 532 533
}

static u32 apic_get_tmcct(struct kvm_lapic *apic)
{
534 535
	ktime_t remaining;
	s64 ns;
536
	u32 tmcct;
E
Eddie Dong 已提交
537 538 539

	ASSERT(apic != NULL);

540
	/* if initial count is 0, current count should also be 0 */
541
	if (apic_get_reg(apic, APIC_TMICT) == 0)
542 543
		return 0;

544
	remaining = hrtimer_get_remaining(&apic->lapic_timer.timer);
545 546 547
	if (ktime_to_ns(remaining) < 0)
		remaining = ktime_set(0, 0);

548 549 550
	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 已提交
551 552 553 554

	return tmcct;
}

555 556 557 558 559
static void __report_tpr_access(struct kvm_lapic *apic, bool write)
{
	struct kvm_vcpu *vcpu = apic->vcpu;
	struct kvm_run *run = vcpu->run;

560
	kvm_make_request(KVM_REQ_REPORT_TPR_ACCESS, vcpu);
561
	run->tpr_access.rip = kvm_rip_read(vcpu);
562 563 564 565 566 567 568 569 570
	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 已提交
571 572 573 574 575 576 577 578
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 已提交
579 580 581 582 583 584
	case APIC_ID:
		if (apic_x2apic_mode(apic))
			val = kvm_apic_id(apic);
		else
			val = kvm_apic_id(apic) << 24;
		break;
E
Eddie Dong 已提交
585
	case APIC_ARBPRI:
586
		apic_debug("Access APIC ARBPRI register which is for P6\n");
E
Eddie Dong 已提交
587 588 589
		break;

	case APIC_TMCCT:	/* Timer CCR */
590 591 592
		if (apic_lvtt_tscdeadline(apic))
			return 0;

E
Eddie Dong 已提交
593 594 595
		val = apic_get_tmcct(apic);
		break;

596 597 598
	case APIC_TASKPRI:
		report_tpr_access(apic, false);
		/* fall thru */
E
Eddie Dong 已提交
599
	default:
600
		apic_update_ppr(apic);
E
Eddie Dong 已提交
601 602 603 604 605 606 607
		val = apic_get_reg(apic, offset);
		break;
	}

	return val;
}

G
Gregory Haskins 已提交
608 609 610 611 612
static inline struct kvm_lapic *to_lapic(struct kvm_io_device *dev)
{
	return container_of(dev, struct kvm_lapic, dev);
}

G
Gleb Natapov 已提交
613 614
static int apic_reg_read(struct kvm_lapic *apic, u32 offset, int len,
		void *data)
E
Eddie Dong 已提交
615 616 617
{
	unsigned char alignment = offset & 0xf;
	u32 result;
G
Gleb Natapov 已提交
618 619
	/* this bitmask has a bit cleared for each reserver register */
	static const u64 rmask = 0x43ff01ffffffe70cULL;
E
Eddie Dong 已提交
620 621

	if ((alignment + len) > 4) {
622 623
		apic_debug("KVM_APIC_READ: alignment error %x %d\n",
			   offset, len);
G
Gleb Natapov 已提交
624
		return 1;
E
Eddie Dong 已提交
625
	}
G
Gleb Natapov 已提交
626 627

	if (offset > 0x3f0 || !(rmask & (1ULL << (offset >> 4)))) {
628 629
		apic_debug("KVM_APIC_READ: read reserved register %x\n",
			   offset);
G
Gleb Natapov 已提交
630 631 632
		return 1;
	}

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

635 636
	trace_kvm_apic_read(offset, result);

E
Eddie Dong 已提交
637 638 639 640 641 642 643 644 645 646 647
	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;
	}
648
	return 0;
E
Eddie Dong 已提交
649 650
}

G
Gleb Natapov 已提交
651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671
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 已提交
672 673 674 675 676 677 678
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;
679
	apic->divide_count = 0x1 << (tmp2 & 0x7);
E
Eddie Dong 已提交
680 681

	apic_debug("timer divide count is 0x%x\n",
G
Glauber Costa 已提交
682
				   apic->divide_count);
E
Eddie Dong 已提交
683 684 685 686
}

static void start_apic_timer(struct kvm_lapic *apic)
{
687
	ktime_t now;
688
	atomic_set(&apic->lapic_timer.pending, 0);
689

690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713
	if (apic_lvtt_period(apic) || apic_lvtt_oneshot(apic)) {
		/* lapic timer in oneshot or peroidic mode */
		now = apic->lapic_timer.timer.base->get_time();
		apic->lapic_timer.period = (u64)apic_get_reg(apic, APIC_TMICT)
			    * APIC_BUS_CYCLE_NS * apic->divide_count;

		if (!apic->lapic_timer.period)
			return;
		/*
		 * 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)) {
			s64 min_period = min_timer_period_us * 1000LL;

			if (apic->lapic_timer.period < min_period) {
				pr_info_ratelimited(
				    "kvm: vcpu %i: requested %lld ns "
				    "lapic timer period limited to %lld ns\n",
				    apic->vcpu->vcpu_id,
				    apic->lapic_timer.period, min_period);
				apic->lapic_timer.period = min_period;
			}
714
		}
715

716 717 718
		hrtimer_start(&apic->lapic_timer.timer,
			      ktime_add_ns(now, apic->lapic_timer.period),
			      HRTIMER_MODE_ABS);
E
Eddie Dong 已提交
719

720
		apic_debug("%s: bus cycle is %" PRId64 "ns, now 0x%016"
E
Eddie Dong 已提交
721 722
			   PRIx64 ", "
			   "timer initial count 0x%x, period %lldns, "
723
			   "expire @ 0x%016" PRIx64 ".\n", __func__,
E
Eddie Dong 已提交
724 725
			   APIC_BUS_CYCLE_NS, ktime_to_ns(now),
			   apic_get_reg(apic, APIC_TMICT),
726
			   apic->lapic_timer.period,
E
Eddie Dong 已提交
727
			   ktime_to_ns(ktime_add_ns(now,
728
					apic->lapic_timer.period)));
729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752
	} else if (apic_lvtt_tscdeadline(apic)) {
		/* lapic timer in tsc deadline mode */
		u64 guest_tsc, tscdeadline = apic->lapic_timer.tscdeadline;
		u64 ns = 0;
		struct kvm_vcpu *vcpu = apic->vcpu;
		unsigned long this_tsc_khz = vcpu_tsc_khz(vcpu);
		unsigned long flags;

		if (unlikely(!tscdeadline || !this_tsc_khz))
			return;

		local_irq_save(flags);

		now = apic->lapic_timer.timer.base->get_time();
		guest_tsc = kvm_x86_ops->read_l1_tsc(vcpu);
		if (likely(tscdeadline > guest_tsc)) {
			ns = (tscdeadline - guest_tsc) * 1000000ULL;
			do_div(ns, this_tsc_khz);
		}
		hrtimer_start(&apic->lapic_timer.timer,
			ktime_add_ns(now, ns), HRTIMER_MODE_ABS);

		local_irq_restore(flags);
	}
E
Eddie Dong 已提交
753 754
}

755 756 757 758 759 760 761 762 763 764 765 766 767 768
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 已提交
769
static int apic_reg_write(struct kvm_lapic *apic, u32 reg, u32 val)
E
Eddie Dong 已提交
770
{
G
Gleb Natapov 已提交
771
	int ret = 0;
E
Eddie Dong 已提交
772

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

G
Gleb Natapov 已提交
775
	switch (reg) {
E
Eddie Dong 已提交
776
	case APIC_ID:		/* Local APIC ID */
G
Gleb Natapov 已提交
777 778 779 780
		if (!apic_x2apic_mode(apic))
			apic_set_reg(apic, APIC_ID, val);
		else
			ret = 1;
E
Eddie Dong 已提交
781 782 783
		break;

	case APIC_TASKPRI:
784
		report_tpr_access(apic, true);
E
Eddie Dong 已提交
785 786 787 788 789 790 791 792
		apic_set_tpr(apic, val & 0xff);
		break;

	case APIC_EOI:
		apic_set_eoi(apic);
		break;

	case APIC_LDR:
G
Gleb Natapov 已提交
793 794 795 796
		if (!apic_x2apic_mode(apic))
			apic_set_reg(apic, APIC_LDR, val & APIC_LDR_MASK);
		else
			ret = 1;
E
Eddie Dong 已提交
797 798 799
		break;

	case APIC_DFR:
G
Gleb Natapov 已提交
800 801 802 803
		if (!apic_x2apic_mode(apic))
			apic_set_reg(apic, APIC_DFR, val | 0x0FFFFFFF);
		else
			ret = 1;
E
Eddie Dong 已提交
804 805
		break;

806 807 808 809 810
	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 已提交
811 812 813 814 815 816 817 818 819 820
		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);
			}
821
			atomic_set(&apic->lapic_timer.pending, 0);
E
Eddie Dong 已提交
822 823 824

		}
		break;
825
	}
E
Eddie Dong 已提交
826 827 828 829 830 831 832
	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 已提交
833 834 835
		if (!apic_x2apic_mode(apic))
			val &= 0xff000000;
		apic_set_reg(apic, APIC_ICR2, val);
E
Eddie Dong 已提交
836 837
		break;

838
	case APIC_LVT0:
839
		apic_manage_nmi_watchdog(apic, val);
E
Eddie Dong 已提交
840 841 842 843 844 845 846 847
	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 已提交
848 849
		val &= apic_lvt_mask[(reg - APIC_LVTT) >> 4];
		apic_set_reg(apic, reg, val);
E
Eddie Dong 已提交
850 851 852

		break;

853 854 855 856 857 858 859 860 861 862 863 864
	case APIC_LVTT:
		if ((apic_get_reg(apic, APIC_LVTT) &
		    apic->lapic_timer.timer_mode_mask) !=
		   (val & apic->lapic_timer.timer_mode_mask))
			hrtimer_cancel(&apic->lapic_timer.timer);

		if (!apic_sw_enabled(apic))
			val |= APIC_LVT_MASKED;
		val &= (apic_lvt_mask[0] | apic->lapic_timer.timer_mode_mask);
		apic_set_reg(apic, APIC_LVTT, val);
		break;

E
Eddie Dong 已提交
865
	case APIC_TMICT:
866 867 868
		if (apic_lvtt_tscdeadline(apic))
			break;

869
		hrtimer_cancel(&apic->lapic_timer.timer);
E
Eddie Dong 已提交
870 871
		apic_set_reg(apic, APIC_TMICT, val);
		start_apic_timer(apic);
G
Gleb Natapov 已提交
872
		break;
E
Eddie Dong 已提交
873 874 875

	case APIC_TDCR:
		if (val & 4)
876
			apic_debug("KVM_WRITE:TDCR %x\n", val);
E
Eddie Dong 已提交
877 878 879 880
		apic_set_reg(apic, APIC_TDCR, val);
		update_divide_count(apic);
		break;

G
Gleb Natapov 已提交
881 882
	case APIC_ESR:
		if (apic_x2apic_mode(apic) && val != 0) {
883
			apic_debug("KVM_WRITE:ESR not zero %x\n", val);
G
Gleb Natapov 已提交
884 885 886 887 888 889 890 891 892 893
			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 已提交
894
	default:
G
Gleb Natapov 已提交
895
		ret = 1;
E
Eddie Dong 已提交
896 897
		break;
	}
G
Gleb Natapov 已提交
898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920
	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);
921
		return 0;
G
Gleb Natapov 已提交
922 923 924 925 926 927 928 929 930 931 932
	}

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

933
	return 0;
E
Eddie Dong 已提交
934 935
}

936 937 938 939 940 941 942 943 944
void kvm_lapic_set_eoi(struct kvm_vcpu *vcpu)
{
	struct kvm_lapic *apic = vcpu->arch.apic;

	if (apic)
		apic_reg_write(vcpu->arch.apic, APIC_EOI, 0);
}
EXPORT_SYMBOL_GPL(kvm_lapic_set_eoi);

945
void kvm_free_lapic(struct kvm_vcpu *vcpu)
E
Eddie Dong 已提交
946
{
947
	if (!vcpu->arch.apic)
E
Eddie Dong 已提交
948 949
		return;

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

952 953
	if (vcpu->arch.apic->regs)
		free_page((unsigned long)vcpu->arch.apic->regs);
E
Eddie Dong 已提交
954

955
	kfree(vcpu->arch.apic);
E
Eddie Dong 已提交
956 957 958 959 960 961 962 963
}

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

964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989
u64 kvm_get_lapic_tscdeadline_msr(struct kvm_vcpu *vcpu)
{
	struct kvm_lapic *apic = vcpu->arch.apic;
	if (!apic)
		return 0;

	if (apic_lvtt_oneshot(apic) || apic_lvtt_period(apic))
		return 0;

	return apic->lapic_timer.tscdeadline;
}

void kvm_set_lapic_tscdeadline_msr(struct kvm_vcpu *vcpu, u64 data)
{
	struct kvm_lapic *apic = vcpu->arch.apic;
	if (!apic)
		return;

	if (apic_lvtt_oneshot(apic) || apic_lvtt_period(apic))
		return;

	hrtimer_cancel(&apic->lapic_timer.timer);
	apic->lapic_timer.tscdeadline = data;
	start_apic_timer(apic);
}

E
Eddie Dong 已提交
990 991
void kvm_lapic_set_tpr(struct kvm_vcpu *vcpu, unsigned long cr8)
{
992
	struct kvm_lapic *apic = vcpu->arch.apic;
E
Eddie Dong 已提交
993 994 995

	if (!apic)
		return;
A
Avi Kivity 已提交
996 997
	apic_set_tpr(apic, ((cr8 & 0x0f) << 4)
		     | (apic_get_reg(apic, APIC_TASKPRI) & 4));
E
Eddie Dong 已提交
998 999 1000 1001
}

u64 kvm_lapic_get_cr8(struct kvm_vcpu *vcpu)
{
1002
	struct kvm_lapic *apic = vcpu->arch.apic;
E
Eddie Dong 已提交
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
	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)
{
1014
	struct kvm_lapic *apic = vcpu->arch.apic;
E
Eddie Dong 已提交
1015 1016 1017

	if (!apic) {
		value |= MSR_IA32_APICBASE_BSP;
1018
		vcpu->arch.apic_base = value;
E
Eddie Dong 已提交
1019 1020
		return;
	}
1021 1022

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

1025
	vcpu->arch.apic_base = value;
G
Gleb Natapov 已提交
1026 1027 1028 1029 1030
	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);
	}
1031
	apic->base_address = apic->vcpu->arch.apic_base &
E
Eddie Dong 已提交
1032 1033 1034 1035
			     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 "
1036
		   "0x%lx.\n", apic->vcpu->arch.apic_base, apic->base_address);
E
Eddie Dong 已提交
1037 1038 1039

}

1040
void kvm_lapic_reset(struct kvm_vcpu *vcpu)
E
Eddie Dong 已提交
1041 1042 1043 1044
{
	struct kvm_lapic *apic;
	int i;

1045
	apic_debug("%s\n", __func__);
E
Eddie Dong 已提交
1046 1047

	ASSERT(vcpu);
1048
	apic = vcpu->arch.apic;
E
Eddie Dong 已提交
1049 1050 1051
	ASSERT(apic != NULL);

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

	apic_set_reg(apic, APIC_ID, vcpu->vcpu_id << 24);
1055
	kvm_apic_set_version(apic->vcpu);
E
Eddie Dong 已提交
1056 1057 1058

	for (i = 0; i < APIC_LVT_NUM; i++)
		apic_set_reg(apic, APIC_LVTT + 0x10 * i, APIC_LVT_MASKED);
Q
Qing He 已提交
1059 1060
	apic_set_reg(apic, APIC_LVT0,
		     SET_APIC_DELIVERY_MODE(0, APIC_MODE_EXTINT));
E
Eddie Dong 已提交
1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075

	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);
	}
1076
	apic->irr_pending = false;
1077
	update_divide_count(apic);
1078
	atomic_set(&apic->lapic_timer.pending, 0);
1079
	if (kvm_vcpu_is_bsp(vcpu))
1080
		vcpu->arch.apic_base |= MSR_IA32_APICBASE_BSP;
E
Eddie Dong 已提交
1081 1082
	apic_update_ppr(apic);

1083 1084
	vcpu->arch.apic_arb_prio = 0;

E
Eddie Dong 已提交
1085
	apic_debug(KERN_INFO "%s: vcpu=%p, id=%d, base_msr="
1086
		   "0x%016" PRIx64 ", base_address=0x%0lx.\n", __func__,
E
Eddie Dong 已提交
1087
		   vcpu, kvm_apic_id(apic),
1088
		   vcpu->arch.apic_base, apic->base_address);
E
Eddie Dong 已提交
1089 1090
}

1091
bool kvm_apic_present(struct kvm_vcpu *vcpu)
E
Eddie Dong 已提交
1092
{
1093 1094
	return vcpu->arch.apic && apic_hw_enabled(vcpu->arch.apic);
}
E
Eddie Dong 已提交
1095

1096 1097 1098
int kvm_lapic_enabled(struct kvm_vcpu *vcpu)
{
	return kvm_apic_present(vcpu) && apic_sw_enabled(vcpu->arch.apic);
E
Eddie Dong 已提交
1099 1100 1101 1102 1103 1104 1105
}

/*
 *----------------------------------------------------------------------
 * timer interface
 *----------------------------------------------------------------------
 */
1106

1107
static bool lapic_is_periodic(struct kvm_timer *ktimer)
E
Eddie Dong 已提交
1108
{
1109 1110 1111
	struct kvm_lapic *apic = container_of(ktimer, struct kvm_lapic,
					      lapic_timer);
	return apic_lvtt_period(apic);
E
Eddie Dong 已提交
1112 1113
}

1114 1115 1116 1117
int apic_has_pending_timer(struct kvm_vcpu *vcpu)
{
	struct kvm_lapic *lapic = vcpu->arch.apic;

1118
	if (lapic && apic_enabled(lapic) && apic_lvt_enabled(lapic, APIC_LVTT))
1119
		return atomic_read(&lapic->lapic_timer.pending);
1120 1121 1122 1123

	return 0;
}

A
Avi Kivity 已提交
1124
int kvm_apic_local_deliver(struct kvm_lapic *apic, int lvt_type)
1125
{
1126
	u32 reg = apic_get_reg(apic, lvt_type);
1127 1128
	int vector, mode, trig_mode;

1129
	if (apic_hw_enabled(apic) && !(reg & APIC_LVT_MASKED)) {
1130 1131 1132 1133 1134 1135 1136
		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;
}
1137

1138
void kvm_apic_nmi_wd_deliver(struct kvm_vcpu *vcpu)
1139
{
1140 1141 1142 1143
	struct kvm_lapic *apic = vcpu->arch.apic;

	if (apic)
		kvm_apic_local_deliver(apic, APIC_LVT0);
1144 1145
}

1146
static struct kvm_timer_ops lapic_timer_ops = {
1147 1148
	.is_periodic = lapic_is_periodic,
};
E
Eddie Dong 已提交
1149

G
Gregory Haskins 已提交
1150 1151 1152 1153 1154
static const struct kvm_io_device_ops apic_mmio_ops = {
	.read     = apic_mmio_read,
	.write    = apic_mmio_write,
};

E
Eddie Dong 已提交
1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165
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;

1166
	vcpu->arch.apic = apic;
E
Eddie Dong 已提交
1167

1168 1169
	apic->regs = (void *)get_zeroed_page(GFP_KERNEL);
	if (!apic->regs) {
E
Eddie Dong 已提交
1170 1171
		printk(KERN_ERR "malloc apic regs error for vcpu %x\n",
		       vcpu->vcpu_id);
1172
		goto nomem_free_apic;
E
Eddie Dong 已提交
1173 1174 1175
	}
	apic->vcpu = vcpu;

1176 1177 1178 1179 1180
	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;
1181
	apic->lapic_timer.vcpu = vcpu;
1182

E
Eddie Dong 已提交
1183
	apic->base_address = APIC_DEFAULT_PHYS_BASE;
1184
	vcpu->arch.apic_base = APIC_DEFAULT_PHYS_BASE;
E
Eddie Dong 已提交
1185

1186
	kvm_lapic_reset(vcpu);
G
Gregory Haskins 已提交
1187
	kvm_iodevice_init(&apic->dev, &apic_mmio_ops);
E
Eddie Dong 已提交
1188 1189

	return 0;
1190 1191
nomem_free_apic:
	kfree(apic);
E
Eddie Dong 已提交
1192 1193 1194 1195 1196 1197
nomem:
	return -ENOMEM;
}

int kvm_apic_has_interrupt(struct kvm_vcpu *vcpu)
{
1198
	struct kvm_lapic *apic = vcpu->arch.apic;
E
Eddie Dong 已提交
1199 1200 1201 1202 1203
	int highest_irr;

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

1204
	apic_update_ppr(apic);
E
Eddie Dong 已提交
1205 1206 1207 1208 1209 1210 1211
	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 已提交
1212 1213
int kvm_apic_accept_pic_intr(struct kvm_vcpu *vcpu)
{
1214
	u32 lvt0 = apic_get_reg(vcpu->arch.apic, APIC_LVT0);
Q
Qing He 已提交
1215 1216
	int r = 0;

1217 1218 1219 1220 1221
	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 已提交
1222 1223 1224
	return r;
}

1225 1226
void kvm_inject_apic_timer_irqs(struct kvm_vcpu *vcpu)
{
1227
	struct kvm_lapic *apic = vcpu->arch.apic;
1228

1229
	if (apic && atomic_read(&apic->lapic_timer.pending) > 0) {
1230
		if (kvm_apic_local_deliver(apic, APIC_LVTT))
1231
			atomic_dec(&apic->lapic_timer.pending);
1232 1233 1234
	}
}

E
Eddie Dong 已提交
1235 1236 1237
int kvm_get_apic_interrupt(struct kvm_vcpu *vcpu)
{
	int vector = kvm_apic_has_interrupt(vcpu);
1238
	struct kvm_lapic *apic = vcpu->arch.apic;
E
Eddie Dong 已提交
1239 1240 1241 1242 1243 1244 1245 1246 1247

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

	apic_set_vector(vector, apic->regs + APIC_ISR);
	apic_update_ppr(apic);
	apic_clear_irr(vector, apic);
	return vector;
}
1248 1249 1250

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

1253
	apic->base_address = vcpu->arch.apic_base &
1254
			     MSR_IA32_APICBASE_BASE;
1255 1256
	kvm_apic_set_version(vcpu);

1257
	apic_update_ppr(apic);
1258
	hrtimer_cancel(&apic->lapic_timer.timer);
1259 1260
	update_divide_count(apic);
	start_apic_timer(apic);
1261
	apic->irr_pending = true;
1262
	kvm_make_request(KVM_REQ_EVENT, vcpu);
1263
}
1264

1265
void __kvm_migrate_apic_timer(struct kvm_vcpu *vcpu)
1266
{
1267
	struct kvm_lapic *apic = vcpu->arch.apic;
1268 1269 1270 1271 1272
	struct hrtimer *timer;

	if (!apic)
		return;

1273
	timer = &apic->lapic_timer.timer;
1274
	if (hrtimer_cancel(timer))
1275
		hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
1276
}
A
Avi Kivity 已提交
1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324

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 已提交
1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356

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 已提交
1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387

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