Week 6

Intro to Kernel Modules,

Project 2

Sarah Diesburg

Florida State University

1
Kernel Logistics

Where should I put the kernel source?

 /usr/src/
 Creates /usr/src/linux-2.6.32/

Where do I issue kernel building commands

(e.g. make oldconfig, make menuconfig,
make, )?
 Inside /usr/src/linux-2.6.32/

2
Kernel Logistics

Where is the kernel image installed?

 Inside /boot/
 Starts with vmlinuz

Where does the initramfs image go?

 Inside /boot/

Where is the grub file?

 /boot/grub/menu.lst
3
Kernel Logistics

Where should I develop my new kernel

modules?
 Inside /usr/src/linux-2.6.32/<module_name>/

4
Kernel Modules

Or drivers, if you prefer

5
Kernel Module

A kernel module is a portion of kernel

functionality that can be dynamically loaded
into the operating system at run-time

Example
 USB drivers
 File system drivers
 Disk drivers
 Cryptographic libraries

6
Why not just compile everything
into the kernel?

Each machine only needs a certain number
of drivers
 For example, should not have to load every single
motherboard driver

Load only the modules you need
 Smaller system footprint

Dynamically load modules for new devices
 Camera, new printer, etc.

7
Creating a Kernel Module

Hello world example

8
Sample Kernel Module: hello.c
#include <linux/init.h>
#include <linux/module.h>
MODULE_LICENSE(Dual BSD/GPL);

static int hello_init(void)

{
printk(KERN_ALERT Hello, world!\n);
return 0;
}

static void hello_exit(void)

{
printk(KERN_ALERT Goodbye, sleepy world.\n);
}

module_init(hello_init);
module_exit(hello_exit);

9
Sample Kernel Module: hello.c
Module headers
#include <linux/init.h>
#include <linux/module.h>
MODULE_LICENSE(Dual BSD/GPL);

static int hello_init(void)

{
printk(KERN_ALERT Hello, world!\n);
return 0;
}

static void hello_exit(void)

{
printk(KERN_ALERT Goodbye, sleepy world.\n);
}

module_init(hello_init);
module_exit(hello_exit);

10
Sample Kernel Module: hello.c
License
#include <linux/init.h>
#include <linux/module.h>
declaration
MODULE_LICENSE(Dual BSD/GPL);

static int hello_init(void)

{
printk(KERN_ALERT Hello, world!\n);
return 0;
}

static void hello_exit(void)

{
printk(KERN_ALERT Goodbye, sleepy world.\n);
}

module_init(hello_init);
module_exit(hello_exit);

11
Sample Kernel Module: hello.c
#include <linux/init.h>
#include <linux/module.h>
MODULE_LICENSE(Dual BSD/GPL);
Initialization
function, runs
static int hello_init(void) when module
{ loaded
printk(KERN_ALERT Hello, world!\n);
return 0;
}

static void hello_exit(void)

{
printk(KERN_ALERT Goodbye, sleepy world.\n);
}
Tells kernel which
module_init(hello_init); function to run on
module_exit(hello_exit); load

12
Sample Kernel Module: hello.c
#include <linux/init.h>
#include <linux/module.h>
MODULE_LICENSE(Dual BSD/GPL);

static int hello_init(void)

{
printk(KERN_ALERT Hello, world!\n);
return 0;
}
Exit function, runs
static void hello_exit(void) when module exits
{
printk(KERN_ALERT Goodbye, sleepy world.\n);
}

module_init(hello_init); Tells kernel which

module_exit(hello_exit); function to run on
exit
13
Sample Kernel Module: Makefile
ifneq ($(KERNELRELEASE),)
obj-m := hello.o

else
KERNELDIR ?= \
/lib/modules/`uname -r`/build/
PWD := `pwd`
default:
$(MAKE) -C $(KERNELDIR) \
M=$(PWD) modules
endif

clean:
rm -f *.ko *.o Module* *mod*
14
Compile the Kernel Module

/usr/src/hello$> make

Creates hello.ko This is the finished kernel

module!

15
Inserting and Removing the Module

insmod insert a module

/usr/src/hello$> sudo insmod hello.ko

rmmod remove a module

/usr/src/hello$> sudo rmmod hello.ko

16
Listing Modules

lsmod lists all running modules

/usr/src/hello$>lsmod

17
Where is it printing?

Look inside /var/log/syslog

Hint to watch syslog in realtime, issue the
following command in a second terminal:

$> sudo tail f /var/log/syslog

Demo

18
Kernel Module vs User Application

All kernel modules are event-driven

 Register functions
 Wait for requests and service them
 Server/client model

No standard C library
 Why not?

No floating point support

Segmentation fault could freeze/crash your
system
 Kernel oops!

19
Kernel Functions

printk() instead of printf()

kmalloc() instead of malloc()

kfree() instead of free()

Where can I find definitions of these kernel

functions?

20
Kernel manpages

Section 9 of manpages

Must install manually for our development
kernel
$> wget http://ftp.us.debian.org/debian/pool/main/l/linux-
2.6/linux-manual-2.6.32_2.6.32-22_all.deb

$> sudo dpkg i linux-manual-2.6.32_2.6.32-22_all.deb

21
Kernel Headers

#include <linux/init.h> /* module stuff */

#include <linux/module.h> /* module stuff */

#include <asm/semaphore.h> /* locks */

#include <linux/list.h> /* linked lists */

#include <linux/string.h> /* string functions! */

Look inside linux-2.6.32/include/ for more

Google is also your friend
22
How can I explore the kernel?

Use lxr (Linux Cross Referencer):

 http://lxr.linux.no/
 Select your kernel version and enter search terms

Use grep on your kernel source

