CSC 660: Advanced Operating SystemsSlide #1 CSC 660: Advanced OS Interrupts.

CSC 660: Advanced Operating Systems Slide #1

CSC 660: Advanced OS

Interrupts


Topics

1. Types of Interrupts

2. PIC and IRQs

3. Interrupt Handlers

4. Top Halves and Bottom Halves

5. Enabling/Disabling Interrupts

6. SoftIRQs

7. Tasklets

8. Work Queues

9. Timer Interrupts


How can hardware communicate with CPU?

Busy WaitIssue hardware request.Wait in tight loop until receives answer.

PollingIssue hardware request.Periodically check hardware status.

InterruptsIssue hardware request.Hardware signals CPU when answer ready.


Types of Interrupts

SynchronousProduced by CPU while executing instructions.Issues only after finishing execution of an instr.Often called exceptions.Ex: page faults, system calls, divide by zero

AsynchronousGenerated by other hardware devices.Occur at arbitrary times, including while CPU is

busy executing an instruction.Ex: I/O, timer interrupts


Programmable Interrupt Controller

PIC connectsHardware devices that issue IRQs.

CPU: INTR pin and data bus.

PIC features15 IRQ lines

Sharing and dynamic assignment of IRQs.

Masking (disabling) of selected IRQs.

CPU masking of all maskable interrupts: cli, sti.

APIC: Advanced PICHandles multiprocessor systems.


Interrupt VectorsVector Range Use

0-19 Nonmaskable interrupts and exceptions.

20-31 Intel-reserved

32-127 External interrupts (IRQs)

128 System Call exception

129-238 External interrupts (IRQs)

239 Local APIC timer interrupt

240 Local APIC thermal interrupt

241-250 Reserved by Linux for future use

251-253 Interprocessor interrupts

254 Local APIC error interrupt

255 Local APIC suprious interrupt


IRQ ExampleIRQ INT Hardware Device

0 32 Timer

1 33 Keyboard

2 34 PIC Cascading

3 35 Second serial port

4 36 First serial port

6 38 Floppy Disk

8 40 System Clock

10 42 Network Interface

11 43 USB port, sound card

12 44 PS/2 Mouse

13 45 Math Coprocessor

14 46 EIDE first controller

15 47 EIDE second controller


IRQ Handling

1. Monitor IRQ lines for raised signals.If multiple IRQs raised, select lowest # IRQ.

2. If raised signal detected1. Converts raised signal into vector (0-255).

2. Stores vector in I/O port, allowing CPU to read.

3. Sends raised signal to CPU INTR pin.

4. Waits for CPU to acknowledge interrupt.

5. Kernel runs do_IRQ().

6. Clears INTR line.

3. Goto step 1.


do_IRQ

1. Kernel jumps to entry point in entry.S.

2. Entry point saves registers, calls do_IRQ().

3. Finds IRQ number in saved %EAX register.

4. Looks up IRQ descriptor using IRQ #.

5. Acknowledges receipt of interrupt.

6. Disables interrupt delivery on line.

7. Calls handle_IRQ_event() to run handlers.

8. Cleans up and returns.

9. Jumps to ret_from_intr().


handle_IRQ_event()fastcall int handle_IRQ_event(unsigned int irq, struct pt_regs

*regs, struct irqaction *action){ int ret, retval = 0, status = 0;

if (!(action->flags & SA_INTERRUPT)) local_irq_enable(); do { ret = action->handler(irq, action->dev_id, regs); if (ret == IRQ_HANDLED) status |= action->flags; retval |= ret; action = action->next; } while (action); if (status & SA_SAMPLE_RANDOM) add_interrupt_randomness(irq); local_irq_disable(); return retval;}


Interrupt Handlers

Function kernel runs in response to interrupt.More than one handler can exist per IRQ.

Must run quickly.Resume execution of interrupted code.

How to deal with high work interrupts?

Ex: network, hard disk


Top and Bottom Halves

Top HalfThe interrupt handler.

Current interrupt disabled, possibly all disabled.

Runs in interrupt context, not process context. Can’t sleep.

Acknowledges receipt of interrupt.

Schedules bottom half to run later.

Bottom HalfRuns in process context with interrupts enabled.

Performs most work required. Can sleep.

Ex: copies network data to memory buffers.


Interrupt Context

Not associated with a process.Cannot sleep: no task to reschedule.

current macro points to interrupted process.

Shares kernel stack of interrupted process.Be very frugal in stack usage.


Registering a Handler

request_irq()Register an interrupt handler on a given line.

free_irq()Unregister a given interrupt handler.

Disable interrupt line if all handlers unregistered.


Registering a Handler

int request_irq(unsigned int irq,

irqreturn_t (*handler)(int, void *, struct pt_regs *),

unsigned long irqflags,

const char * devname,

void *dev_id)

irqflaqs = SA_INTERRUPT

| SA_SAMPLE_RANDOM

| SA_SHIRQ


Writing an Interrupt Handler

Differentiating between devicesPre-2.0: irq

Current: dev_id

RegistersPointer to registers before interrupt occurred.

Return ValuesIRQ_NONE: Interrupt not for handler.

IRQ_HANDLED: Interrupted handled.

irqreturn_t ih(int irq,void *devid,struct pt_regs *r)


RTC Handlerirqreturn_t rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs){ spin_lock (&rtc_lock); rtc_irq_data += 0x100; rtc_irq_data &= ~0xff; if (rtc_status & RTC_TIMER_ON) mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);

spin_unlock (&rtc_lock);

/* Now do the rest of the actions */ spin_lock(&rtc_task_lock); if (rtc_callback) rtc_callback->func(rtc_callback->private_data); spin_unlock(&rtc_task_lock); wake_up_interruptible(&rtc_wait);

