Computer Systems
Creating and Executing Unix Processes

Introduction

With the exception of some initial processes, all processes in UNIX are created by the fork system call. In fact, the Unix shell is constantly forking processes.

The exec family of system calls provides a facility for overlaying the calling process with a new executable module. It is often used in conjunction with fork, with the child execing the desired program, and the parent continuing to execute the original code.

The wait system call lets a parent process wait for a child to finish. It will cause the caller to pause until a child terminates. It will return immediately if the process has no children, or a child has terminated previously but not yet been waited for.

The following five activities will give you some practical experience with creating and executing processes in Unix using the following system calls:

	fork, wait, exit
	execv, execl 

Activity 1

• Takes two integers from the command line
• Forks a child process that prints out the difference of the two integers
• The parent process prints out the sum of the two integers.

	if(argc < 3)
     	{
    		printf("Invalid command line: please supply two integer values\n");
        	exit(1);
      	}

Here is a sample output for this activity (assuming command line pfork 12 16):

 	[Child  1235]: Difference of 12 and 16 is -4.
 	[Parent 1234]: Sum of 12 and 16 is 28.

 	[Parent 1234]: Sum of 12 and 16 is 28.
 	[Child  1235]: Difference of 12 and 16 is -4.    

Activity 2

1. At the shell prompt, try the command

       ps -f
   

   A list of your own processes currently running will be displayed:
   • The first column lists the owner of the process (your account name)
   • The second column lists the identifier of the process
   • The third column lists the identifier of the parent process

   Very likely, your only process currently running is the bash shell. For a list all processes in the system, try

       ps -e -f
   

   Optionally, for more information on ps, use the Unix manual pages (type in man ps at the shell prompt).

2. Find out the full path for the command ps by typing in at the shell prompt

       which ps
   

   You will likely find out that the full path for ps is /bin/ps.

3. Copy the program from Activity 1 into a new file pexec.c. Extend the code for the child to do the following:
   • 3.1 Print out the difference of the two integers, as before
   • 3.2 Execute the code for

     	ps -e -f

     To do so, initialize an array of strings cmd with the tokens in the command you'd like to execute, then use execv:

     	char * cmd[] = {"/bin/ps", "-e", "-f", 0};  // in the variable declaration section
     	...
     	execv(cmd[0], cmd);                         // in the code section of the program
     

     The first string in the array cmd should be the full path for the command ps found in the previous step.

   Here is a sample output (assumming the command line pexec 12 16):

   	[Parent 1234]: Sum of 12 and 16 is 28.
   	[Child  1235]: Difference of 12 and 16 is -4.
   
        	UID     PID   PPID   C    STIME TTY      TIME CMD
        	mdamian 22686 22684  0 14:12:26 pts/5    0:01 -bin/bash
        	mdamian 22826 22686  0 15:11:49 pts/5    0:00 pexec
        	mdamian 22827 22826  0 15:11:49 pts/5    0:00 ps
   

   Make sure the parent waits for the child to finish executing.

4. Is it possible to have the child execute ps -e -f first, and then print out the difference value? Explain your answer.

Activity 3

• Instead of using an array of arguments such as cmd, you can pass the command tokens directly in a list using execl (trailing 'l' from 'execl' stands for 'list', trailing 'v' from 'execv' stands for vector):

      execl("/bin/ps", "/bin/ps", "-f", 0); 
  

  Note that the argument /bin/ps appears twice: the first occurence accounts for cmd[0], while the rest of arguments account for all values in the array cmd, as used in execv. Try it out.

• The system function execv requires the full path for the program to execute, starting at the root. For instance, we must use the entire path /bin/ps, instead of just ps. Unix provides a similar function, called execvp, that places a pointer to the process environment that contains the location of the file on the disk. When using execvp, you do not need to provide the entire path for the program to execute:

      char * cmd[] = {"ps", "-f", 0};  // in the variable declaration section
      ...
      execvp(cmd[0], cmd);             // in the code section of the program
  

  Modify the code from Activity 2 to include the lines of code above (comment out existing code, do not delete). Does it produce the same output?

• The equivalent for execl is execlp: just as execvp, it does not require the full path for the program to execute. Try it out.

Activity 4

    wc filename

1. Prints out the name of the file
2. Uses execl to execute the program wc on that file

Here is a sample output (user input is in italics, aa and bb are two files in the same directory as xlinecount):

    bash$ ./xlinecount aa bb
    aa
           3       2       9   aa
    bb
           5       6      41   bb

Activity 5

    void mysystem(char * cmd);

1. Tokenize the command argument cmd and save each token in an array of strings
2. The main process invokes fork to create a child process, then waits for the child to finish executing
3. The child process invokes execv with arguments taken from the array of strings

    mysystem("wc aa");

	      3       2       9   aa