Module I-7410 Advanced Linux Kernel Data Structures

Bern University of Applied Sciences 

Engineering and Information Technology 

Module I-7410 

Advanced Linux 

By Franz Meyer 

Version 1.4 

March 2012 

Kernel Data 

Structures


School of Information Technology TI 

Module: Advanced Linux 

FS-2012 

Introduction to Linux Kernel Lists (1) 

Lists are very frequently used in operating system kernels to link data 

structures that represent all existing instances of various kernel 

objects such as 

Process descriptor objects 

File descriptor objects 

Memory regions 

For processes, for example, there are at least linked lists 

To link the process descriptors of all processes in the system 

To link the process descriptors of all runnable processes (run lists aka ready 

queue). 

Many lists in the Linux kernel are doubly linked using a header node 

List traversal in both directions 

Insertions at both ends: head (LIFO list), tail (FIFO list) 

Deletions are easy 

Introduction to Linux Kernel Data Structures 

V1.4 © 2012 by franz.meyer@bfh.ch Slide-2





FS-2012 

Introduction to Linux Kernel Lists (2) 

Basic Data Structure (defined in ): 

struct list_head { 

struct list_head *prev, *next; 

} 

The structure list_head is used throughout the Linux kernel for 

both list headers and list nodes in a kernel list. 

The structure list_head is often embedded in a larger structure 

(container). 

The pointers next and prev point to list_head structures not to 

the containers of the list_head structures. 





Kernel List Header 


FS-2012 

List header 

to define and to initialize a list header use the macros LIST_HEAD(list_name) 

and LIST_HEAD_INIT(name) as well as the inline function INIT_LIST_HEAD() 

#define LIST_HEAD_INIT(name) { &(name), &(name) } 

#define LIST_HEAD(name) \ 

struct list_head name = LIST_HEAD_INIT(name) 

static inline void 

INIT_LIST_HEAD(struct list_head *list) { 

list>next = list; 

list>prev = list; 

} 

List header 

struct list_head 

next 

prev 





Kernel List 


FS-2012 

Kernel lists are 

Often circular 

List items include the list_head structure to establish a node in the list. 

The pointers next and prev in the list_head structure point to the other 

struct list_head structure rather than to the base address of the whole 

data structure 

struct S 

struct S 

struct 

list_head 

next 

prev 

List tail (last node) 

struct 

list_head 

next 

prev 

List header 

struct 

list_head 

next 

prev 

List head (first node) 

more 

list 

nodes 





Kernel List Macros (1) 


FS-2012 

The macros come from file: usr/include/linux/list.h 

Macro Name Description 

list_add(n,p) Insert a new item pointed to by n right after the item 

specified by p. If p points to the list header, you insert 

the new item at the list head (beginning). 

list_add_tail(n,p) Insert a new item pointed to by n right before 

the item specified by p. If p points to the list header, 

you insert the new item at the list tail (end). 

del(p) Delete an item pointed to by p. Does not free memory 

belonging to node p. 

list_empty(p) Check if a list starting at the header given by pointer p 

is empty. 







FS-2012 

Macro Name Description 

list_entry(p,t,m) Return the address of the data structure of type t 

(the container). The list_head field in t has the 

name m and the address p. 

__list_for_each(p,h) Iterate over the list specified by the address 

of its header h. The iterator p is a pointer to the 

current list_head field. No pre-fetch. 

list_for_each(p,h) Iterator with pre-fetch of the the next element ptr. 

list_for_each_entry(p,h,m) Similar to list_for_each 

but the macro returns a pointer to the data 

structure that contains the list_head sub- 

structure in field m. Note: for kernel use only. 

list_for_each_entry_safe(p,p1,h,m) Safe iterator. Similar 

to list_for_each_entry but p1 specifies 

another pointer p as temporary storage 







FS-2012 

Example: Build a LIFO list (stack) and a FIFO list (queue) 

Data Structures and variables 

struct list_el { /* a list element */ 

int id; /* a field */ 

struct list_head link; /* the link field */ 

} 

LIST_HEAD(hdr_lifo); /*define LIFO list header*/ 

LIST_HEAD(hdr_fifo); /*define FIFO list header*/ 

/* define some list elements */ 

struct list_el lifo1, lifo2, fifo1, fifo2; 







FS-2012 

Example, cont: Build a LIFO list (stack) and a FIFO list (queue) 

Use macros to build a LIFO and a FIFO list 

/* the LIFO list (stack) */ 

list_add(&lifo1.link, &hdr_lifo); 

list_add(&lifo2.link, &hdr_lifo); 

/* the FIFO list (queue) */ 

list_add_tail(&fifo1.link, &hdr_fifo); 

list_add_tail(&fifo2.link, &hdr_fifo); 







FS-2012 

Example, cont: Get the address of the first element in the FIFO list 

struct list_el *ple; 

ple = list_entry(&hdr_fifo.next,struct list_el,link); 

Example, cont: Use simple iterator macro to count the number of 

elements in the FIFO list. You need not access fields in the elements. 

struct list_head *pln; /* iterator */ 

int nItems = 0; /* number of elements */ 

/*REMARK: Use this iterator for very short lists*/ 

__list_for_each(pln, &hdr_fifo) { 

nItems++; 

} 







FS-2012 

Example, cont: Iterate safeley through the elements of the LIFO list 

and print the id field of each list element. 

struct list_el *ple, *ple1; 

list_for_each_entry_safe(ple,ple1,&hdr_lifo,link) { 

printf(“ple:%p id:%i\n”, ple, ple>id); 

} 