$> grep Rn xtime /usr/src/linux-
2.6.32
 R = recursive, n = display line number

23
Project 2: /Proc Kernel
Module and Elevator

24
procfs Kernel Module

procfs hello world example

 Creates a read-only procfs entry

Steps
 Create entry in module_init function
 Register reading function with procfs_read
 Delete entry in module_cleanup function

Reference
 Linux Kernel Module Programming Guide: Proc
FS

25
Procfs: Headers and Global Data
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
MODULE_LICENSE(GPL);

#define ENTRY_NAME helloworld

#define PERMS 0644
#define PARENT NULL

struct proc_dir_entry *proc_entry;

int procfile_read(char *buf, char **buf_location, off_t

offset, int buffer_length, int *eof, void *data);

26
Procfs: Creation
int hello_proc_init(void)
{
proc_entry =
create_proc_entry(ENTRY_NAME,
PERMS,PARENT);
/* check proc_entry != NULL */
proc_entry->read_proc = procfile_read;
proc_entry->mode = S_IFREG | S_IRUGO;
proc_entry->uid = 0;
proc_entry->gid = 0;
proc_entry->size = 11;

printk(/proc/%s created\n, ENTRY_NAME);

return 0;
}

27
Procfs: Reading
int procfile_read(char *buf, char **buf_location,
off_t offset, int buffer_length, int *eof, void
*data)
{
int ret;
printk(/proc/%s read called.\n, ENTRY_NAME);

/* Setting eof. We exhaust all data in one shot

*/
*eof = 1;
ret = sprintf(buf, Hello World!\n);

return ret;
}

28
Procfs: Deletion
void hello_proc_exit(void)
{
remove_proc_entry(ENTRY_NAME, NULL);
printk(Removing /proc/%s.\n, ENTRY_NAME);
}

29
Procfs: Registration

module_init(hello_proc_init);
module_exit(hello_proc_exit);

30
Testing Procfs

$> sudo insmod hello_proc.ko

$> sudo tail /var/log/syslog
$> cat /proc/helloworld
$> sudo rmmod hello_proc

31
Part 2: Kernel Time

Implement a procfs entry to display the value

of xtime
 Hint: You may not be able to directly read xtime
from your module, but maybe something else
can

32
Part 3: Elevator Scheduling

33
Part 3: Elevator Scheduling

Implement a kernel module that simulates an

elevator system

Implement system calls to interact with your
elevator

Implement a procfs entry to display
debugging information

Test using a set of user-space programs to
exercise your system

34
Why Elevator Scheduling?

Classic producer/consumer analogy

Similar to disk elevators
 File system produces read/write requests
 Disk consumes requests, optimized for disk head
position, rotational delays, etc.

35
Your Elevator

One elevator

Five floors

Four types of people
 Adults
 Children
 Delivery people
 Maintenance people

The elevator cannot exceed its maximum
weight load
36
Your Elevator

People will line up at each floor in a first-in,

first-out (FIFO) order

Each person has a starting floor and a
destination floor

The elevator must pause for a period of time
to collect people and move between floors

Once the elevator reaches a passengers
destination floor, that passenger gets out and
ceases to exist
37
Passengers will line up (FIFO)

38
Each passenger has a destination floor
in mind

I want
to go to
floor 3

39
The elevator must be started to service
passengers

Start!
40
The elevator must be started to service
passengers

Elevator
starts on the
first floor

41
Passengers enter in FIFO order

Make sure
passengers dont
exceed weight
limit!

42
Passengers enter in FIFO order

More passengers
can be queuing
up!

43
Elevator can move to any floor

Red and black

has destination
floor 3, blue has
destination floor 2

Going to floor 3!
44
Elevator can move to any floor

Must take certain

amount of time
between floors

45
Elevator can move to any floor

Must take certain

amount of time
between floors

46
Elevator can move to any floor

Must take certain

amount of time
between floors

47
Elevator can move to any floor

Must take certain

amount of time
between floors

48
Elevator can move to any floor

Must take certain

amount of time
between floors

49
Passengers disappear when they exit

50
Elevator stop in progress

Must finish
delivering
passengers
before stopping
Stop in
Progress
51
Elevator stop in progress

Must finish
delivering
passengers
before stopping
Stop in
Progress
52
Elevator stop in progress

Must finish
delivering
passengers
before stopping
Stop in
Progress
53
Elevator stop

Full stop
54
Controlling the Elevator

Implement the following system calls

int start_elevator(void)

int issue_request(int passenger_type, int

start_floor, int destination_floor)

int stop_elevator(void)

55
Elevator Scheduling Algorithms

A scheduling algorithm considers the state of

the consumers and all requests and tries to
optimize some metric
 Throughput: Maximize total requests, minimize
processing total time.
 Priorities: Requests now have deadlines.
Maximize number of requests meeting deadlines.
 Burst throughput: Maximize peak requests that
can be handled.
 Energy: Minimize consumer action
56
Elevator Test Applications

consumer.c
 Runs in infinite loop
 Issues K passenger requests once per second

producer.c
 Takes an argument telling the elevator to start or
stop

57
Kernel Time Constraints

#include <linux/delay.h>
void ssleep(unsigned int seconds);

A call to ssleep will have the program cease

to the task scheduler for seconds number of
seconds

58
Additional Design Considerations

How to move elevator?

How to protect the floor FIFO queues?

What scheduling algorithm to use?

59
Next Time

Kernel debugging techniques

How to insert system calls

Some elevator scheduling algorithms

60
What you should do?

Finish part 1 (5 system calls)

Finish part 2 (/proc module)

Try sample kernel module and proc module

Make skeleton part 3 module

Make elevator and floor queue data
structures

61