Homework 3: Adding Signals to xv6

Background on UNIX signals

(Some parts of this section have been summarized from the Linux signal(7) man page)

A signal is an event which can be sent by one process to another process. Each signal has a current disposition, which determines how the process behaves when it is delivered the signal.

The following default actions are available:

• Term - terminate the process
• Ign - ignore the signal
• Core - terminate the process and create a core dump file
• Stop - stop the process
• Cont - continue the process if it is currently stopped

There are a number of standard signals that are supported by most UNIX-like OSs, for example SIGHUP, SIGINT, SIGQUIT, SIGKILL, SIGSEGV, SIGPIPE, SIGALRM, SIGTERM, SIGUSR1, and SIGUSR2. You can take a look at the signals(7) man page for more details on these signals. There are others listed on the man page as well.

A process can change the action of a signal using the signal() system call. Using this system call, a process can elect one of the following behaviors to occur on delivery of the signal: perform the default action; ignore the signal; or catch the signal with a signal handler, a programmer-defined function that is automatically invoked when the signal is delivered.

Problem statement

Extend the xv6 kernel to add support for process signals. For this homework assignment, you must modify the xv6 kernel to allow for "user-level signals" to be posted to processes. Additionally, you must implement three new syscalls. These syscalls (as further described below) will add support for a process to (i) register a custom handler for each signal, (ii) issue a signal to itself, its parent, or any of its child processes, and (iii) get the process id of its parent process. Finally, as part of this assignment, you will be required to create an xv6 program that both establishes a custom signal handler in a parent process and issues a signal from a child to its parent that triggers the parent's handler.

Here are the steps you will need to complete for this assignment:

1. Add support for 16 signals (numbered 0 through 15). Each process should be able to register its own signal handler for each of these 16 signals.

2. Add a new system call: int getppid(void). The getppid() system call takes no arguments. When called it returns the process id of the calling process' parent.

3. Add a new system call: int signal(int signum, sighandler_t handler). The signal() call takes the signal number (signum) and a pointer to the signal handler (handler) as arguments. It returns the previous value of the signal handler on success or -1 on failure. The parameter "handler" is of type sighandler_t, which you will have to define as typedef void (sighandler_t)(void) at appropriate places in the source code. When called by a process, the signal() system call should register "handler" as the signal handler for signal "signum" for that process.

4. Add a new system call: int kill_signal(int pid, int signum). The kill_signal() call should take a process id and a signal number as arguments. It should return 0 on success or -1 on failure. A process may access its own process id via a call to getpid(). It may access its parent's process id via a call to getppic() (see #2 above). Also, fork() returns the process id of child processes to the parent (as the return value). When called by a process, the kill_signal() system call should post a "signum" signal to process "pid".

5. Create a user-level test program called kill_test that sets a custom signal handler for a signal to print output to the screen. Then it should fork a child process and wait. The child process signal its parent and then exit. The parent should process the signal and then exit afterwards. The way to do this is to have the parent's custom signal handler also set a flag that breaks its waiting condition so that it can only exit after receiving the signal from its child.

XV6 SOURCE CODE: The source code for the xv6 kernel can be downloaded from here.

Hints

This section is a list of hints for some of the more difficult portions of the assignment. This does not cover every aspect of the code changes that must be made, though.

• The process structure should be extended (in proc.h) to include an array of pointers to store pointers to customer signal handler functions. This should be large enough for 16 signals (0 through 15) and initialized to -1 (the default action) for each signal in (proc.c) whenever a new process is created. The default action for a signal should be SIGKILL, which already exists in the xv6 kernel.
• To add a new system call, you must extend the syscall vector, in syscall.c, and add a new syscall number in syscall.h. Your code for the syscalls should be placed in sysproc.c and proc.c. You should look in syscall.c to see how arguments are passed on the stack, between user space and the kernel. Finally, you must create a stub for the new syscall in usys.S similar to those found in usys.S.
• To add support for getppid() in xv6, you must extend the process structure to include an element to store its parent id. Then when a process is created, you set the element to its parent's id. This is what should be returned by the getppid() call.
• To register a custom signal handler for a process in the kernel, you must first read the arguments off of the calling process' stack to get the "signum" and "handler" parameters. Then you will need to set the handler in the calling process' signal vector for the "signum" signal. Finally, you should return the return value back to the calling process.
• To send a process a signal you must first read the arguments off of the calling process' stack to get the "pid" and "signum" parameters. Then you will need to find the target process (PID) from the process table. If the signal handler value for "signum" in PID's signal handler array is set to -1 terminate the process (this is the current default action in the code). If there is a custom signal handler set, you must place the address pointed to by PID's eip at the top of PID's user stack (set PID's: esp - 4 = eip). Then decrement PID's esp by 4 (set PID's: esp = esp - 4) and change PID's eip to point to the address of PID's custom signal handler for "signum" (set PID's: eip = custom signal handler address). In this way, when the PID process is scheduled next, it will return to execute the custom signal handler first. Returning from the custom signal handler, the process will continue with the instruction where the trap/interrupt occured. A process' eip and esp can be found in it's trap frame.
• To create a new user space program in xv6, you first create the program file (foo.c or whatever you wish to call it) with the program source code. You also need to add a line in the Makefile so that your user space program is compiled with the rest (see lines starting right after "UPROGS=\" in the Makefile). You can use kill.c as a template for your user space program. Make sure all programs exit by explicit calls to the exit() syscall, otherwise you will get an error on program exit.
• Look at: kill.c, syscall.c::argint(), syscall.c::fetchint(), and sysproc.c::sys_kill(), as they are quite relevant to the assignment. They are not the only relevant files/functions though.

Submission Instructions

• Your Name
• Parts of the project you have done in the following format:
  Part 1: Done
  Part 2: Not Done
  and so on.
• Describe the changes you have made to implement the syscalls and why they were necessary. Please keep the explanation short and meaningful.

• Submit a tarfile of the xv6 code with your modifications.

Email the tar file to your TA prior to the deadline. The subject of the email should read "[CS416-S08 HW#3]". Please ensure that you submit the files before the deadline. To be safe, hand it in as early as possible. If you are close to the due date/time and are not completed, you can submit one version with whatever you have done earlier, and then submit a later version by sending a new tarfile before the deadline. We will consider the submitted version to be the last version received, prior to the deadline.