Quick Reference

This section summarizes the kernel functions, variables, macros, and /proc files that we’ve touched on in this chapter. It is meant to act as a reference. Each item is listed after the relevant header file, if any. A similar section appears at the end of every chapter from here on, summarizing the new symbols introduced in the chapter.


Preprocessor symbols, which must both be defined to compile modularized kernel code.


A preprocessor symbol that must be defined when compiling modules for symmetric multiprocessor systems.

int init_module(void); , void cleanup_module(void);

Module entry points, which must be defined in the module object file.

#include <linux/init.h> , module_init(init_function); , module_exit(cleanup_function);

The modern mechanism for marking a module’s initialization and cleanup functions.

#include <linux/module.h>

Required header. It must be included by a module source.


Macros that act on the usage count.


The list of currently loaded modules. Entries contain the module name, the amount of memory each module occupies, and the usage count. Extra strings are appended to each line to specify flags that are currently active for the module.


Preprocessor macro, required for modules that export symbols.


Macro used to specify that the module exports no symbols to the kernel.


Macro used to export a symbol to the kernel. The second form exports without using versioning information.

int register_symtab(struct symbol_table *);

Function used to specify the set of public symbols in the module. Used in 2.0 kernels only.

#include <linux/symtab_begin.h> , X(symbol), , #include <linux/symtab_end.h>

Headers and preprocessor macro used to declare a symbol table in the 2.0 kernel.

MODULE_PARM(variable, type); , MODULE_PARM_DESC (variable, description);

Macros that make a module variable available as a parameter that may be adjusted by the user at module load time.


Place documentation on the module in the object file.

#include <linux/version.h>

Required header. It is included by <linux/module.h>, unless __NO_VERSION__ is defined (see later in this list).


Integer macro, useful to #ifdef version dependencies.

char kernel_version[] = UTS_RELEASE;

Required variable in every module. <linux/module.h> defines it, unless __NO_VERSION__ is defined (see the following entry).


Preprocessor symbol. Prevents declaration of kernel_version in <linux/module.h>.

#include <linux/sched.h>

One of the most important header files. This file contains definitions of much of the kernel API used by the driver, including functions for sleeping and numerous variable declarations.

struct task_struct *current;

The current process.

current->pid , current->comm

The process ID and command name for the current process.

#include <linux/kernel.h> , int printk(const char * fmt, ...);

The analogue of printf for kernel code.

#include <linux/malloc.h> , void *kmalloc(unsigned int size, int priority); , void kfree(void *obj);

Analogue of malloc and free for kernel code. Use the value of GFP_KERNEL as the priority.

#include <linux/ioport.h> , int check_region(unsigned long from, unsigned long extent); , struct resource *request_region(unsigned long from, unsigned long extent, const char *name); , void release_region(unsigned long from, unsigned long extent);

Functions used to register and release I/O ports.

int check_mem_region (unsigned long start, unsigned long extent); , struct resource *request_mem_region (unsigned long start, unsigned long extent, const char *name); , void release_mem_region (unsigned long start, unsigned long extent);

Macros used to register and release I/O memory regions.


The public kernel symbol table.


The list of ports used by installed devices.


The list of allocated memory regions.

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

O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.