Reading 12: Processes

Everyone:

Next week, we will discuss system calls involving processes and signals. We will discover the wonders of the fork bomb and examine how something like the TROLL from Homework 01 works.

TL;DR¶

The focus of this reading is to explore system calls related to processes and signals in C.

Readings¶

The readings for this week are:

Operating Systems: Three Easy Pieces
- Processes

Optional References¶

Quiz¶

This week, the reading is split into two sections: the first part is a dredd quiz, while the second part involves one C program: doit.c.

To test the C program, you will need to download the Makefile and test scripts:

$ git switch master                   # Make sure we are in master branch
$ git pull --rebase                   # Make sure we are up-to-date with GitHub

$ git checkout -b reading12           # Create reading12 branch and check it out

$ cd reading12                        # Go into reading12 folder

# Download Makefile
$ curl -sLO https://www3.nd.edu/~pbui/teaching/cse.20289.sp24/static/txt/reading12/Makefile

# Download Starter code
$ curl -sLO https://www3.nd.edu/~pbui/teaching/cse.20289.sp24/static/txt/reading12/doit.c

# Download, build, and execute tests
$ make test

Questions¶

Record the answers to the following Reading 12 Quiz questions in your reading12 branch:

Programs¶

Given the provided Makefile and doit.c, you are to do the following:

Modify Makefile to include a rule for the doit program. Be sure to use the CC and CFLAGS variables in your rule.

Once you have a working Makefile, you should be able to use the make command to run your recipes:

$ make clean                                # Remove targets
rm -f doit

$ make                                      # Build targets
gcc -Wall -g -std=gnu99 -o doit doit.c

Modify doit.c so that it uses system calls in C to implement your own version of the system function called doit.

The C standard library provides a system function that can be used to execute another command as an external process. Internally, it uses fork, exec, and wait. For this assignment, you are to implement your own version of the system function called doit inside the doit.c starter code:
```
/**
* Run specified program with the bourne shell.
* @param     command     Command to run.
* @return    Exit status of child process.
*/
int doit(const char *command);
```
This doit function forks a new process, execs the specified command, waits for the child process to complete, and then returns the exit status of the child process.

Once you have this doit function, you are to utilize it in the doit.c program such that it executes the first command-line argument specified by the user via the function you wrote as shown below:
```
$ make                # Build doit walk program
gcc -Wall -g -std=gnu99 -o doit doit.c

$ ./doit              # Usage
Usage: ./doit COMMAND

$ ./doit ls           # Run doit program with ls
doit  doit.c  Makefile  README.md  test_doit.sh

$ make clean          # Cleanup
rm -f doit
```

Submission¶

To submit you work, follow the same process outlined in Reading 01:

#--------------------------------------------------
# BE SURE TO DO THE PREPARATION STEPS ABOVE
#--------------------------------------------------

$ cd reading12                        # Go into reading12 folder

$ $EDITOR answers.json                # Edit your answers.json file

$ ../.scripts/check.py                # Check reading12 quiz
Checking reading12 quiz ...
      Q1 0.60
      Q2 0.40
   Score 1.00 / 1.00
  Status Success

$ git add answers.json                # Add answers.json to staging area
$ git commit -m "Reading 12: Quiz"    # Commit work

$ $EDITOR doit.c                      # Edit source code

$ make test                           # Build and Run tests
Checking reading12 doit ...
 doit (syscalls)                                              ... Success
 doit (usage)                                                 ... Success
 doit true (status)                                           ... Success
 doit true (valgrind)                                         ... Success
 doit false (status)                                          ... Success
 doit false (valgrind)                                        ... Success
 doit NOPE (status)                                           ... Success
 doit NOPE (valgrind)                                         ... Success
 doit ls (output)                                             ... Success
 doit ls (status)                                             ... Success
 doit ls (valgrind)                                           ... Success
 doit 'echo execution of all things' (output)                 ... Success
 doit 'echo execution of all things' (status)                 ... Success
 doit 'echo execution of all things' (valgrind)               ... Success

   Score 3.00 / 3.00
  Status Success

$ git add Makefile                    # Add Makefile to staging area
$ git add doit.c                      # Add source code to staging area
$ git commit -m "Reading 12: Code"    # Commit work

$ git push -u origin reading12        # Push branch to GitHub

Pull Request¶

Remember to create a Pull Request and assign the appropriate TA from the Reading 12 TA List.

DO NOT MERGE your own Pull Request. The TAs use open Pull Requests to keep track of which assignments to grade. Closing them yourself will cause a delay in grading and confuse the TAs.