Description
Goal
The goal of this lab is to get comfortable with processes, from their creation to reaping dead processes,
and to get used to system calls related to process creation and usage. After completing this lab you will
find yourself capable of constructing multi-process systems.
Before you begin
You must use C/C++ for this lab.
A set of system calls that we will use in this lab are listed below. You should look up the appropriate man pages for details of each. You may have to use non-default man page sections for some of
these. For example, you need to use man 2 open instead of man open.
• fork: This system call is used to create a new process. After the process is created, both parent
and child processes continue execution from the point after fork(). The return value is different
in child and parent processes: zero in the child and the process-id(pid) number of the child in the
parent. In case of error, -1 is returned and new process is not created.
• wait: This call makes the calling process wait till a child process terminates and reclaims the
resources associated to it. The return value is the pid of the child process. A variant of this,
waitpid waits for a process with a given pid.
• exec: This call is used to run a new executable by replacing calling process’s code with the
executable program’s code. The code after exec() in the original process is executed only if exec
fails. If it succeeds, execution continues from the first line of the executable. Check out the several
variants of this in the man page.
• open: This call is used to open a file or create one. The return value is the file descriptor of the
opened file. This call assigns the smallest unused non-negative integer as the file descriptor.
• close: This call loses a file descriptor. The resources associated with the open file are freed.
• read: This call is used to read a specified number of bytes from a file descriptor into a buffer.
It does not necessarily read the requested number of bytes as the file may have lesser number of
bytes. The number of bytes read is returned.
• write: This call is used to write a specified number of bytes from a buffer to a file descriptor. The
number of bytes written is returned
• getpid: This returns the process ID of the calling process.
Standard file descriptors which are opened for every process:
0 : Standard input (stdin)
1 : Standard output (stdout)
2 : Standard error (stderr)
Introduction to Processes
A process is a basic unit of execution in an OS. The main job of any OS is to run processes, while
managing their life cycle from creation to termination. Processes are typically created in Unix-like
systems by forking from an existing process.
• Task 1: Baby steps to forking
Write a program simple_fork.c that forks a child and prints
Parent: The child’s process ID is : {child_PID}
and then waits for the child process to exit. The child on execution prints
1
Child: The child’s process ID is : {child_PID}.
After the child exits, the parent prints
Parent: The child has terminated.
File Descriptors and Fork
A file descriptor (a.k.a fd) is an abstract indicator (handle) used to access a file or other input/output
resources, such as a pipe, network socket, disk, terminal etc. A file descriptor is a non-negative integer,
generally represented in the C programming language as the type integer . When a fork operation occurs,
the file descriptor table is copied for the child process, which allows the child process access to the files
opened by the parent process. Note: Only file handles get copied, the offset within a file for read and
write are independently manipulated.
• Task 2: Writing to a file without opening it
Write a program smart_file_write.c that opens a file (output.txt) and gets a file descriptor,
writes “Hi I am the Parent” to the file, and then forks a child process.
The child should then be able to write to the file without re-opening the file using the copied file
descriptor. The child should write “Hi I am the Child!”.
What do you expect the final contents in the file?
Fork and Exec
The exec system call is used to run an executable in a process by overwriting the content of the existing
process with the content of the executable. Typically, in Unix systems, as fork is the primary way of
creating processes, a fork+exec combination is used to spawn new programs. In this technique, to run
an executable, the parent process forks a new process and the child process uses exec to load and run
the executable.
Before we use exec, let’s learn how to use some I/O system calls.
• Task 3: Writing your own “head” program
Write a program my_head.c which takes two arguments, an integer n and a file name. It should
read the given file and print the first n characters in the file to standard output. For this, you
should not use any library functions like printf, scanf cin for I/O. Use standard system calls
read() and write().
The integer given as argument to this is available as a character array in the program. You can
use the atoi() method to convert it to integer.
Assume that n is a positive integer and is less than the number of characters in the file.
Sample run: ./my_head 10 sample.txt
Note: Compile my_head.c and name the executable as my_head. You need to use it in the following
tasks.
• Task 4: fork+exec
Write a program multi_head.c which takes a list of file names as arguments. It should print
the first 10 characters of each of the files in the given order using the my_head program written
above. For each given file, you can fork a new process and exec the my_head program with relevant
arguments. The parent waits till child exits and then continues to the next file.
Sample run: ./multi_head abc.txt def.txt ghi.txt jkl.txt
• Task 5: Output redirection
Write a program write_head.c which takes the arguments similar to my_head.c in Task 3 and
one additional output file name. It should use the my_head executable from Task 3 and print the
first n characters to the given output file in the argument. This can be done by forking a new process, closing child’s standard output, opening the output file and executing my_head with required
arguments. Make sure you give atleast read permissions when you try to create a non-existent file
using open().
Whenever a new file is opened, it is allocated the smallest fd which is free. In this case, as the file
descriptor of stdout is closed, the output file is given stdout’s fd when it is opened.
Sample run: ./write_head 10 input.txt output.txt
2
Signal Handling
A signal is an asynchronous notification sent to a process in order to notify it of an event that occurred.
When a signal is sent, the operating system interrupts the target process’ normal flow of execution to
deliver the signal. A signal is mechanism to inject explicit non-deterministic software interrupts targeted
for a process. For example, pressing Ctrl+C during the execution of any process sends a signal called
the SIGNINT signal to the process.
Also, for each process, a custom ‘handler’ of a signal can be used. The custom handler can be then set
as the signal handler by using the signal system call.
• Task 6: Implementing a Safe Version of Ctrl+C
Write a program safe_control_c.c. This program should override the current SIGINT signal handler to ask if the user really wanted to send the SIGINT signal to the running process every time
the user presses Ctrl+C. The handler should then ask for either yes or no and then exit or not
accordingly.
The program should go to an infinite loop and in between you should press Ctrl+C to check the
correctness of the new signal handler.
Submission Guidelines
• All submissions via moodle. Name your submissions as: .tar.gz
• The tar should contain the following files in the following directory structure:
/
|__task1/
|____simple_fork.c
|__task2/
|____smart_file_write.c
|__task3/
|____my_head.c
|__task4/
|____multi_head.c
|__task5/
|____write_head.c
|__task6/
|____safe_control_c.c
• Deadline: 29th July 11.59 A.M.
Expected time for completion of lab: 3 hours
3