Upload
elaine-kelly
View
217
Download
0
Embed Size (px)
Citation preview
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 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
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#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
Module headers
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);
11
License declaration
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);
12
Initialization function, runs when module
loaded
Tells kernel which function to
run on load
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);
13
Exit function, runs when module exits
Tells kernel which function to
run on exit
Sample Kernel Module: Makefileifneq ($(KERNELRELEASE),) obj-m := hello.o
else KERNELDIR ?= \ /lib/modules/`uname -r`/build/ PWD := `pwd`default: $(MAKE) -C $(KERNELDIR) \ M=$(PWD) modulesendif
clean: rm -f *.ko *.o Module* *mod*
14
/usr/src/hello$> make
Creates hello.ko – This is the finished kernel module!
Compile the 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
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
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 F
S
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
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 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
Elevator can move to any floor
44
Going to floor 3!
Red and black has destination floor 3, blue has
destination floor 2
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