Lecture: 29 Mar, 2010

//From include/linux/sched.h:

struct task_struct {
        volatile long state;    /* -1 unrunnable, 0 runnable, >0 stopped */
        void *stack;
        atomic_t usage;
        unsigned int flags;     /* per process flags, defined below */
        unsigned int ptrace;

        int lock_depth;         /* BKL lock depth */

#ifdef CONFIG_SMP
#ifdef __ARCH_WANT_UNLOCKED_CTXSW
        int oncpu;
#endif
#endif

        int prio, static_prio, normal_prio;
        struct list_head run_list;
        const struct sched_class *sched_class;
        struct sched_entity se;

#ifdef CONFIG_PREEMPT_NOTIFIERS
        /* list of struct preempt_notifier: */
        struct hlist_head preempt_notifiers;
#endif

        unsigned short ioprio;
        /*
         * fpu_counter contains the number of consecutive context switches
         * that the FPU is used. If this is over a threshold, the lazy fpu
         * saving becomes unlazy to save the trap. This is an unsigned char
         * so that after 256 times the counter wraps and the behavior turns
         * lazy again; this to deal with bursty apps that only use FPU for
         * a short time
         */
        unsigned char fpu_counter;
        s8 oomkilladj; /* OOM kill score adjustment (bit shift). */
#ifdef CONFIG_BLK_DEV_IO_TRACE
        unsigned int btrace_seq;
#endif

        unsigned int policy;
        cpumask_t cpus_allowed;
...

Of significant note is the process id, or pid of the process. This is a number that uniquely identifies the process on the system. You can see the pid's of the processes in the system in the second column from the left of the ps listing. The most common use for this pid is referring to a process you want to kill:

kill pid

Creating a new process with fork()

All of these processes came from somewhere: clearly, there must be some way of creating new processes in the system. And, since this is something that involves changing the data structures inside the operating system, it must involve a system call.

The system call we are looking for is fork(). fork() means "create two (almost) identical copies of this process right now". This means the two processes have the same memory contents, the same registers, and the same stack contents, and the same program counter, among other things.

Consider the following simple program.

int main()
{
	fork();
	printf("Hello, world!\n");
	return 0;
}

This program results in the following output:

Hello, world!
Hello, world!

What's going on here? When the program hits the fork(), an interesting thing happens. A second complete process is created which is (nearly) identical to the first process. That means two different processes will each go on to the print statement, so we get the output twice.

Consider the following similar program:

int main()
{
	fork();
	fork();
	printf("Hello, world!\n");
	return 0;
}

This will result in "Hello world!" being printed 4 times. The first fork() will result in 2 processes. Each of those 2 processes will then fork(), which results in 4 processes. Each of those processes will print the message.

Read the following code segment, but keep in mind the adage "with great power comes great responsibility":

int main()
{
	while(1) 
		fork();
	return 0;
}

This is called a fork bomb. It will result in exponential growth in the number of processes running on the system. If the system is not configured to limit the amount of memory or number of processes that a user can have at one time, this will eat all available memory and processor time, and will eventually force you to reboot the machine.

Don't do this on a machine which is not yours. In particular, don't do this on any of the shared unix machines on campus. I don't know if they are configured with reasonable limits, but even if a fork bomb won't bring down the machine, cleaning up a fork bomb is a pain in the #&*(@ and will (justifiably) get you in trouble.

Notice I said the processes created by fork() are almost identical. They differ in a few crucial ways - most significantly their process ids and the return values of the fork() call.

The two processes from a fork() are related to each other. One of them is the parent, and the other is the child. The parent is the "original" process, with the original process id. The child is a copy of the parent, but has its own process id. Additionally, the parent has a few abilities with respect to the child -- more on that in the Wait section below. To help look after the child, the parent receives the process id of the child as its fork() return value. For the child, on the other hand, fork() returns 0.

Here's an example program:

int main()
{
        printf("%li: Before the fork()\n", (long)getpid());
        pid_t p = fork();
        printf("%li: After the fork.  For this process, fork returned %li\n", 
               (long)getpid(), (long)p);
        return 0;
}

The output of this program depends on the specific pid assigned to the child, but here is a sample run:

16946: Before the fork()
16946: After the fork.  For this process, fork returned 16948
16948: After the fork.  For this process, fork returned 0

The first line of the output tells us the starting state: we have a process which has a process id of 16946.

Then we have a fork(). This fork creates a second process, the child. We see two lines of output containing "After the fork"--one for the parent, and one for the child. The child has the new pid of 16948.

Look at the fork return values. For the parent, it got the pid of the child. For the child, it got 0.

The most common usage for fork() is not to start another copy of the current process, but to start a copy of an entirely different program. Do do that, we need exec, which we will cover in depth next time.