378-LKP: Lecture 11

Linux Time Management

Feb 22, 2002
Yongguang Zhang

Today's Lecture

Q&A
Interrupt Handling
Time Management

Linux Interrupt Handling

Hardware Interrupt:
- A signal that the hardware sends to get kernel's attention
- See all interrupts: /proc/interrupts

To Service a Hardware Interrupt:

int request_irq(unsigned int irq,
        void (*handler)(),
        unsigned long flags,
        const char *dev_name,
        void *dev_id);

Top Half and Bottom Half

Within Interrupt Handler: All Interrupts are Blocked
- Interrupt Handlers Must Finish up Quickly
- So as not to keep interrupts blocked for long
- How to perform longer tasks within a handler?
Linux Splitting the Interrupt Handler Into Two Halves
- Top half: the function actually responds to the interrupt (the one registered with request_irq())
- Bottom half: a routine that is deferred by the top half to be executed later, at a safer time

Bottom Half

During Bottom Half: All Interrupts Are Enabled
Typical Scenario:
- Top half saves device data to a device-specific buffer, schedules its bottom half, and exits
- Bottom half runs later to perform whatever other work is required to finish the interrupt handling
Still Run in Interrupt Context:
- cannot sleep
- cannot access user space
- cannot invoke the scheduler (but can set the need_resched field)

Tasklet

A Really Really Lightweight Task (Thread)
- A type of kernel routine that can be scheduled to run later (at a system-determined safe time)
- Run in interrupt context
Interrupt Bottom Half:
- Implemented as a tasklet

Tasklet Properties

Guaranteed to run once
- Once scheduled (by tasklet_schedule() ), a tasklet is guaranteed to be executed once after that
- An already scheduled but not yet executed tasklet can be rescheduled, but will be executed only once
Once a tasklet starts running, it can be rescheduled to run again later
Tasklet is strictly serialized (run once), different tasklets can run simultaneously in different CPUs.

Implementing Tasklet

In include/linux/interrupt.h

Data Structure:

struct tasklet_struct
{
        struct tasklet_struct *next;
        unsigned long state;
        atomic_t count;
        void (*func)(unsigned long);
        unsigned long data;
};

A Linked List of All Tasklet (one per CPU)

Declaring Tasklet

DECLARE_TASKLET(name,function,data)
- Declares a tasklet with the given name, function, and (unsigned long) data value.
DECLARE_TASKLET_DISABLED(name,function,data)
- Declares a tasklet but with initial state "disabled" -- it can be scheduled but will not be executed until enabled at some future time

Using Tasklet

void tasklet_schedule(struct tasklet_struct *t)
- To schedule a tasklet to run soon
void tasklet_disable(struct tasklet_struct *t)
- To disable the tasklet
- The tasklet may still be scheduled (with tasklet_schedule), but its execution will be deferred until after it is enabled again
void tasklet_enable(struct tasklet_struct *t)
- To enable a tasklet that had been previously disabled
- If the tasklet has already been scheduled, it will run soon (but not immediately within tasklet_enable)

Interrupt Bottom Half

Implemented Using Tasklet
Backward Compatibility: The old BH structure
- A list of BH functions (tasklet), one per interrupt
- Using mark_bh(int nr) to schedule a BH function
- In include/linux/interrupt.h
```
extern struct tasklet_struct bh_task_vec[];
static inline void mark_bh(int nr)
{
        tasklet_hi_schedule(bh_task_vec+nr);
}
```

Clocks in Linux

Real-Time Clock (RTC)
- Independent of CPU
CPU Cycle Counter (TSC Register)
- For keeping track of time of day (gettimeofday())
- For accurate time measurements
- Granularity: CPU cycle (e.g. 1GHz)
Kernel Clock (Programmable Interval Timer)
- Each tick: cause timer interrupt at a fixed interval
- For the kernel to keep track of time
- Granularity: much larger: in terms of 10 Hz-1000 Hz

CPU Cycle Counter

In Intel Architecture
- TSC (Time Stamp Counter) register
- Updated by hardware
Granularity: CPU cycle
- 64-bit
To Read
- cycles_t get_cycles (void)
- Defined in include/asm/timex.h
- Implemented as rdtsc() calls in i386

Timer Interrupt

Frequency: HZ (per second)
- See include/asm-i386/param.h
- #define HZ 100
Hardware Interrupt Handler
- Calls the kernel timer interrupt handler routine when the clock ticks
jiffies: Number of Ticks Since System Boot Time
- Defined in include/linux/sched.h
```
    extern unsigned long volatile jiffies;
```
- Incremented in timer interrupt handler

Timer Interrupt Handler

Called Each Time the Kernel Clock Ticks
Interrupt service routine: timer_interrupt()
Timer Interrupt Handler Top Half
- Architecture-dependent: arch/i386/kernel/time.c
- timer_interrupt()
  - Calls do_timer_interrupt()
- do_timer_interrupt()
  - Calls do_timer()
  - Adjust RTC if needed

`do_timer()`

Architecture Independent

Defined in kernel/timer.c

void do_timer(struct pt_regs *regs)
{
        (*(unsigned long *)&jiffies)++;
        mark_bh(TIMER_BH);
        if (TQ_ACTIVE(tq_timer))
                mark_bh(TQUEUE_BH);
}

Q: when jiffies is updated in top half?

Timer Button Half

In kernel/timer.c

void timer_bh(void)
{
        update_times();
        run_timer_list();
}

update_times(): update the xtime structure
run_timer_list(): process the list of kernel interval timers (with expiration time smaller than or equal to jiffies)

Maintaining Wall Clock

xtime variable
- Declare in include/linux/sched.h
- xtime.tv_sec: second since 1/1/1970
- xtime.tv_usec: microseconds within the second

Updating xtime: in update_times()

ticks = jiffies - wall_jiffies;
if (ticks) {
        wall_jiffies += ticks;
        update_wall_time(ticks);
}

Kernel Timers

Maintained in the kernel data structure

In kernel/linux/timer.h

struct timer_list {
        struct list_head list;
        unsigned long expires;
        unsigned long data;
        void (*function)(unsigned long);
};
extern void add_timer(struct timer_list * timer);
extern int del_timer(struct timer_list * timer);

Processed by run_timer_list()

Next Lecture

Synchronization
Mutual Exclusion and Atomic Actions
Locks, Spinlocks