System Architecture

1  Introduction

• look at Unix and Linux specific concepts, such as processes, files, memory etc.
• look at the POSIX system calls which give user-mode programs access to these concepts
• sometimes, look at some Java simulations of how an operating system implements these concepts

2  The Unix Process Model

init-+-Xvnc
     |-cron---cron-+-sendmail
     |             `-sh---cvsup
     |-2*[getty]
     |-inetd
     |-lpd
     |-sendmail
     |-sshd
     |-syslogd
     |-xinit-+-XF86_Mach64
     |       `-fvwm-+-FvwmPager
     |              |-xbiff
     |              |-xclock
     |              |-xterm---tcsh-+-navigator-4.61.b---navigator-4.61.b
     |              |              `-pstree
     |              `-xterm---tcsh
     |-xntpd
     `-xterm---ssh1

3  Multiprocess Capabilities

  $ w

4  Multitasking Capabilities

  $ ps

  $ ps -ef | more

• The user who started the process,
• The unique process-id of the process,
• The process-id of the parent process who started this process up,
• The processor utilisation (obsolete),
• The time or date when the process started,
• The terminal to which this process is attached,
• The cumulative execution time for the process, and
• The command name and the arguments.

  $ ps -e -o pri,vsz,pcpu,s,comm  | more

O:

The process is running.

S:

The process is blocked on I/O.

R:

The process is ready to run.

I:

The process is idle (blocked for > 30 seconds).

Z:

The process is a zombie.

T:

The process is being traced (debugged) by its parent.

X:

The process is waiting for more memory.

5  Foreground and Background Tasks

  $ sleep 100                 # Wait for 100 seconds, then go back to shell
    ctrl-C                    # Kill sleep process
  $ sleep 100 &               # Wait for 100 seconds in the background
  $ jobs                      # Show list of jobs
  [1] +  Running                 sleep 100 &
  $ stop %1                   # Stop sleep process (job number 1)
  $ jobs
  [1] + Stopped (SIGSTOP)        sleep 100 &
  $ bg %1                     # Put sleep in background
  $ fg %1                     # Bring sleep in foreground

  $ (sleep 10; ps -ef)

6  Process-related System Calls

6.1  Finding a Process' Identity

     #include <sys/types.h>
     #include <unistd.h>

     int getpid(void)

     int getppid(void)

6.2  The Fork System Call

     #include <sys/types.h>
     #include <unistd.h>

     int fork(void)

6.3  The Exec System Call

     #include <unistd.h>

     int execlp(const char *file, const char *arg, ...)

    . . .
    execlp("ls", "-l", "fred.c", mary.c", NULL);
    . . .
    printf("Just after the exec syscall\n");

6.4  Combining Fork and Exec

  int pid;                      /* Holds the process-id of the child */

  switch (pid = fork())         /* Call fork, and test what it returns */
  {
    case -1: printf("The fork failed\n"); return (-1);

    case 0:              /* The child is given a value of 0 from fork() */
                           /* Do special things like closing files etc. */

    if (redirection required) {
      close my standard output;
      open the named output file as my standard output;
    }

                                /* Replace ourselves with the real child */
                                /* Call execvp */
      execlp(command, arg1, arg2, ..., NULL);
      exit(1);                  /* Exec failed, indicate error */

    default:          /* The parent receives the new process-id from fork() */
      wait();                   /* Wait for child to exit */
}

6.5  The Exit and Wait System Calls

     #include <stdlib.h>

     void exit(int status)

     #include <sys/types.h>
     #include <sys/wait.h>

     int wait(int *status)

6.6  Zombie Processes

6.7  Some Example Programs

• onlyfork.c show what happens when a process fork()s with no exec(). Compile with the command   cc -o onlyfork -g -Wall onlyfork.c  , and run it with the command   ./onlyfork
• onlyexec.c show what happens when a process exec()s with no fork(). Compile with the command   cc -o onlyexec -g -Wall onlyexec.c  , and run it with the command   ./onlyexec
• forkexec.c show what happens when a process fork()s and exec()s. Compile with the command   cc -o forkexec -g -Wall forkexec.c  , and run it with the command   ./forkexec
• shell.c is an example of a Unix command-line shell, which reads a command line, breaks it into the command plus the arguments and then uses fork() and exec() to run it. Don't worry about the code which parses the line, concentrate on the code which uses fork(), exec(), wait() and exit(). Use the same sort of compile command as above.
• I wrote this program, tinyshell.c, to see how small I could make a shell. Compile this one with the command   cc -o tinyshell tinyshell.c

7  The Linux Scheduler

• The Linux Process Scheduler
• A closer look at the Linux O(1) scheduler

8  Process Scheduling Simulator

• download the simulator tarball from this local copy
• tar vxzf scheduling.tgz
• cd scheduling

8.1  Activities

1. Look at the original scheduling.conf file: explain what it means. Explain how this scheduling.conf file produces this output:

   Scheduling Type: Batch (Nonpreemptive)

   Scheduling Name: First-Come First-Served

   Simulation Run Time: 2877

   Mean: 1100

   Standard Deviation: 510

   Process #	CPU Time	IO Blocking	CPU Completed	CPU Blocked
   0	1725 (ms)	100 (ms)	1725 (ms)	17 times
   1	576 (ms)	500 (ms)	576 (ms)	1 times
   2	576 (ms)	30 (ms)	576 (ms)	19 times
2. Create a configuration file in which all processes run an average of 2000 milliseconds with a standard deviation of zero, and which are blocked for input or output every 500 milliseconds. Run the simulation for 10000 milliseconds with 2 processes. Examine the two output files. Try again for 5 processes. Try again for 10 processes. Explain what's happening.
3. For the Java programmers, modify the scheduling algorithm to perform pre-emption. Add a configuration directive that sets the maximum quantum that any process can have before being pre-empted. Put the process back on the tail of the ready queue.

9  Outlook for the Next Lab