Transcript ppt

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?



Where does the initramfs image go?


Inside /boot/
Starts with vmlinuz…
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


Load only the modules you need


For example, should not have to load every single
motherboard driver
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
#include <linux/init.h>
#include <linux/module.h>
MODULE_LICENSE(“Dual BSD/GPL”);
License
declaration
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”);
static int hello_init(void)
{
printk(KERN_ALERT “Hello, world!\n”);
return 0;
}
Initialization
function, runs
when module
loaded
static void hello_exit(void)
{
printk(KERN_ALERT “Goodbye, sleepy world.\n”);
}
module_init(hello_init);
module_exit(hello_exit);
Tells kernel which
function to run on
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
when module exits
static void hello_exit(void)
{
printk(KERN_ALERT “Goodbye, sleepy world.\n”);
}
module_init(hello_init);
module_exit(hello_exit);
Tells kernel which
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




No standard C library



Register functions
Wait for requests and service them
Server/client model
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/linux2.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/linux2.6.32

R = recursive, n = display line number
23
Project 2: /Proc Kernel
Module and Elevator
24
procfs Kernel Module

procfs “hello world” example


Steps




Creates a read-only procfs entry
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 passenger’s
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 don’t
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