irq_comm.c 11.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 * irq_comm.c: Common API for in kernel interrupt controller
 * Copyright (c) 2007, Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 * Place - Suite 330, Boston, MA 02111-1307 USA.
 * Authors:
 *   Yaozu (Eddie) Dong <Eddie.dong@intel.com>
 *
 */

#include <linux/kvm_host.h>
23
#include <trace/events/kvm.h>
S
Sheng Yang 已提交
24 25

#include <asm/msidef.h>
26 27 28
#ifdef CONFIG_IA64
#include <asm/iosapic.h>
#endif
S
Sheng Yang 已提交
29

30 31 32 33
#include "irq.h"

#include "ioapic.h"

34 35 36 37 38 39 40 41 42 43 44 45
static inline int kvm_irq_line_state(unsigned long *irq_state,
				     int irq_source_id, int level)
{
	/* Logical OR for level trig interrupt */
	if (level)
		set_bit(irq_source_id, irq_state);
	else
		clear_bit(irq_source_id, irq_state);

	return !!(*irq_state);
}

46
static int kvm_set_pic_irq(struct kvm_kernel_irq_routing_entry *e,
47
			   struct kvm *kvm, int irq_source_id, int level)
48 49
{
#ifdef CONFIG_X86
50 51 52 53
	struct kvm_pic *pic = pic_irqchip(kvm);
	level = kvm_irq_line_state(&pic->irq_states[e->irqchip.pin],
				   irq_source_id, level);
	return kvm_pic_set_irq(pic, e->irqchip.pin, level);
54 55
#else
	return -1;
56 57 58
#endif
}

59
static int kvm_set_ioapic_irq(struct kvm_kernel_irq_routing_entry *e,
60
			      struct kvm *kvm, int irq_source_id, int level)
61
{
62 63 64 65 66
	struct kvm_ioapic *ioapic = kvm->arch.vioapic;
	level = kvm_irq_line_state(&ioapic->irq_states[e->irqchip.pin],
				   irq_source_id, level);

	return kvm_ioapic_set_irq(ioapic, e->irqchip.pin, level);
67 68
}

69
inline static bool kvm_is_dm_lowest_prio(struct kvm_lapic_irq *irq)
70
{
71 72 73 74 75 76 77
#ifdef CONFIG_IA64
	return irq->delivery_mode ==
		(IOSAPIC_LOWEST_PRIORITY << IOSAPIC_DELIVERY_SHIFT);
#else
	return irq->delivery_mode == APIC_DM_LOWEST;
#endif
}
78

79 80 81 82 83 84 85 86
int kvm_irq_delivery_to_apic(struct kvm *kvm, struct kvm_lapic *src,
		struct kvm_lapic_irq *irq)
{
	int i, r = -1;
	struct kvm_vcpu *vcpu, *lowest = NULL;

	if (irq->dest_mode == 0 && irq->dest_id == 0xff &&
			kvm_is_dm_lowest_prio(irq))
87 88
		printk(KERN_INFO "kvm: apic: phys broadcast and lowest prio\n");

89 90
	kvm_for_each_vcpu(i, vcpu, kvm) {
		if (!kvm_apic_present(vcpu))
91 92
			continue;

93 94
		if (!kvm_apic_match_dest(vcpu, src, irq->shorthand,
					irq->dest_id, irq->dest_mode))
95 96
			continue;

97 98 99 100
		if (!kvm_is_dm_lowest_prio(irq)) {
			if (r < 0)
				r = 0;
			r += kvm_apic_set_irq(vcpu, irq);
101
		} else {
102 103 104 105
			if (!lowest)
				lowest = vcpu;
			else if (kvm_apic_compare_prio(vcpu, lowest) < 0)
				lowest = vcpu;
106
		}
107 108
	}

109 110 111 112
	if (lowest)
		r = kvm_apic_set_irq(lowest, irq);

	return r;
113 114
}

