Quick Reference

This chapter introduced the following symbols:

#include <linux/param.h> , HZ

The HZ symbol specifies the number of clock ticks generated per second.

#include <linux/sched.h> , volatile unsigned long jiffies

The jiffies variable is incremented once for each clock tick; thus, it’s incremented HZ times per second.

#include <asm/msr.h> , rdtsc(low,high); , rdtscl(low);

Read the timestamp counter or its lower half. The header and macros are specific to PC-class processors; other platforms may need asm constructs to achieve similar results.

extern struct timeval xtime;

The current time, as calculated at the last timer tick.

#include <linux/time.h> , void do_gettimeofday(struct timeval *tv); , void get_fast_time(struct timeval *tv);

The functions return the current time; the former is very high resolution, the latter may be faster while giving coarser resolution.

#include <linux/delay.h> , void udelay(unsigned long usecs); , void mdelay(unsigned long msecs);

The functions introduce delays of an integer number of microseconds and milliseconds. The former should be used to wait for no longer than one millisecond; the latter should be used with extreme care because these delays are both busy-loops.

int in_interrupt();

Returns nonzero if the processor is currently running in interrupt mode.

#include <linux/tqueue.h> , DECLARE_TASK_QUEUE(variablename);

The macro declares a new variable and initializes it.

void queue_task(struct tq_struct *task, task_queue *list);

The function registers a task for later execution.

void run_task_queue(task_queue *list);

This function consumes a task queue.

task_queue tq_immediate, tq_timer;

These predefined task queues are run as soon as possible (for tq_immediate), or after each timer tick (for tq_timer).

int schedule_task(struct tq_struct *task);

Schedules a task to be run on the scheduler queue.

#include <linux/interrupt.h> , DECLARE_TASKLET(name, function, data) , DECLARE_TASKLET_DISABLED(name, function, data)

Declare a tasklet structure that will call the given function (passing it the given unsigned long data) when the tasklet is executed. The second form initializes the tasklet to a disabled state, keeping it from running until it is explicitly enabled.

void tasklet_schedule(struct tasklet_struct *tasklet);

Schedules the given tasklet for running. If the tasklet is enabled, it will be run shortly on the same CPU that ran the first call to tasklet_schedule.

tasklet_enable(struct tasklet_struct *tasklet); , tasklet_disable(struct tasklet_struct *tasklet);

These functions respectively enable and disable the given tasklet. A disabled tasklet can be scheduled, but will not run until it has been enabled again.

void tasklet_kill(struct tasklet_struct *tasklet);

Causes an “infinitely rescheduling” tasklet to cease execution. This function can block and may not be called in interrupt time.

#include <linux/timer.h> , void init_timer(struct timer_list * timer);

This function initializes a newly allocated timer.

void add_timer(struct timer_list * timer);

This function inserts the timer into the global list of pending timers.

int mod_timer(struct timer_list *timer, unsigned long expires);

This function is used to change the expiration time of an already scheduled timer structure.

int del_timer(struct timer_list * timer);

del_timer removes a timer from the list of pending timers. If the timer was actually queued, del_timer returns 1; otherwise, it returns 0.

int del_timer_sync(struct timer_list *timer);

This function is similar to del_timer, but guarantees that the function is not currently running on other CPUs.

Get Linux Device Drivers, Second Edition now with O’Reilly online learning.

O’Reilly members experience live online training, plus books, videos, and digital content from 200+ publishers.