COP 4610 :: Project Pages :: Project 2: Concurrency with Processes

Deliverables: Two files: myshell.c and makefile

Assessment Rubric:

Your code uses good programming practices:         [0...30]    xx
Your shell can run background commands correctly:  [0...35]    xx
Your shell can kill processes correctly:           [0...15]    xx
Your shell has the jobs command:                   [0...20]    xx
Late Fees:                    [-4 pts per dated submission]   (xx)
Project 1 source code distribution:                [-4 pts]   (xx)
                                                              ---
Score:                                             [0..100]   xxx

Example Project 1 Code

Note that you may begin with example solution code for project 1 if you are not confident with your shell submitted for project 1. Obtaining this "head start" code will cost 4 points toward your grade in project 2. To obtain a copy of this code:

1. cp -r ~cop4610p/LIB/proj1Code ~/cop4610
   This should create the directory and give you copies of deliverables.sh and request.txt.
2. Edit request.txt to place your CS username in the designated place in the document.
3. Execute submit.sh

The code will be sent to your CS email account.

NOTE: There is a non-disclosure agreement in "request.txt" that is binding, enforced by the FSU honor code.

Details

Your task is to take your project 1 shell and add the ability to run processes in the background. Note that you already learned how to spawn parallel processes in project 1, but background processing will allow your shell to continue running while another process is running. In other words, you won't have to wait on it to finish. The symbol to denote that a command should run in the background is the ampersand (&). Just like the redirection operators from project 1 (< and >), you can assume whitespace on both sides of the & symbol. Your parsing algorithm will simply add in a check for this symbol. Also, you will want to store some type of flag in your command structure to decide whether a command should be executed normally or in the background.

When a command is set to run in the background, you will follow these steps when executing:

(1) Give the command a job ID (JID) and store the JID, process ID (PID), and command itself in an array. This will require some type of structure to hold the JID, PID, and command. In other words, the type of elements in the array are structures with the JID, PID, and command. Each structure will be placed in the array after the last existing structure. The JID will start at 1 and will always be one more than the last existing structure's JID. For example, if your array is empty, the next background command will occupy the first spot in the array and have JID 1. As another example, if the last existing structure is at the fourth spot in the array and has JID 8, the next one will be added in the fifth spot and have JID 9. You can assume a max of 100 items in the array at any one time.

(2) Print the following message to the screen:

[JID] [PID]

where [JID] is the job ID in brackets and [PID] is the process ID in brackets.

(3) Run the command like normal in your child process.

(4) Your parent process will not wait on a background command in the same way you waited in project 1. Instead, your command prompt loop will periodically wait with a special flag called WNOHANG. This will simultaneously let you check for terminated children and not cause your program to stop and wait. Note that the wait with the special flag is still necessary to avoid zombie processes.

(5) You don't need to print the moment a child ends, but the next time the jobs command is called, you will print the following message to the screen:

[JID] Done COMMAND

where [JID] is the job ID in brackets, Done is literally the word "Done", and COMMAND is the command that was run. You can space them out a bit more if you want with tabs, for example.

You will also create a new built-in command called jobs. While we aren't going to implement job control functionality, you should make jobs simply print the entire array of background tasks in the format of (5) above, except printing [PID] instead of Done. Only make it print actual jobs, not free array slots.

Backgound processes should be able to be terminated prematurely by using the kill command. This is an external command, so you don't actually have to worry about killing the process, but you do have to make sure your jobs array correctly reflects this. You may assume that the PID is the only argument the kill command will have. After calling kill PID, you will print something like this: [JID] Terminated COMMAND.

Your code uses good programming practices (30%).

Your shell can run background commands correctly (35%).

Your shell can kill background processes correctly, and only exits if these have all been killed (15%).

Your shell has the jobs command (20%).

Submitting

Submit two files: myshell.c containing your updated shell source code with background processing, and makefile which builds an executable named myshell.x. Do this with ~cop4610p/submitscripts/proj2submit.sh.