115
static int kvm_set_msi(struct kvm_kernel_irq_routing_entry *e,
116
		       struct kvm *kvm, int irq_source_id, int level)
S
Sheng Yang 已提交
117
{
118
	struct kvm_lapic_irq irq;
S
Sheng Yang 已提交
119

120 121 122
	if (!level)
		return -1;

123 124
	trace_kvm_msi_set_irq(e->msi.address_lo, e->msi.data);

125
	irq.dest_id = (e->msi.address_lo &
126
			MSI_ADDR_DEST_ID_MASK) >> MSI_ADDR_DEST_ID_SHIFT;
127
	irq.vector = (e->msi.data &
128
			MSI_DATA_VECTOR_MASK) >> MSI_DATA_VECTOR_SHIFT;
129 130 131 132 133
	irq.dest_mode = (1 << MSI_ADDR_DEST_MODE_SHIFT) & e->msi.address_lo;
	irq.trig_mode = (1 << MSI_DATA_TRIGGER_SHIFT) & e->msi.data;
	irq.delivery_mode = e->msi.data & 0x700;
	irq.level = 1;
	irq.shorthand = 0;
134 135

	/* TODO Deal with RH bit of MSI message address */
136
	return kvm_irq_delivery_to_apic(kvm, NULL, &irq);
S
Sheng Yang 已提交
137 138
}

139
/*
140 141 142 143 144
 * Return value:
 *  < 0   Interrupt was ignored (masked or not delivered for other reasons)
 *  = 0   Interrupt was coalesced (previous irq is still pending)
 *  > 0   Number of CPUs interrupt was delivered to
 */
145
int kvm_set_irq(struct kvm *kvm, int irq_source_id, u32 irq, int level)
146
{
G
Gleb Natapov 已提交
147 148
	struct kvm_kernel_irq_routing_entry *e, irq_set[KVM_NR_IRQCHIPS];
	int ret = -1, i = 0;
149 150
	struct kvm_irq_routing_table *irq_rt;
	struct hlist_node *n;
S
Sheng Yang 已提交
151

A
Avi Kivity 已提交
152
	trace_kvm_set_irq(irq, level, irq_source_id);
153

154 155 156 157
	/* Not possible to detect if the guest uses the PIC or the
	 * IOAPIC.  So set the bit in both. The guest will ignore
	 * writes to the unused one.
	 */
158 159
	rcu_read_lock();
	irq_rt = rcu_dereference(kvm->irq_routing);
160
	if (irq < irq_rt->nr_rt_entries)
G
Gleb Natapov 已提交
161 162
		hlist_for_each_entry(e, n, &irq_rt->map[irq], link)
			irq_set[i++] = *e;
163
	rcu_read_unlock();
G
Gleb Natapov 已提交
164 165 166 167 168 169 170 171 172 173

	while(i--) {
		int r;
		r = irq_set[i].set(&irq_set[i], kvm, irq_source_id, level);
		if (r < 0)
			continue;

		ret = r + ((ret < 0) ? 0 : ret);
	}

174
	return ret;
175 176
}

177
void kvm_notify_acked_irq(struct kvm *kvm, unsigned irqchip, unsigned pin)
178 179 180
{
	struct kvm_irq_ack_notifier *kian;
	struct hlist_node *n;
181
	int gsi;
182

183 184
	trace_kvm_ack_irq(irqchip, pin);

185 186
	rcu_read_lock();
	gsi = rcu_dereference(kvm->irq_routing)->chip[irqchip][pin];
187
	if (gsi != -1)
188 189
		hlist_for_each_entry_rcu(kian, n, &kvm->irq_ack_notifier_list,
					 link)
190 191
			if (kian->gsi == gsi)
				kian->irq_acked(kian);
192
	rcu_read_unlock();
193 194 195 196 197
}

void kvm_register_irq_ack_notifier(struct kvm *kvm,
				   struct kvm_irq_ack_notifier *kian)
{
198
	mutex_lock(&kvm->irq_lock);
199
	hlist_add_head_rcu(&kian->link, &kvm->irq_ack_notifier_list);
200
	mutex_unlock(&kvm->irq_lock);
201 202
}

