Course OS - Laboratory Session on Linux Kernel

Course on Operating Systems - Project of Fall 2008

Starting on November, 27^th, 2008

Ludovic Apvrille

Information on the project

Individual project. Similar approaches or source code are not allowed. You may use source code and information provided on the Internet (or else), but if you do so, do mention it in your report.
Graded (35% of you final grade)
Due for the 20th of January, midnight.
You must make a report (in pdf). This report should explain me your work: your overall approach, your implementation work, and answers to various questions provided below. Do mention difficulties you have encountered, and how you have solved them. I do not expect a long report (maximum of 5 pages), I just expect relevant information to be provided. Provide all references you have used to perform your project (websites, books, etc.).
Your backup directory located on /archives/kernel_project/<mylogin>/ should contain the 20th of January the last version of your work i.e. the last virtual machine, and your report in pdf format. This directory will be closed on that date, and your grade will be provided according to it (and according to your report).

If you have problems to make this project, you may come to my office to get help and advices. Also, do not start working on your project the 19th of January ;-) You should have completed a subsequent part - if not all parts - of the project before the end-of-year's vacations.

Information about the computer system

The project should be realized using a "vmwared" Linux. The starting vmware machine is the one provided in /home/Admin_Data/Tp_Apvrille/TP_Kernel.tar. Information on the use of this machine is provided in lab session on Linux kernel. This lab session also contains information on the system (edition, compilation, and various functions that may be useful).

We provide a backuped disk space for your project. Thus, the first time you use your machine, do:

Copy and extract the virtual machines information into a work directory:
$ cd /home/Local_Data
$ tar xvf /packages/administration/TP_Kernel.apvrille.tar

Then, you may start the virtual machine. When you have finished working on it, do as follows:

$ cd TP_Kernel
$ vmplayer TP_Kernel.vmx

Stop the system, in the virtual machine:

$halt

Wait for the Linux to be halted, and then, close vmware. Come back to the main Linux, and do:

$ cd /home/Local_Data
$ tar -cvf <mylogin_vm>.tar TP_Kernel/

And save it in you project directory:
$cp <mylogin_vm>.tar /archives/kernel_project/<mylogin>/

Next time you want to access it, do:
$ cd /home/Local_Data
$cp /archives/kernel_project/<mylogin>/<mylogin_vm>.tar .

You may need to use Linux manual pages, section 9 (kernel). I recommend using:

Work to do

Basically, your work is to implement a new function offered by Linux to user applications.

At first, you have to finish the lab session on kernel programming i.e. your final virtual machine should contain the implementation of exercises 1 to 3. You don't have to provide information on theses system calls in your report.

In this project, the objective is to design a system call that can handle a delayed signals between processes. Indeed, usually, when a process sends a signal to another process - using the kill() system call - , that signal is delivered immediatly by the operating system to the destination process. On the contrary, with your new system call - called mykill() - the signal shall be delivered to the destination process only after a given duration provided as argument to the system call.

1) At first, understand how the usual kill() system call works

To do so, you may use the lecture notes on "thread", and use related manual pages i.e. :

$ man -s2 signal

$ man -s2 kill

Then, do two different programs, and test them under linux

The first program shall start a process P1. P1 waits for SIGUSR1 signal. When it gets that signal, it prints a specific message.
The second program - called P2 - shall send ten times SIGUSR1 signals to P1.

2) We now wish to add a delay parameter to signals

Propose an architecture - based on a new system call - to handle such signals. Do explain that architecture in your report

Implement your solution, and more particularly a new system call. That system call shall have the following interface:

int mykill(pid_t pid, int sig, int delay);

The delay shall be given in milliseconds.

Test your new system. Reuse P1. P2 shall be as follows:

A test program should look like this (with pid being the process id of P1):

…

int pid;

if (mykill(pid, SIGUSR1, 10000) <0) {exit(-1);}
if (mykill(pid, SIGUSR1, 1000) <0) {exit(-1);}
if (mykill(pid, SIGUSR1, 5000) <0) {exit(-1);}

...

In that test program, we specify to the operating system that we wish three SIGUSR1 to be delivered to P1: one after 1 second, one after 5 seconds, at the last one after 10 seconds.

3) Is your system call re-entrant i.e. can it be called at the same time by several user processes? If no, what shall be done for making it re-entrant? Do justify your answer in the report [Here, I do not ask you to program a re-entrant system call if the one you have programmed is not].

4) Now, we wish to implement another system call that allows the cancellation of a signal

The interface of the system call shall be the following one:

int mycancelkill(pid_t pid, int sig);

This calls means that all signals -of number sig - that have not yet been sent to process pid shall be cancelled.

Propose an implementation for that second system call, and provide a test program.