Berne University of Applied Sciences 

School of Information Technology HTI 

Course: Advanced Linux 

FS-2012 

Example: Module Representation in the Kernel (1) 

A module is represented by a struct module 

struct module { 

enum module_state state; /*LIVE,COMING,GOING*/ 

struct list_head list; /*member list,head:modules*/ 

char name[MODULE_NAME_LEN]; /* unique module name */ 

... 

const struct kernel_symbol *syms; /*exported symbols*/ 

unsigned int num_syms; 

const unsigned long *crcs; /*check sums on names*/ 

/* GPLonly exported symbols. */ 

const struct kernel_symbol *gpl_syms; 

unsigned int num_gpl_syms; 

const unsigned long *gpl_crcs; 

unsigned int num_exentries; /* Exception table */ 

const struct exception_table_entry *extable; 

Introduction to Modules 


} 





FS-2012 


struct module, cont 

int (*init)(void); /*Startup function*/ 

void *module_init; /*If nonNULL,returned after init*/ 

void *module_core; /*actual code + data*/ 

unsigned long init_size, core_size; 

unsigned long init_text_size, core_text_size; 

struct mod_arch_specific arch; 

int unsafe; /* Am I unsafe to unload? */ 

int license_gplok; /* Am I GPLcompatible */ 

... 

struct list_head source_list; /*what depends on me*/ 

struct list_head target_list; /*what do I depend on*/ 

struct task_struct *waiter; /* Who is waiting for us*/ 

void (*exit)(void); /*Destruction function. */ 

char *args; /*command line args */ 





FS-2012 


Kernel Modules List 

struct list_head { 

struct list_head *next, *prev; 

} 

struct 

list_head 

list_head 

modules 


struct module 

state 

list_head list 

char name[] 

other 

fields 

struct module 

state 

list_head list 

char name[] 

other 

fields 





FS-2012 


Representation of Dependencies 

struct module_use { 

struct list_head source_list, target_list; 

struct module *source, *target; 

} 

Example: Module msdos uses module vfat 

struct 

module 

struct 

module_use 


name=msdos 

list_head source_list 

list_head target_list 



struct module *source 

struct module *target 

name=vfat 







FS-2012 


Code that produces module dependency: a uses b 

Module a is the source and module b is the target 

int add_module_usage(struct module *a, *b) 

{ 

struct module_use *use; 

use = kmalloc(sizeof(struct module_use),GFP_ATOMIC); 

if (!use) 

return ENOMEM; 

use>source = a; use>target = b; 

list_add(&use>source_list, &b>source_list); 

list_add(&use>target_list, &a>target_list); 

return 0; 

} 







FS-2012 

Kernel Queue – Exercise (1) 

Problem 1 

Kernel list exist in the kernel and are hidden to user space programs. 

To experiment with kernel lists it is suggested to write a kernel loadable 

module. 

Write a simple module in file klist.c that defines a data structure 

struct S with some simple fields like a numeric id, and with three list 

node fields (of type struct list_head). Define a few instances of 

the data structure S. For simplicity define an array of structures S to 

avoid dynamic memory allocation operations. Now link all instances of 

S by using the first list node field. Let this queue begin at a header 

variable (of type list_head) called head_all. 

Use the second and the third list node field to establish sub-queues 

formed by a sub-set of existing items S. For example, (1) link all nodes 

with an even node-id in ascending order starting at a header field called 

head_even, and (2) link all nodes with an odd node-id in descending 

order starting at a header field called head_odd. 






FS-2012 

Kernel Lists – Exercise (2) 

Problem 1, cont. 

Use the macros introduced before to iterate over the lists described 

above in two rounds: 

(1) Iterate and count the number of elements in the list. To do that you 

need not access any fields of the structure S. What is the iterator? 

(2) Iterate and print various fields of the data structure S. What is the 

iterator? 

(3) Iterate through the substructures formed by nodes with even and 

odd node id. 

Write a make file to generate the .ko file (kernel object). The command 

$ make modules will generate the kernel object, and the command 

$ make modules_install will install the module in the directory 

/lib/modules//extra. 

Use the /sbin/modprobe or the /sbin/insmod utility to load the 

module. The utility rmmod or modprobe r unloads the module. 





Kernel Lists – Exercise (3) 


FS-2012 

Problem 2 

Write a kernel module called list_modules.c that displays the kernel module 

list and possible dependencies, similar to the lsmod command. For each module 

in the list check to see if there are dependencies. If so, display all dependent 

modules. Recall that dependencies are associated with two lists: (1) list of used 

modules, and (2) list of modules that uses this module. Compare your output 

with the result of the lsmod command or of the cat /proc/modules command. 

Notes 

- Be careful with your list algorithm. If not correctly programmed your machine 

may hang. 

- The modules code is in file /usr/src/linux/kernel/module.c. Here, the 

module list variable (modules) is defined as static, which means that the 

variable is not visible in other kernel modules. To fix that write a global function 

void * get_modules() { return &modules; } 

EXPORT_SYMBOL(get_modules); 

Then recompile the kernel by: make uImage and install its image. 

- When you are accessing the module list, lock it first, and unlock it when you are 

done. Use the exported lock variable module_mutex for that purpose. 

- To test your program load the dependent modules hellomain and hellofunc 

of a previous exercise.

Module I-7410 Advanced Linux Kernel Data Structures

Create successful ePaper yourself

Delete template?

Save as template?