203 204
void kvm_unregister_irq_ack_notifier(struct kvm *kvm,
				    struct kvm_irq_ack_notifier *kian)
205
{
206
	mutex_lock(&kvm->irq_lock);
207
	hlist_del_init_rcu(&kian->link);
208
	mutex_unlock(&kvm->irq_lock);
209
	synchronize_rcu();
210
}
211 212 213 214

int kvm_request_irq_source_id(struct kvm *kvm)
{
	unsigned long *bitmap = &kvm->arch.irq_sources_bitmap;
215 216 217
	int irq_source_id;

	mutex_lock(&kvm->irq_lock);
218
	irq_source_id = find_first_zero_bit(bitmap, BITS_PER_LONG);
219

220
	if (irq_source_id >= BITS_PER_LONG) {
221
		printk(KERN_WARNING "kvm: exhaust allocatable IRQ sources!\n");
222 223
		irq_source_id = -EFAULT;
		goto unlock;
224 225 226 227
	}

	ASSERT(irq_source_id != KVM_USERSPACE_IRQ_SOURCE_ID);
	set_bit(irq_source_id, bitmap);
228
unlock:
229
	mutex_unlock(&kvm->irq_lock);
230

231 232 233 234 235 236 237
	return irq_source_id;
}

void kvm_free_irq_source_id(struct kvm *kvm, int irq_source_id)
{
	int i;

238 239
	ASSERT(irq_source_id != KVM_USERSPACE_IRQ_SOURCE_ID);

240
	mutex_lock(&kvm->irq_lock);
241
	if (irq_source_id < 0 ||
242
	    irq_source_id >= BITS_PER_LONG) {
243
		printk(KERN_ERR "kvm: IRQ source ID out of range!\n");
244
		goto unlock;
245
	}
246 247 248 249
	clear_bit(irq_source_id, &kvm->arch.irq_sources_bitmap);
	if (!irqchip_in_kernel(kvm))
		goto unlock;

250 251 252 253 254 255 256 257
	for (i = 0; i < KVM_IOAPIC_NUM_PINS; i++) {
		clear_bit(irq_source_id, &kvm->arch.vioapic->irq_states[i]);
		if (i >= 16)
			continue;
#ifdef CONFIG_X86
		clear_bit(irq_source_id, &pic_irqchip(kvm)->irq_states[i]);
#endif
	}
258
unlock:
259
	mutex_unlock(&kvm->irq_lock);
260
}
261 262 263 264

void kvm_register_irq_mask_notifier(struct kvm *kvm, int irq,
				    struct kvm_irq_mask_notifier *kimn)
{
265
	mutex_lock(&kvm->irq_lock);
266
	kimn->irq = irq;
267
	hlist_add_head_rcu(&kimn->link, &kvm->mask_notifier_list);
268
	mutex_unlock(&kvm->irq_lock);
269 270 271 272 273
}

void kvm_unregister_irq_mask_notifier(struct kvm *kvm, int irq,
				      struct kvm_irq_mask_notifier *kimn)
{
274
	mutex_lock(&kvm->irq_lock);
275
	hlist_del_rcu(&kimn->link);
276
	mutex_unlock(&kvm->irq_lock);
277
	synchronize_rcu();
278 279 280 281 282 283 284
}

void kvm_fire_mask_notifiers(struct kvm *kvm, int irq, bool mask)
{
	struct kvm_irq_mask_notifier *kimn;
	struct hlist_node *n;

285 286
	rcu_read_lock();
	hlist_for_each_entry_rcu(kimn, n, &kvm->mask_notifier_list, link)
287 288
		if (kimn->irq == irq)
			kimn->func(kimn, mask);
289
	rcu_read_unlock();
290 291
}

