Lecture: interrupts and exceptions

preparation

• review OSPP §2, The Kernel Abstraction, focusing on 2.3–2.6

recap

• CSE 351, system control flow
  • “normal” control flow - OS is no involved
  • exceptional control flow
    • asynchronous exceptions (interrupts)
    • synchronous exceptions (traps & faults)
• workflow
  • kernel boots up, then do we need the kernel again? list cases
    • provide services
    • handle errors
    • handle on-demand requests (e.g., growing stack)
    • handle devices
  • the “event” loop
    • CPU: execute an instruction
    • check for interrupts
    • if yes, run interrupt handler
    • resume
• interrupt sources
  • exceptions: page fault, div by zero
  • device interrupts: timer, I/O
  • software interrupts: system calls (int instruction)
• example: lazy allocation
  • user space: access unmapped memory
  • page fault occurs: pause execution
  • user → kernel transition - what to save
  • kernel: allocate a page on demand
  • kernel → user transition - what to restore
  • user space: resume execution
• example: div by zero
  • run the following div.c on xv6
  • Makefile: change -O2 to -O0; add _div to UPROGS
  • explain pid 4 div: trap 0 err 0 on cpu 0 eip 0x62 addr 0x0--kill proc
• questions
  • how do we get to trap()?
  • where is struct trapframe from?
    • alltraps in trapasm.S
    • vector0, …, vector255 in vectors.S
  • where are vectors first used?
    • trap.c for setting up the idt

#include "types.h"
#include "user.h"

int
main(int argc, char **argv)
{
  int x, y, z;

  if (argc < 3){
    printf(2, "usage: div x y\n");
    exit();
  }
  x = atoi(argv[1]);
  y = atoi(argv[2]);
  z  = x / y;
  printf(1, "%d / %d = %d\n", x, y, z);
  exit();
}

x86 interrupt handling

• 256 interrupt vectors: each interrupt has a number 0–255
  • 0–31: processor interrupts
    • reserved by Intel
    • examples: 0 (division by zero), 14 (page fault)
  • 32–255: kernel configured
    • xv6: 32–47 (IRQs), 64 (syscall) - see traps.h
    • how about JOS
  • terminology: interrupts, exceptions, traps, faults, aborts
• Interrupt Descriptor Table (IDT): find the interrupt handler
  • %idtr register: base address of IDT
  • IDT entries: gate descriptors, indexed by interrupt numbers
    • cs:offset: entry point
    • DPL
      • 0: exception and device interrupts
      • 3 - software interrupts
    • type
      • interrupt gate: clear IF of %eflags
      • trap gate: don’t change %eflags
  • xv6
    • trap.c: tvinit() - SETGATE, idtinit() - lidt
    • vectors.S
    • gdb
      • b idtinit
      • p/x idt[0]
      • pretty print: source gdbutil & printdesc idt[0]
• example: div
  • open div.asm and find the idivl instruction (e.g., at 0x62)
  • set a breakpoint at idivl (e.g., b *0x62)
  • run div 1 0 in xv6 shell
  • info registers: esp. cs & esp
    • recall: lower 2 bits of cs
    • 3 - user; 0 - kernel
  • single step: si
  • check registers again: in kernel now!
  • x/6x $esp
  • run to trap(): who set tf->trapno
• what if we don’t handle this trap?
  • decide where to return to in user space
  • add case T_DIVIDE: return; and single-step until iret
  • back to user space: re-execute: idivl
  • trap to kernel again
• is it possible to change division by zero to return 0 (or 42 if you want)?