kill_fasync (&rtc_async_queue, SIGIO, POLL_IN);

return IRQ_HANDLED;}


Interrupt Control

Disable/Enable Local Interruptslocal_irq_disable();/* interrupts are disabled */local_irq_enable();

Saving and Restoring IRQ stateUseful when don’t know prior IRQ state.unsigned long flags;local_irq_save(flags);/* interrupts are disabled */local_irq_restore(flags);/* interrupts in original state */


Interrupt Control

Disabling Specific InterruptsFor legacy hardware, avoid for shared IRQ lines.

disable_irq(irq)

enable_irq(irq)

What about other processors?Disable local interrupts + spin lock.

We’ll talk about spin locks next time…


Bottom Halves

Perform most work required by interrupt.Run in process context with interrupts enabled.

Three forms of deferring workSoftIRQs

Tasklets

Work Queues


SoftIRQs

Statically allocated at compile time.Only 32 softIRQs can exist (only 6 currently used.)struct softirq_action

{

void (*action)(struct softirq_action *);

void *data;

};

static struct softirq_action softirq_vec[32];

Tasklets built on SoftIRQs.All tasklets use one SoftIRQ.

Dynamically allocated.


SoftIRQ Handlers

Prototypevoid softirq_handler(struct softirq_action *)

Callingmy_softirq->action(my_softirq);

Pre-emptionSoftIRQs don’t pre-empt other softIRQs.

Interrupt handlers can pre-empt softIRQs.

Another softIRQ can run on other CPUs.


Executing SoftIRQs

Interrupt handler marks softIRQ.Called raising the softirq.

SoftIRQs checked for execution:In return from hardware interrupt code.

In ksoftirq kernel thread.

In any code that explicitly checks for softIRQs.

do_softirq()Loops over all softIRQs.


Current SoftIRQs

SoftIRQ Priority Description

HI 0 High priority tasklets.

TIMER 1 Timer bottom half.

NET_TX 2 Send network packets.

NET_RX 3 Receive network packets.

SCSI 4 SCSI bottom half.

TASKLET 5 Tasklets.


Tasklets

• Implemented as softIRQs.– Linked list of tasklet_struct objects.

• Two priorities of tasklets:– HI: tasklet_hi_schedule()– TASKLET: tasklet_schedule()

• Scheduled tasklets run via do_softirq()– HI action: tasklet_action()– TASKLET action: tasklet_hi_action()


ksoftirqd

SoftIRQs may occur at high frequencies.SoftIRQs may re-raise themselves.

Kernel will not handle re-raised softIRQs immediately in do_softirq().

Kernel thread ksoftirq solves problem.One thread per processor.

Runs at lowest priority (nice +19).


Work Queues

Defer work into a kernel thread.Execute in process context.

One thread per processor: events/n.

Processes can create own threads if needed.

struct workqueue_struct {

struct cpu_workqueue_struct cpu_wq[NR_CPUS];

const char *name;

struct list_head list; /* Empty if single thread */

};


Work Queue Data Structures

worker thread

work_struct

cpu_workqueue_struct 1/CPU

workqueue_struct 1/thread type

work_struct

work_struct1/deferrable function


Worker Thread

Each thread runs worker_thread()1. Marks self as sleeping.

2. Adds self to wait queue.

3. If linked list of work empty, schedule().

4. Else, marks self as running, removes from queue.

5. Calls run_workqueue() to perform work.


run_workqueue()1. Loops through list of work_structs

struct work_struct { unsigned long pending; struct list_head entry; void (*func)(void *); void *data; void *wq_data; struct timer_list timer;};

2. Retrieves function, func, and arg, data3. Removes entry from list, clears pending4. Invokes function


Which Bottom Half to Use?

1. If needs to sleep, use work queue.

2. If doesn’t need to sleep, use tasklet.

3. What about serialization needs?

Bottom Half Context Serialization

Softirq Interrupt None

Tasklet Interrupt Against same tasklet

Work queues Process None


Timer Interrupt

Executed HZ times a second.#define HZ 1000 /* <asm/param.h> */

Called the tick rate.Time between two interrupts is a tick.Driven by Programmable Interrupt Timer (PIT).

Interrupt handler responsibilitiesUpdating uptime, system time, kernel stats.Rescheduling if current has exhausted time slice.Balancing scheduler runqueues.Running dynamic timers.


Jiffies

Jiffies = number of ticks since boot.extern unsigned long volatile jiffies;

Incremented each timer interrupt.Uptime = jiffies/HZ seconds.Convert for user space: jiffies_to_clock_t()

Comparing jiffies, while avoiding overflow.time_after(a, b): a > btime_before(a,b) a < btime_after_eq(a,b): a >= btime_before_eq(a,b): a <= b


Timer Interrupt Handler

1. Increments jiffies.

2. Update resource usages (sys + user time.)

3. Run dynamic timers.

4. Execute scheduler_tick().

5. Update wall time.

6. Calculate load average.


References1. Daniel P. Bovet and Marco Cesati, Understanding the

Linux Kernel, 3rd edition, O’Reilly, 2005.2. Johnathan Corbet et. al., Linux Device Drivers, 3rd edition,

O’Reilly, 2005.3. Robert Love, Linux Kernel Development, 2nd edition,

Prentice-Hall, 2005.4. Claudia Rodriguez et al, The Linux Kernel Primer,

Prentice-Hall, 2005.5. Peter Salzman et. al., Linux Kernel Module Programming

Guide, version 2.6.1, 2005.6. Andrew S. Tanenbaum, Modern Operating Systems, 3rd

edition, Prentice-Hall, 2005.

CSC 660: Advanced Operating SystemsSlide #1 CSC 660: Advanced OS Interrupts.

Documents