292 293
void kvm_free_irq_routing(struct kvm *kvm)
{
294 295
	/* Called only during vm destruction. Nobody can use the pointer
	   at this stage */
296
	kfree(kvm->irq_routing);
297 298
}

299 300
static int setup_routing_entry(struct kvm_irq_routing_table *rt,
			       struct kvm_kernel_irq_routing_entry *e,
301
			       const struct kvm_irq_routing_entry *ue)
302 303 304
{
	int r = -EINVAL;
	int delta;
305
	unsigned max_pin;
306 307 308 309 310 311 312 313 314 315 316
	struct kvm_kernel_irq_routing_entry *ei;
	struct hlist_node *n;

	/*
	 * Do not allow GSI to be mapped to the same irqchip more than once.
	 * Allow only one to one mapping between GSI and MSI.
	 */
	hlist_for_each_entry(ei, n, &rt->map[ue->gsi], link)
		if (ei->type == KVM_IRQ_ROUTING_MSI ||
		    ue->u.irqchip.irqchip == ei->irqchip.irqchip)
			return r;
317 318

	e->gsi = ue->gsi;
319
	e->type = ue->type;
320 321 322 323 324 325
	switch (ue->type) {
	case KVM_IRQ_ROUTING_IRQCHIP:
		delta = 0;
		switch (ue->u.irqchip.irqchip) {
		case KVM_IRQCHIP_PIC_MASTER:
			e->set = kvm_set_pic_irq;
326
			max_pin = 16;
327 328
			break;
		case KVM_IRQCHIP_PIC_SLAVE:
329
			e->set = kvm_set_pic_irq;
330
			max_pin = 16;
331 332 333
			delta = 8;
			break;
		case KVM_IRQCHIP_IOAPIC:
334
			max_pin = KVM_IOAPIC_NUM_PINS;
335
			e->set = kvm_set_ioapic_irq;
336 337 338 339 340 341
			break;
		default:
			goto out;
		}
		e->irqchip.irqchip = ue->u.irqchip.irqchip;
		e->irqchip.pin = ue->u.irqchip.pin + delta;
342
		if (e->irqchip.pin >= max_pin)
343 344
			goto out;
		rt->chip[ue->u.irqchip.irqchip][e->irqchip.pin] = ue->gsi;
345
		break;
S
Sheng Yang 已提交
346 347 348 349 350 351
	case KVM_IRQ_ROUTING_MSI:
		e->set = kvm_set_msi;
		e->msi.address_lo = ue->u.msi.address_lo;
		e->msi.address_hi = ue->u.msi.address_hi;
		e->msi.data = ue->u.msi.data;
		break;
352 353 354
	default:
		goto out;
	}
355 356

	hlist_add_head(&e->link, &rt->map[e->gsi]);
357 358 359 360 361 362 363 364 365 366 367
	r = 0;
out:
	return r;
}


int kvm_set_irq_routing(struct kvm *kvm,
			const struct kvm_irq_routing_entry *ue,
			unsigned nr,
			unsigned flags)
{
368
	struct kvm_irq_routing_table *new, *old;
369
	u32 i, j, nr_rt_entries = 0;
370 371
	int r;

372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389
	for (i = 0; i < nr; ++i) {
		if (ue[i].gsi >= KVM_MAX_IRQ_ROUTES)
			return -EINVAL;
		nr_rt_entries = max(nr_rt_entries, ue[i].gsi);
	}

	nr_rt_entries += 1;

	new = kzalloc(sizeof(*new) + (nr_rt_entries * sizeof(struct hlist_head))
		      + (nr * sizeof(struct kvm_kernel_irq_routing_entry)),
		      GFP_KERNEL);

	if (!new)
		return -ENOMEM;

	new->rt_entries = (void *)&new->map[nr_rt_entries];

	new->nr_rt_entries = nr_rt_entries;
390 391 392
	for (i = 0; i < 3; i++)
		for (j = 0; j < KVM_IOAPIC_NUM_PINS; j++)
			new->chip[i][j] = -1;
393

394 395 396 397
	for (i = 0; i < nr; ++i) {
		r = -EINVAL;
		if (ue->flags)
			goto out;
398
		r = setup_routing_entry(new, &new->rt_entries[i], ue);
399 400 401 402 403
		if (r)
			goto out;
		++ue;
	}

404
	mutex_lock(&kvm->irq_lock);
405
	old = kvm->irq_routing;
406
	rcu_assign_pointer(kvm->irq_routing, new);
407
	mutex_unlock(&kvm->irq_lock);
408
	synchronize_rcu();
409

410
	new = old;
411 412 413
	r = 0;

out:
414
	kfree(new);
415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
	return r;
}

