Shell Edit on Github

Fork Bombs

To prevent you from fork bombing your own VM, we recommend looking into ulimit. This will allow you to set a limit for how many times you can fork. It is a good idea to add this to your ~/.bashrc file (feel free to look up online how to do so), so that it is run every time you log in to your VM.

Since a learning objective of this assignment is to use the fork-exec-wait pattern, if you use system, you will automatically fail this MP.

Formatting

• Since this MP requires your programs to print a variety of things like error messages, we have provided you with our own highly customized formatting library. You should not be printing out to stdout and stderr at all; instead, all output and errors should be printed using the functions provided in format.c and format.h. In format.h you can find documentation about what each function does, and you should use them whenever appropriate.

Note: don’t worry if you don’t use all of the functions in format.c, but you should use them whenever their documented purpose matches the situation.

• Do not worry about irregular spacing in command inputs (i.e. extra whitespace before and after each token). This is considered undefined behavior and will not be tested.

Starting Your Shell

The shell should run in a loop like this executing multiple commands:

• Print a command prompt
• Read the command from standard input
• Print the PID of the process executing the command (with the exception of built-in commands), and run the command

The shell must support the following two optional arguments, however, the order of the arguments does not matter, and should not affect the functionality of your shell.

History

-h takes the filename of the history file. The shell should load in the history file as its history. If the file does not exist, you should treat it as an empty file and write all the commands that were executed in the terminal to the output file on exit. Upon exit, the exact same history file should be updated, even if the shell is in a different working directory than where it started.

./shell -h <filename>

The format of the history file stored should be exactly the same as a script file. See below for details.

If the the -h flag is not specified, the shell will still keep a history of commands run, but will not read/write from/to a history file. Just think of it like private browsing mode for your terminal.

File

-f takes the name of the file to be executed by the shell. The shell will both print and run the commands in the file in sequential order until the end of the file. See the following example file and execution:

commands.txt:

cd cs241
echo Hey!

./shell -f commands.txt
(pid=1234)/home/user$ cd cs241
(pid=1234)/home/user/cs241$ echo Hey!
Command executed by pid=1235
Hey!

You have been given a sample script file test_file.txt. Your history files and script files should be formatted in the same manner.

If the user supplies an incorrect number of arguments, or the script file cannot be found, your shell should print the appropriate error from format.h and exit.

The getopt function may come in handy.

Prompting

When prompting for a command, the shell will print a prompt in the following format (from format.h):

(pid=<pid>)<path>$

<pid> is the current process ID, and <path> is a path to the current working directory. Note the lack of a newline at the end of this prompt.

Reading in the Command

The shell will read in a command from stdin (or a file if -f was specified).

Running the Command

The shell should run the command that was read in previously.

If the command is run by a new process, the PID of the process should be printed like this:

Command executed by pid=<pid>

This should be printed by the process that will run the command, before any of the output of the command is printed (prints to be used are in format.c/h).

Keeping History

Your shell should store the command that the user entered, so the user can repeat it later if they wish. Every command should be stored unless otherwise noted. A vector may be useful here.

Catching Ctrl+C

Usually when we do Ctrl+C, the current running program will exit. However, we want the shell itself to ignore the Ctrl+C signal (SIGINT). Instead, it should check if there is a currently running foreground process, and if so, it should kill that foreground process using SIGINT (the kill() function might come in handy, here and elsewhere).

When a signal is sent to process, it is sent to all processes in its process group. In this assignment, the shell process is the leader of a process group consisting of all processes that are fork‘d from it.

Since we want this signal sent to the foreground process, but not to any backgrounded processes, you will want to use setpgid to assign each background process to its own process group after forking:

cd <path>

Changes the current working directory of the shell to <path>. Paths not starting with / should be followed relative to the current directory. If the directory does not exist, then print the appropriate error. Unlike your regular shell, the <path> argument is mandatory here. A missing path should be treated as a nonexistent directory.

(pid=1234)/home/user$ cd code
(pid=1234)/home/user/code$ cd imaginary_directory
imaginary_directory: No such file or directory
(pid=1234)/home/user/code$

There is a system call that may be helpful here.

!history

Prints out each command in the history, in order.

(pid=1234)/home/user$ !history
0    ls -l
1    pwd
2    ps
(pid=1234)/home/user$

This command is not stored in history.

#<n>

Prints and executes the nth command in history (in chronological order, from earliest to most recent), where n is a non-negative integer. Other values of n will not be tested. The command run should be stored in the history. If n is not a valid index, then print the appropriate error and do not store anything in the history.

The following example assumes a fresh history:

(pid=1234)/home/user$ echo Echo This!
Command executed by pid=1235
Echo This!
(pid=1234)/home/user$ echo Another echo
Command executed by pid=1236
Another echo
(pid=1234)/home/user$ !history
0    echo Echo This!
1    echo Another echo
(pid=1234)/home/user$ #1
echo Another echo
Command executed by pid=1237
Another echo
(pid=1234)/home/user$ #9001
Invalid Index
(pid=1234)/home/user$ !history
0    echo Echo This!
1    echo Another echo
2    echo Another echo
(pid=1234)/home/user$

Print out the command before executing if there is a match.

The #<n> command itself is not stored in history, but the command being executed (if any) is.

!<prefix>

Prints and executes the last command that has the specified prefix. If no match is found, print the appropriate error and do not store anything in the history. The prefix may be empty. The following example assumes a fresh history:

