1/*P:800 2 * Interrupts (traps) are complicated enough to earn their own file. 3 * There are three classes of interrupts: 4 * 5 * 1) Real hardware interrupts which occur while we're running the Guest, 6 * 2) Interrupts for virtual devices attached to the Guest, and 7 * 3) Traps and faults from the Guest. 8 * 9 * Real hardware interrupts must be delivered to the Host, not the Guest. 10 * Virtual interrupts must be delivered to the Guest, but we make them look 11 * just like real hardware would deliver them. Traps from the Guest can be set 12 * up to go directly back into the Guest, but sometimes the Host wants to see 13 * them first, so we also have a way of "reflecting" them into the Guest as if 14 * they had been delivered to it directly. 15:*/ 16#include <linux/uaccess.h> 17#include <linux/interrupt.h> 18#include <linux/module.h> 19#include <linux/sched.h> 20#include "lg.h" 21 22/* Allow Guests to use a non-128 (ie. non-Linux) syscall trap. */ 23static unsigned int syscall_vector = SYSCALL_VECTOR; 24module_param(syscall_vector, uint, 0444); 25 26/* The address of the interrupt handler is split into two bits: */ 27static unsigned long idt_address(u32 lo, u32 hi) 28{ 29 return (lo & 0x0000FFFF) | (hi & 0xFFFF0000); 30} 31 32/* 33 * The "type" of the interrupt handler is a 4 bit field: we only support a 34 * couple of types. 35 */ 36static int idt_type(u32 lo, u32 hi) 37{ 38 return (hi >> 8) & 0xF; 39} 40 41/* An IDT entry can't be used unless the "present" bit is set. */ 42static bool idt_present(u32 lo, u32 hi) 43{ 44 return (hi & 0x8000); 45} 46 47/* 48 * We need a helper to "push" a value onto the Guest's stack, since that's a 49 * big part of what delivering an interrupt does. 50 */ 51static void push_guest_stack(struct lg_cpu *cpu, unsigned long *gstack, u32 val) 52{ 53 /* Stack grows upwards: move stack then write value. */ 54 *gstack -= 4; 55 lgwrite(cpu, *gstack, u32, val); 56} 57 58/*H:210 59 * The set_guest_interrupt() routine actually delivers the interrupt or 60 * trap. The mechanics of delivering traps and interrupts to the Guest are the 61 * same, except some traps have an "error code" which gets pushed onto the 62 * stack as well: the caller tells us if this is one. 63 * 64 * "lo" and "hi" are the two parts of the Interrupt Descriptor Table for this 65 * interrupt or trap. It's split into two parts for traditional reasons: gcc 66 * on i386 used to be frightened by 64 bit numbers. 67 * 68 * We set up the stack just like the CPU does for a real interrupt, so it's 69 * identical for the Guest (and the standard "iret" instruction will undo 70 * it). 71 */ 72static void set_guest_interrupt(struct lg_cpu *cpu, u32 lo, u32 hi, 73 bool has_err) 74{ 75 unsigned long gstack, origstack; 76 u32 eflags, ss, irq_enable; 77 unsigned long virtstack; 78 79 /* 80 * There are two cases for interrupts: one where the Guest is already 81 * in the kernel, and a more complex one where the Guest is in 82 * userspace. We check the privilege level to find out. 83 */ 84 if ((cpu->regs->ss&0x3) != GUEST_PL) { 85 /* 86 * The Guest told us their kernel stack with the SET_STACK 87 * hypercall: both the virtual address and the segment. 88 */ 89 virtstack = cpu->esp1; 90 ss = cpu->ss1; 91 92 origstack = gstack = guest_pa(cpu, virtstack); 93 /* 94 * We push the old stack segment and pointer onto the new 95 * stack: when the Guest does an "iret" back from the interrupt 96 * handler the CPU will notice they're dropping privilege 97 * levels and expect these here. 98 */ 99 push_guest_stack(cpu, &gstack, cpu->regs->ss); 100 push_guest_stack(cpu, &gstack, cpu->regs->esp); 101 } else { 102 /* We're staying on the same Guest (kernel) stack. */ 103 virtstack = cpu->regs->esp; 104 ss = cpu->regs->ss; 105 106 origstack = gstack = guest_pa(cpu, virtstack); 107 } 108 109 /* 110 * Remember that we never let the Guest actually disable interrupts, so 111 * the "Interrupt Flag" bit is always set. We copy that bit from the 112 * Guest's "irq_enabled" field into the eflags word: we saw the Guest 113 * copy it back in "lguest_iret". 114 */ 115 eflags = cpu->regs->eflags; 116 if (get_user(irq_enable, &cpu->lg->lguest_data->irq_enabled) == 0 117 && !(irq_enable & X86_EFLAGS_IF)) 118 eflags &= ~X86_EFLAGS_IF; 119 120 /* 121 * An interrupt is expected to push three things on the stack: the old 122 * "eflags" word, the old code segment, and the old instruction 123 * pointer. 124 */ 125 push_guest_stack(cpu, &gstack, eflags); 126 push_guest_stack(cpu, &gstack, cpu->regs->cs); 127 push_guest_stack(cpu, &gstack, cpu->regs->eip); 128 129 /* For the six traps which supply an error code, we push that, too. */ 130 if (has_err) 131 push_guest_stack(cpu, &gstack, cpu->regs->errcode); 132 133 /* 134 * Now we've pushed all the old state, we change the stack, the code 135 * segment and the address to execute. 136 */ 137 cpu->regs->ss = ss; 138 cpu->regs->esp = virtstack + (gstack - origstack); 139 cpu->regs->cs = (__KERNEL_CS|GUEST_PL); 140 cpu->regs->eip = idt_address(lo, hi); 141 142 /* 143 * There are two kinds of interrupt handlers: 0xE is an "interrupt 144 * gate" which expects interrupts to be disabled on entry. 145 */ 146 if (idt_type(lo, hi) == 0xE) 147 if (put_user(0, &cpu->lg->lguest_data->irq_enabled)) 148 kill_guest(cpu, "Disabling interrupts"); 149} 150 151/*H:205 152 * Virtual Interrupts. 153 * 154 * interrupt_pending() returns the first pending interrupt which isn't blocked 155 * by the Guest. It is called before every entry to the Guest, and just before 156 * we go to sleep when the Guest has halted itself. 157 */ 158unsigned int interrupt_pending(struct lg_cpu *cpu, bool *more) 159{ 160 unsigned int irq; 161 DECLARE_BITMAP(blk, LGUEST_IRQS); 162 163 /* If the Guest hasn't even initialized yet, we can do nothing. */ 164 if (!cpu->lg->lguest_data) 165 return LGUEST_IRQS; 166 167 /* 168 * Take our "irqs_pending" array and remove any interrupts the Guest 169 * wants blocked: the result ends up in "blk". 170 */ 171 if (copy_from_user(&blk, cpu->lg->lguest_data->blocked_interrupts, 172 sizeof(blk))) 173 return LGUEST_IRQS; 174 bitmap_andnot(blk, cpu->irqs_pending, blk, LGUEST_IRQS); 175 176 /* Find the first interrupt. */ 177 irq = find_first_bit(blk, LGUEST_IRQS); 178 *more = find_next_bit(blk, LGUEST_IRQS, irq+1); 179 180 return irq; 181} 182 183/* 184 * This actually diverts the Guest to running an interrupt handler, once an 185 * interrupt has been identified by interrupt_pending(). 186 */ 187void try_deliver_interrupt(struct lg_cpu *cpu, unsigned int irq, bool more) 188{ 189 struct desc_struct *idt; 190 191 BUG_ON(irq >= LGUEST_IRQS); 192 193 /* 194 * They may be in the middle of an iret, where they asked us never to 195 * deliver interrupts. 196 */ 197 if (cpu->regs->eip >= cpu->lg->noirq_start && 198 (cpu->regs->eip < cpu->lg->noirq_end)) 199 return; 200 201 /* If they're halted, interrupts restart them. */ 202 if (cpu->halted) { 203 /* Re-enable interrupts. */ 204 if (put_user(X86_EFLAGS_IF, &cpu->lg->lguest_data->irq_enabled)) 205 kill_guest(cpu, "Re-enabling interrupts"); 206 cpu->halted = 0; 207 } else { 208 /* Otherwise we check if they have interrupts disabled. */ 209 u32 irq_enabled; 210 if (get_user(irq_enabled, &cpu->lg->lguest_data->irq_enabled)) 211 irq_enabled = 0; 212 if (!irq_enabled) { 213 /* Make sure they know an IRQ is pending. */ 214 put_user(X86_EFLAGS_IF, 215 &cpu->lg->lguest_data->irq_pending); 216 return; 217 } 218 } 219 220 /* 221 * Look at the IDT entry the Guest gave us for this interrupt. The 222 * first 32 (FIRST_EXTERNAL_VECTOR) entries are for traps, so we skip 223 * over them. 224 */ 225 idt = &cpu->arch.idt[FIRST_EXTERNAL_VECTOR+irq]; 226 /* If they don't have a handler (yet?), we just ignore it */ 227 if (idt_present(idt->a, idt->b)) { 228 /* OK, mark it no longer pending and deliver it. */ 229 clear_bit(irq, cpu->irqs_pending); 230 /* 231 * set_guest_interrupt() takes the interrupt descriptor and a 232 * flag to say whether this interrupt pushes an error code onto 233 * the stack as well: virtual interrupts never do. 234 */ 235 set_guest_interrupt(cpu, idt->a, idt->b, false); 236 } 237 238 /* 239 * Every time we deliver an interrupt, we update the timestamp in the 240 * Guest's lguest_data struct. It would be better for the Guest if we 241 * did this more often, but it can actually be quite slow: doing it 242 * here is a compromise which means at least it gets updated every 243 * timer interrupt. 244 */ 245 write_timestamp(cpu); 246 247 /* 248 * If there are no other interrupts we want to deliver, clear 249 * the pending flag. 250 */ 251 if (!more) 252 put_user(0, &cpu->lg->lguest_data->irq_pending); 253} 254 255/* And this is the routine when we want to set an interrupt for the Guest. */ 256void set_interrupt(struct lg_cpu *cpu, unsigned int irq) 257{ 258 /* 259 * Next time the Guest runs, the core code will see if it can deliver 260 * this interrupt. 261 */ 262 set_bit(irq, cpu->irqs_pending); 263 264 /* 265 * Make sure it sees it; it might be asleep (eg. halted), or running 266 * the Guest right now, in which case kick_process() will knock it out. 267 */ 268 if (!wake_up_process(cpu->tsk)) 269 kick_process(cpu->tsk); 270} 271/*:*/ 272 273/* 274 * Linux uses trap 128 for system calls. Plan9 uses 64, and Ron Minnich sent 275 * me a patch, so we support that too. It'd be a big step for lguest if half 276 * the Plan 9 user base were to start using it. 277 * 278 * Actually now I think of it, it's possible that Ron *is* half the Plan 9 279 * userbase. Oh well. 280 */ 281static bool could_be_syscall(unsigned int num) 282{ 283 /* Normal Linux SYSCALL_VECTOR or reserved vector? */ 284 return num == SYSCALL_VECTOR || num == syscall_vector; 285} 286 287/* The syscall vector it wants must be unused by Host. */ 288bool check_syscall_vector(struct lguest *lg) 289{ 290 u32 vector; 291 292 if (get_user(vector, &lg->lguest_data->syscall_vec)) 293 return false; 294 295 return could_be_syscall(vector); 296} 297 298int init_interrupts(void) 299{ 300 /* If they want some strange system call vector, reserve it now */ 301 if (syscall_vector != SYSCALL_VECTOR) { 302 if (test_bit(syscall_vector, used_vectors) || 303 vector_used_by_percpu_irq(syscall_vector)) { 304 printk(KERN_ERR "lg: couldn't reserve syscall %u\n", 305 syscall_vector); 306 return -EBUSY; 307 } 308 set_bit(syscall_vector, used_vectors); 309 } 310 311 return 0; 312} 313 314void free_interrupts(void) 315{ 316 if (syscall_vector != SYSCALL_VECTOR) 317 clear_bit(syscall_vector, used_vectors); 318} 319 320/*H:220 321 * Now we've got the routines to deliver interrupts, delivering traps like 322 * page fault is easy. The only trick is that Intel decided that some traps 323 * should have error codes: 324 */ 325static bool has_err(unsigned int trap) 326{ 327 return (trap == 8 || (trap >= 10 && trap <= 14) || trap == 17); 328} 329 330/* deliver_trap() returns true if it could deliver the trap. */ 331bool deliver_trap(struct lg_cpu *cpu, unsigned int num) 332{ 333 /* 334 * Trap numbers are always 8 bit, but we set an impossible trap number 335 * for traps inside the Switcher, so check that here. 336 */ 337 if (num >= ARRAY_SIZE(cpu->arch.idt)) 338 return false; 339 340 /* 341 * Early on the Guest hasn't set the IDT entries (or maybe it put a 342 * bogus one in): if we fail here, the Guest will be killed. 343 */ 344 if (!idt_present(cpu->arch.idt[num].a, cpu->arch.idt[num].b)) 345 return false; 346 set_guest_interrupt(cpu, cpu->arch.idt[num].a, 347 cpu->arch.idt[num].b, has_err(num)); 348 return true; 349} 350 351/*H:250 352 * Here's the hard part: returning to the Host every time a trap happens 353 * and then calling deliver_trap() and re-entering the Guest is slow. 354 * Particularly because Guest userspace system calls are traps (usually trap 355 * 128). 356 * 357 * So we'd like to set up the IDT to tell the CPU to deliver traps directly 358 * into the Guest. This is possible, but the complexities cause the size of 359 * this file to double! However, 150 lines of code is worth writing for taking 360 * system calls down from 1750ns to 270ns. Plus, if lguest didn't do it, all 361 * the other hypervisors would beat it up at lunchtime. 362 * 363 * This routine indicates if a particular trap number could be delivered 364 * directly. 365 */ 366static bool direct_trap(unsigned int num) 367{ 368 /* 369 * Hardware interrupts don't go to the Guest at all (except system 370 * call). 371 */ 372 if (num >= FIRST_EXTERNAL_VECTOR && !could_be_syscall(num)) 373 return false; 374 375 /* 376 * The Host needs to see page faults (for shadow paging and to save the 377 * fault address), general protection faults (in/out emulation) and 378 * device not available (TS handling), invalid opcode fault (kvm hcall), 379 * and of course, the hypercall trap. 380 */ 381 return num != 14 && num != 13 && num != 7 && 382 num != 6 && num != LGUEST_TRAP_ENTRY; 383} 384/*:*/ 385 386/*M:005 387 * The Guest has the ability to turn its interrupt gates into trap gates, 388 * if it is careful. The Host will let trap gates can go directly to the 389 * Guest, but the Guest needs the interrupts atomically disabled for an 390 * interrupt gate. It can do this by pointing the trap gate at instructions 391 * within noirq_start and noirq_end, where it can safely disable interrupts. 392 */ 393 394/*M:006 395 * The Guests do not use the sysenter (fast system call) instruction, 396 * because it's hardcoded to enter privilege level 0 and so can't go direct. 397 * It's about twice as fast as the older "int 0x80" system call, so it might 398 * still be worthwhile to handle it in the Switcher and lcall down to the 399 * Guest. The sysenter semantics are hairy tho: search for that keyword in 400 * entry.S 401:*/ 402 403/*H:260 404 * When we make traps go directly into the Guest, we need to make sure 405 * the kernel stack is valid (ie. mapped in the page tables). Otherwise, the 406 * CPU trying to deliver the trap will fault while trying to push the interrupt 407 * words on the stack: this is called a double fault, and it forces us to kill 408 * the Guest. 409 * 410 * Which is deeply unfair, because (literally!) it wasn't the Guests' fault. 411 */ 412void pin_stack_pages(struct lg_cpu *cpu) 413{ 414 unsigned int i; 415 416 /* 417 * Depending on the CONFIG_4KSTACKS option, the Guest can have one or 418 * two pages of stack space. 419 */ 420 for (i = 0; i < cpu->lg->stack_pages; i++) 421 /* 422 * The stack grows *upwards*, so the address we're given is the 423 * start of the page after the kernel stack. Subtract one to 424 * get back onto the first stack page, and keep subtracting to 425 * get to the rest of the stack pages. 426 */ 427 pin_page(cpu, cpu->esp1 - 1 - i * PAGE_SIZE); 428} 429 430/* 431 * Direct traps also mean that we need to know whenever the Guest wants to use 432 * a different kernel stack, so we can change the IDT entries to use that 433 * stack. The IDT entries expect a virtual address, so unlike most addresses 434 * the Guest gives us, the "esp" (stack pointer) value here is virtual, not 435 * physical. 436 * 437 * In Linux each process has its own kernel stack, so this happens a lot: we 438 * change stacks on each context switch. 439 */ 440void guest_set_stack(struct lg_cpu *cpu, u32 seg, u32 esp, unsigned int pages) 441{ 442 /* 443 * You're not allowed a stack segment with privilege level 0: bad Guest! 444 */ 445 if ((seg & 0x3) != GUEST_PL) 446 kill_guest(cpu, "bad stack segment %i", seg); 447 /* We only expect one or two stack pages. */ 448 if (pages > 2) 449 kill_guest(cpu, "bad stack pages %u", pages); 450 /* Save where the stack is, and how many pages */ 451 cpu->ss1 = seg; 452 cpu->esp1 = esp; 453 cpu->lg->stack_pages = pages; 454 /* Make sure the new stack pages are mapped */ 455 pin_stack_pages(cpu); 456} 457 458/* 459 * All this reference to mapping stacks leads us neatly into the other complex 460 * part of the Host: page table handling. 461 */ 462 463/*H:235 464 * This is the routine which actually checks the Guest's IDT entry and 465 * transfers it into the entry in "struct lguest": 466 */ 467static void set_trap(struct lg_cpu *cpu, struct desc_struct *trap, 468 unsigned int num, u32 lo, u32 hi) 469{ 470 u8 type = idt_type(lo, hi); 471 472 /* We zero-out a not-present entry */ 473 if (!idt_present(lo, hi)) { 474 trap->a = trap->b = 0; 475 return; 476 } 477 478 /* We only support interrupt and trap gates. */ 479 if (type != 0xE && type != 0xF) 480 kill_guest(cpu, "bad IDT type %i", type); 481 482 /* 483 * We only copy the handler address, present bit, privilege level and 484 * type. The privilege level controls where the trap can be triggered 485 * manually with an "int" instruction. This is usually GUEST_PL, 486 * except for system calls which userspace can use. 487 */ 488 trap->a = ((__KERNEL_CS|GUEST_PL)<<16) | (lo&0x0000FFFF); 489 trap->b = (hi&0xFFFFEF00); 490} 491 492/*H:230 493 * While we're here, dealing with delivering traps and interrupts to the 494 * Guest, we might as well complete the picture: how the Guest tells us where 495 * it wants them to go. This would be simple, except making traps fast 496 * requires some tricks. 497 * 498 * We saw the Guest setting Interrupt Descriptor Table (IDT) entries with the 499 * LHCALL_LOAD_IDT_ENTRY hypercall before: that comes here. 500 */ 501void load_guest_idt_entry(struct lg_cpu *cpu, unsigned int num, u32 lo, u32 hi) 502{ 503 /* 504 * Guest never handles: NMI, doublefault, spurious interrupt or 505 * hypercall. We ignore when it tries to set them. 506 */ 507 if (num == 2 || num == 8 || num == 15 || num == LGUEST_TRAP_ENTRY) 508 return; 509 510 /* 511 * Mark the IDT as changed: next time the Guest runs we'll know we have 512 * to copy this again. 513 */ 514 cpu->changed |= CHANGED_IDT; 515 516 /* Check that the Guest doesn't try to step outside the bounds. */ 517 if (num >= ARRAY_SIZE(cpu->arch.idt)) 518 kill_guest(cpu, "Setting idt entry %u", num); 519 else 520 set_trap(cpu, &cpu->arch.idt[num], num, lo, hi); 521} 522 523/* 524 * The default entry for each interrupt points into the Switcher routines which 525 * simply return to the Host. The run_guest() loop will then call 526 * deliver_trap() to bounce it back into the Guest. 527 */ 528static void default_idt_entry(struct desc_struct *idt, 529 int trap, 530 const unsigned long handler, 531 const struct desc_struct *base) 532{ 533 /* A present interrupt gate. */ 534 u32 flags = 0x8e00; 535 536 /* 537 * Set the privilege level on the entry for the hypercall: this allows 538 * the Guest to use the "int" instruction to trigger it. 539 */ 540 if (trap == LGUEST_TRAP_ENTRY) 541 flags |= (GUEST_PL << 13); 542 else if (base) 543 /* 544 * Copy privilege level from what Guest asked for. This allows 545 * debug (int 3) traps from Guest userspace, for example. 546 */ 547 flags |= (base->b & 0x6000); 548 549 /* Now pack it into the IDT entry in its weird format. */ 550 idt->a = (LGUEST_CS<<16) | (handler&0x0000FFFF); 551 idt->b = (handler&0xFFFF0000) | flags; 552} 553 554/* When the Guest first starts, we put default entries into the IDT. */ 555void setup_default_idt_entries(struct lguest_ro_state *state, 556 const unsigned long *def) 557{ 558 unsigned int i; 559 560 for (i = 0; i < ARRAY_SIZE(state->guest_idt); i++) 561 default_idt_entry(&state->guest_idt[i], i, def[i], NULL); 562} 563 564/*H:240 565 * We don't use the IDT entries in the "struct lguest" directly, instead 566 * we copy them into the IDT which we've set up for Guests on this CPU, just 567 * before we run the Guest. This routine does that copy. 568 */ 569void copy_traps(const struct lg_cpu *cpu, struct desc_struct *idt, 570 const unsigned long *def) 571{ 572 unsigned int i; 573 574 /* 575 * We can simply copy the direct traps, otherwise we use the default 576 * ones in the Switcher: they will return to the Host. 577 */ 578 for (i = 0; i < ARRAY_SIZE(cpu->arch.idt); i++) { 579 const struct desc_struct *gidt = &cpu->arch.idt[i]; 580 581 /* If no Guest can ever override this trap, leave it alone. */ 582 if (!direct_trap(i)) 583 continue; 584 585 /* 586 * Only trap gates (type 15) can go direct to the Guest. 587 * Interrupt gates (type 14) disable interrupts as they are 588 * entered, which we never let the Guest do. Not present 589 * entries (type 0x0) also can't go direct, of course. 590 * 591 * If it can't go direct, we still need to copy the priv. level: 592 * they might want to give userspace access to a software 593 * interrupt. 594 */ 595 if (idt_type(gidt->a, gidt->b) == 0xF) 596 idt[i] = *gidt; 597 else 598 default_idt_entry(&idt[i], i, def[i], gidt); 599 } 600} 601 602/*H:200 603 * The Guest Clock. 604 * 605 * There are two sources of virtual interrupts. We saw one in lguest_user.c: 606 * the Launcher sending interrupts for virtual devices. The other is the Guest 607 * timer interrupt. 608 * 609 * The Guest uses the LHCALL_SET_CLOCKEVENT hypercall to tell us how long to 610 * the next timer interrupt (in nanoseconds). We use the high-resolution timer 611 * infrastructure to set a callback at that time. 612 * 613 * 0 means "turn off the clock". 614 */ 615void guest_set_clockevent(struct lg_cpu *cpu, unsigned long delta) 616{ 617 ktime_t expires; 618 619 if (unlikely(delta == 0)) { 620 /* Clock event device is shutting down. */ 621 hrtimer_cancel(&cpu->hrt); 622 return; 623 } 624 625 /* 626 * We use wallclock time here, so the Guest might not be running for 627 * all the time between now and the timer interrupt it asked for. This 628 * is almost always the right thing to do. 629 */ 630 expires = ktime_add_ns(ktime_get_real(), delta); 631 hrtimer_start(&cpu->hrt, expires, HRTIMER_MODE_ABS); 632} 633 634/* This is the function called when the Guest's timer expires. */ 635static enum hrtimer_restart clockdev_fn(struct hrtimer *timer) 636{ 637 struct lg_cpu *cpu = container_of(timer, struct lg_cpu, hrt); 638 639 /* Remember the first interrupt is the timer interrupt. */ 640 set_interrupt(cpu, 0); 641 return HRTIMER_NORESTART; 642} 643 644/* This sets up the timer for this Guest. */ 645void init_clockdev(struct lg_cpu *cpu) 646{ 647 hrtimer_init(&cpu->hrt, CLOCK_REALTIME, HRTIMER_MODE_ABS); 648 cpu->hrt.function = clockdev_fn; 649} 650