#define IOAPIC_ROUTING_ENTRY(irq) \
	{ .gsi = irq, .type = KVM_IRQ_ROUTING_IRQCHIP,	\
	  .u.irqchip.irqchip = KVM_IRQCHIP_IOAPIC, .u.irqchip.pin = (irq) }
#define ROUTING_ENTRY1(irq) IOAPIC_ROUTING_ENTRY(irq)

#ifdef CONFIG_X86
#  define PIC_ROUTING_ENTRY(irq) \
	{ .gsi = irq, .type = KVM_IRQ_ROUTING_IRQCHIP,	\
	  .u.irqchip.irqchip = SELECT_PIC(irq), .u.irqchip.pin = (irq) % 8 }
#  define ROUTING_ENTRY2(irq) \
	IOAPIC_ROUTING_ENTRY(irq), PIC_ROUTING_ENTRY(irq)
#else
#  define ROUTING_ENTRY2(irq) \
	IOAPIC_ROUTING_ENTRY(irq)
#endif

static const struct kvm_irq_routing_entry default_routing[] = {
	ROUTING_ENTRY2(0), ROUTING_ENTRY2(1),
	ROUTING_ENTRY2(2), ROUTING_ENTRY2(3),
	ROUTING_ENTRY2(4), ROUTING_ENTRY2(5),
	ROUTING_ENTRY2(6), ROUTING_ENTRY2(7),
	ROUTING_ENTRY2(8), ROUTING_ENTRY2(9),
	ROUTING_ENTRY2(10), ROUTING_ENTRY2(11),
	ROUTING_ENTRY2(12), ROUTING_ENTRY2(13),
	ROUTING_ENTRY2(14), ROUTING_ENTRY2(15),
	ROUTING_ENTRY1(16), ROUTING_ENTRY1(17),
	ROUTING_ENTRY1(18), ROUTING_ENTRY1(19),
	ROUTING_ENTRY1(20), ROUTING_ENTRY1(21),
	ROUTING_ENTRY1(22), ROUTING_ENTRY1(23),
#ifdef CONFIG_IA64
	ROUTING_ENTRY1(24), ROUTING_ENTRY1(25),
	ROUTING_ENTRY1(26), ROUTING_ENTRY1(27),
	ROUTING_ENTRY1(28), ROUTING_ENTRY1(29),
	ROUTING_ENTRY1(30), ROUTING_ENTRY1(31),
	ROUTING_ENTRY1(32), ROUTING_ENTRY1(33),
	ROUTING_ENTRY1(34), ROUTING_ENTRY1(35),
	ROUTING_ENTRY1(36), ROUTING_ENTRY1(37),
	ROUTING_ENTRY1(38), ROUTING_ENTRY1(39),
	ROUTING_ENTRY1(40), ROUTING_ENTRY1(41),
	ROUTING_ENTRY1(42), ROUTING_ENTRY1(43),
	ROUTING_ENTRY1(44), ROUTING_ENTRY1(45),
	ROUTING_ENTRY1(46), ROUTING_ENTRY1(47),
#endif
};

int kvm_setup_default_irq_routing(struct kvm *kvm)
{
	return kvm_set_irq_routing(kvm, default_routing,
				   ARRAY_SIZE(default_routing), 0);
}