(pid=1234)/home/user$ echo Echo This!
Command executed by pid=1235
Echo This!
(pid=1234)/home/user$ echo Another echo
Command executed by pid=1236
Another echo
(pid=1234)/home/user$ !e
echo Another echo
Command executed by pid=1237
Another echo
(pid=1234)/home/user$ !echo E
echo Echo This!
Command executed by pid=1238
Echo This!
(pid=1234)/home/user$ !d
No Match
(pid=1234)/home/user$ !
echo Echo This!
Command executed by pid=1239
Echo This!
(pid=1234)/home/user$ !history
0       echo Echo This!
1       echo Another echo
2       echo Another echo
3       echo Echo This!
4       echo Echo This!
(pid=1234)/home/user$

Print out the command before executing if there is a match.

The !<prefix> command itself is not stored in history, but the command being executed (if any) is.

exit

The shell will exit once it receives the exit command or once it receives an EOF at the beginning of the line. An EOF is sent by typing Ctrl-D from your terminal. It is also sent automatically from a script file (as used with the -f flag) once the end of the file is reached. This should cause your shell to exit with exit status 0.

If there are currently stopped or running background processes when your shell receives exit or Control-D (EOF), you should kill and cleanup each of those children before your shell exits. You do not need to worry about SIGTERM.

If you don’t handle EOF to exit, you will fail many of our test cases!

Do not store exit in history!

Invalid Built-in Commands

You should be printing appropriate errors in cases where built-in commands fail; for example, if the user tries to cd into a nonexistent directory.

(pid=1234)/home/user$ cd /imaginary_directory
/imaginary_directory: No such file or directory
(pid=1234)/home/user$

AND

&& is the AND operator.

Input: x && y

• The shell first runs x, then checks the exit status.
• If x exited successfully (status = 0), run y.
• If x did not exit successfully (status ≠ 0), do not run y. This is also known as short-circuiting.

This mimics short-circuiting AND in boolean algebra: if x is false, we know the result will be false without having to run y.

This is often used to run multiple commands in a sequence and stop early if one fails. For example, make && ./shell will run your shell only if make succeeds.

OR

|| is the OR operator.

Input: x || y

• The shell first runs x, then checks the exit status.
• If x exited successfully, the shell does not run y. This is short-circuiting.
• If x did not exit successfully, run y.

Boolean algebra: if x is true, we can return true right away without having to run y.

This is often used to recover after errors. For example, make || echo 'Make failed!' will run echo only if make does not succeed.

Separator

; is the command separator.

Input: x; y

• The shell first runs x.
• The shell then runs y.

The two commands are run regardless of whether the first one succeeds.

ps

Like our good old ps, your shell should print out information about all currently executing processes. You should include the shell and its immediate children, but don’t worry about grandchildren or other processes. Make sure you use print_process_info_header() and print_process_info() (and maybe some other helper functions)!

Note: while ps is normally a separate binary, it is a built-in command for your shell. (This is not “execing ps”, this is you implementing it in the code. Thus you may have to keep track of some information for each process.)

Your version of the ps should print the following information for each process:

• PID: The pid of the process
• NLWP: The number of threads currently being used in the process
• VSZ: The program size (virtual memory size) of the process, in kilobytes
• STAT: The state of the process
• START: The start time of the process. You will want to add the boot time of the computer, and start time of the process to calculate this. Make sure you are careful while converting from various formats - the man pages for procfs have helpful tips.
• TIME: The amount of cpu time that the process has been executed for. This includes time the process has been scheduled in user mode (utime) and kernel mode (stime).
• COMMAND: The command that executed the process

Some things to keep in mind:

• The order in which you print the processes does not matter.
• The ‘command’ for print_process_info should be the full command you executed. The & for background processes is optional. For the main shell process only, you do not need to include the command-line flags.
• You may not exec the ps binary to complete this part of the assignment.

Example output of this command:

(pid=25497)/home/user$ ps
PID     NLWP    VSZ     STAT    START   TIME    COMMAND
25498   1       7328    R       14:03   1:35    dd if=/dev/zero of=/dev/null &
25501   1       7288    S       14:04   0:00    sleep 1000 &
25497   1       7484    R       14:03   0:00    ./shell

pfd <pid>

To impress your boss even futher, you’ve decided that you’re going to implement a new command that doesn’t exist in the regular shell.

The pfd (print file descriptor) command that you have come up with will print the following information about each of the open file descriptors of a process:

• The file descriptor number used in the process
• The position of the file descriptor for the process
• The real path of the file

Note: This includes stdin, stdout, and stderr.

Hint: You may find the /proc filesystem to be useful here as well.

Example output of this command:

(pid=29709)/home/user$ pfd 29719
FD_NO   POS     REALPATH
0       0       /dev/pts/2
1       0       /dev/pts/2
2       0       /dev/pts/2
3       4096    /home/user/doc.txt

kill <pid>

The ever-useful panic button. Send SIGTERM to the specified process.

Use the appropriate prints from format.h for:

• Successfully sending SIGTERM to process
• No process with pid exists
• kill was ran without a pid

stop <pid>

This command will allow your shell to stop a currently executing process by sending it the SIGTSTP signal. It may be resumed by using the command cont.

Use the appropriate prints from format.h for:

• Process was successfully sent SIGTSTP
• No such process exists
• stop was ran without a pid

cont <pid>

This command resumes the specified process by sending it SIGCONT.

Use the appropriate prints from format.h for:

• No such process exists
• cont was ran without a pid

Any <pid> used in kill, stop, or, cont will either be a process that is a direct child of your shell or a non-existent process. You do not have to worry about killing other processes.