Nov 14

Programs and Processes

(much of the material here, especially the fork() programs, is courtesy Jim Plank at UTK)

A process is an instance of a program in execution. One program may thus correspond to multiple processes. The UNIX ps command depicts the status of processes. Use ps -ef to list all processes on the system. Note that, by default ps will list itself (since, at that moment, it is running).
A process can run in the foreground (occupying your terminal, so you cannot type any more commands until the process completes) or in the background (releasing your terminal so that you are free to do something else). For instance, consider the command
```
cd /; find .
```
which lists all files on your system! Running it in the foreground (by just typing the command) will be a disaster! Try it!
Hit Ctrl-C to interrupt that process. To execute the process in the background instead, do
```
cd /; find .&
```
which runs the find command in the background. The only difference is the ampersand at the end. Now your terminal is free to do something else!
Yeh? you say. How can I use this terminal when it is still raining cats and dogs? Well, technically the terminal is really waiting for your commands but since the output is so profuse, you cannot see the command line for the output! In particular, hitting Ctrl-C does not help, since there is no process running in the foreground to interrupt!
There are many ways to get out of this situation. Use one of the following:
- Open up a new terminal window. Do a ps -ef | egrep find there to find the process ID (PID; second column) of the find process. Let us say it is 2345. Then type:
```
kill -9 2345
```
  which will kill that process.
- Type fg in the current terminal window which will bring the job back into the foreground. The output is still spewing on the terminal, so much so that you won't even be able to see that you typed fg. But now that it is in the foreground, you can hit a Ctrl-C.
The fg command brings a process into the foreground and the bg command puts it to work in the background. By default, just typing fg will bring the most recently backgrounded job to the foreground (and vice versa). If you have multiple jobs in the background, you can specify which one you want to be foregrounded by specifying (typically) the job number (which is different from the process ID number). To identify job numbers, type jobs. Then use the job number in job's output preceded by a % sign, like: fg %2.
Another useful trick is when you put a job in the foreground and later realize that you actually wanted to put it in the background. You cannot type jobs and then do a bg because the terminal is not free to accept commands! Instead do the following series of commands:
```
Ctrl-Z
bg
```
The Ctrl-Z suspends the process (does not interrput it, as does Ctrl-C) which can then be put to background by bg.
Precise scheduling of jobs can be done using the sleep (sleeps for a specified amount of time), at (schedules a job at a particular time), and cron (schedules repeated and monotonous jobs) commands. Use man to learn more about them.

More on processes

The ps command also lists for each process, its parent process ID (PPID), i.e., the ID of the process that started this process. Note that you can follow the chain of process invocations back to the mother of all processes, called init. This is the process that runs first when you bring up UNIX. It then gives rise to all the processes that you see in your session.
The UNIX system calls getpid() and getppid() give information about the current process's PID and its parent's PID. For instance, if we compile the following program (showpid.c):
```
#include <stdio.h>

main()
{
  printf("My pid = %d.  My parent's pid = %d\n", getpid(), getppid());
}
```
and run it, say twice, we get:
```
My pid = 7424.  My parent's pid = 2590
My pid = 7425.  My parent's pid = 2590
```
Note that the parent PID is the same but the given process ID changes on each invocation (why?)
The pstree command gives a nice tree-structured list of who started who, revealing the root process as init.
To understand how init started everything, we have to study a concept called "forking". When a process forks, it is creating a new process which is a copy of itself, i.e., it copies all its memory stack, variables, open files, and hands over the copy to the "child" process. At this point, the child is free to go its own way and do something different. We can learn about forking by using the UNIX system call fork() in a C program (simpfork1.c):
```
#include <stdio.h>

main()
{
  int i;

  printf("simpfork: pid = %d\n", getpid());
  i = fork();
  printf("Did a fork.  It returned %d.  getpid = %d.  getppid = %d\n",
    i, getpid(), getppid());
}
```
The first printf is executed before the process forked, so only one line of output will be generated. The second printf is executed in both the parent and the child, so two lines of output are given. How can you figure out which line was the output of the child and which came from the parent? You cannot assume, by default, that the child (or the parent) will be the first. You have to look at the return values of fork(). For the parent, it returns the ID of the child process. For the child, it returns zero. This is how you know which process you are in when fork() returns.

Here's another fork program. After forking, the parent exits. In such a case, notice who "adopts" the child process now.

#include <stdio.h>

main()
{
  int i;

  i = fork();
  if (i == 0) {
    printf("Child.  getpid() = %d, getppid() = %d\n", getpid(), getppid());
    sleep(5);
    printf("After sleeping.  getpid() = %d, getppid() = %d\n",
            getpid(), getppid());
  } else {
    printf("Parent exiting now\n");
  }

}

To reinforce that the parent's address space is truly copied over to the child, and that these become separate copies henceforth, try the following program:

#include <stdio.h>

int K;

main()
{
  int i;
  int j;

  j = 200;
  K = 300;

  printf("Before forking: j = %d, K = %d\n", j, K);
  i = fork();

  if (i > 0) {  /* Delay the parent */
    sleep(1);
    printf("After forking, parent: j = %d, K = %d\n", j, K);

  } else {
    j++;
    K++;
    printf("After forking, child: j = %d, K = %d\n", j, K);
  }
}