CSS 430
Program 1: System Calls and Shell
Due date: See the syllabus

0. Preface: A Note on Academic Integrity

This series of programming assignments is a step-by-step implementation of an OS simulator in Java. As you might imagine, significant effort was expended in the comprehensive design of the individual assignments and the way they are linked together. The goal is to enhance your understanding of key concepts by giving you an opportunity to learn by doing, rather than being limited to learning by reading or listening (though it is hoped these will also enhance your understanding). It would be very difficult to significantly change the specifications of these assignments every quarter the course is offered. Thus, solutions developed by former CSS430 students will likely be similar to solutions you will develop for these assignments. However, learning by copying will not help enhance your understanding, and submitting someone else's work as your own would be a violation of the academic integrity expected of all members of the UWB community.

In cultivating a collaborative learning environment, it is expected that you will consult various resources as you seek to understand each assignment, and as you iteratively develop and test your solutions to each one. However, all the solutions - programs, reports and other materials - that you submit for this or any other class you take at UWB must be your own. The instructor expects that students will appropriately conduct themselves throughout the course. However, there have been instances in the past where students have not maintained academic integrity in this course, and they have been reported to the Vice Chancellor's office in accordance with the UWB Student Conduct Code. All solutions submitted by former css430 students in all sections have been archived, and can be easily accessed by software plagiarism detection applications.

1. Purpose of this assignment

The three goals of this assignment are for you to

1. become familiar with Linux system programming through the use of system calls such as fork(), execlp(), wait(), pipe(), dup2() and close()
2. better appreciate that, from the kernel's viewpoint, the shell is simply an application program that uses system calls to spawn and to terminate other user programs
3. become familiar with our ThreadOS operating system simulator, which will also be used for all subsequent assignments.

2. Shell

This section explains the behavior and the language syntax of the Unix (Linux) shell.

2.1. Command interpretation

The shell is a command interpreter that provides Unix users with an interface to the underlying operating system. It interprets user commands and executes them as independent processes. The shell also allows users to code an interpretive script using simple programming constructs such as if, while and for. With shell scripting, users can coordinate a collection of their jobs.

The behavior of the shell simply repeats:

1. Display a prompt to indicate that it is ready to accept a next command from its user
2. Read a line of keyboard input as one or more commands, possibly with arguments
3. Spawn one or more new processes to execute the user command(s)

Examples of prompts include a host name followed by a % symbol

   uw1-320-00%

   $

There are a variety of different shells that can be run on a Linux system, including the Bourne shell (sh), C-shell (csh), Korn shell (ksh) and Bourne again shell (bash). You can check which shell is running on a Linux system by issuing the command

    echo $SHELL

    /bin/bash

To execute each command, the shell follows these steps:

1. Search for an executable file whose name is specified in the first string (other strings are args) in the directories listed in the PATH variable; if such a file is not found, abort and issue a "command not found" error message
2. Create a new child process by duplicating itself
3. Overlay its process image with the executable file.
4. The new process receives all the remaining strings given from a keyboard input (if any), and executes the command with those args.

For example, assume that your current working directory (CWD) includes the a.out executable file and you have typed the following line input from your keyboard:

   uw1-320-00% ./a.out a b c

After reading this command line, the shell process duplicates itself, and this duplicated process executes a.out with a, b and c as its arguments.

The shell has several builtin commands in addition to the commands that are stored externally as executable programs. Many of the built-ins have some effect on the state of the shell. For example, the cd command changes the current working directory of the shell:

   uw1-320-00% cd public_html

The shell can receive two or more commands at a time from a keyboard input. The symbols ';' and '&' are used as delimiters to separate each individual command. The ';' symbol specifies sequential processing of commands; the '&' symbol specifies parallel processing of commands. More specifically:

• If a command is followed by ';', the shell spawns a new process to execute this command, waits for that process to be terminated, and thereafter continues to process the next command on the line.
• If a command is delimited by '&', the shell spawns a new process to execute this command, but does not wait for that process to be terminated, instead proceeding on to the next command on the line immediately after spawning the child process.

   uw1-320-00% who & ls & date

   uw1-320-00% who & ls & date &

Now that we have learned a little more about the behavior of the shell, we can specify its behavior more precisely as follows:

1. Display a prompt to show that it is ready to accept a new line of input from the keyboard
2. Read a line from the keyboard
3. Repeating the following sequence for each command until it reaches the end of the input line:
   • Spawn a new process to execute this command.
   • Wait for the spawned process to be terminated if the command is delimited by ';' (otherwise continue)

2.2. Input/output redirection and pipelines

One of the shell's interesting features is I/O redirection. Unless specified otherwise, input to a command run from by shell is read from the keyboard, i.e., the default standard input source is the keyboard. Likewise, the standard output destination for a command run by the shell is the monitor, unless otherwise specified. The '<' symbol on the command line specifies a file from which input to a command will be read, and the '>' symbol specifies a file to which output will be written. Each command can have zero, one or both redirection specifications. For example, when the following command is input to the shell

   uw1-320-00% a.out < file1 > file2

Another useful feature is pipelines. Pipelines connect the output of one process to the input of another process using the '|' (vertical bar) as a delimiter.

   uw1-320-00% command1 | command2 | command3

As a specific example,

   uw1-320-00% who | wc -l

2.3. Shell implementation techniques

3. ThreadOS

Through a series of assignments, you will implement and/or enhance some portions of ThreadOS. ThreadOS loads Java programs that have been derived from the Java Thread class, manages them as user processes, and provides them with some basic operating system services. Those services include spawning threads, terminating threads, disk operations, and even standard input/output. ThreadOS receives all service requests as a form of interrupt from each user thread, handles them, and returns a status value to the interrupting thread.

3.1. Structure

To start ThreadOS, simply type:

  uw1-320-00% java Boot
  ThreadOS ver 1.0:
  Type ? for help
  threadOS: a new thread (thread=Thread[Thread-3,2,main] tid=0 pid=-1)
  -->

  uw1-320-00% date; java Boot; date
  Sat Oct  8 11:14:41 PDT 2011
  threadOS ver 1.0:
  threadOS: DISK created
  default format( 64 )
  Superblock synchronized
  Type ? for help
  threadOS: a new thread (thread=Thread[Thread-3,2,main] tid=0 pid=-1)
  -->q
  q
  Superblock synchronized
  Sat Oct  8 11:15:09 PDT 2011
  uw1-320-00% 

Note that Loader is not a shell. It simply launches and waits for the completion of a user program (which, in the case of Shell.class, may behave as a shell). From ThreadOS' point of view, there is no distinction between Loader and the other user programs.

3.2. User Programs

A user program run by ThreadOS must be an instance of a Java thread. Java threads are execution entities concurrently running in a Java application. They maintain their own stacks and program counter but share static variables in their application. At least one thread, (i.e., the main thread) is automatically instantiated when an application starts a main function. Threads other than the main thread can be dynamically created in the similar way to instantiate a new class object using new. Once their start method is called, they keep executing their own run method independently from the calling function such as main. Java threads can be defined as a subclass of the Thread class.

The following Java thread repeatedly writes copies of word (given in args[0]) to standard output, waiting for loop milliseconds (given in args[1]) between printing each copy [note: in an earlier version, loop was used to specify the number of dummy iterations of a busy wait for loop between printing each copy; code from earlier version is shown in comments].

  public class PingPong extends Thread { // NB: "extends Thread"
    private String word;
    private int loop;
    public PingPong( String[] args ) {
      word = args[0];
      loop = Integer.parseInt( args[1] );
    }
    public void run( ) {
      for ( int j = 0; j < 100; j++ ) {
        // substituting SysLib.cout() for System.out.println()
        // System.out.print( word + " " );
        SysLib.cout( word + " " );
        // substituting SysLib.sleep() for busy wait for loop
        // for ( int i = 0; i < loop; i++ ) ;
        SysLib.sleep( loop );
      }
      SysLib.cout( "\n" );
      SysLib.exit( );
    }
  }

public class TestPingPong {
  public static void main( String[] args ) {
    String[] testargs = new String[2];
    
    testargs[0] = "ping"; testargs[1] = "10";
    new PingPong( testargs ).start( );

    testargs[0] = "PING"; testargs[1] = "90";
    new PingPong( testargs ).start( );
  }
}

Just as the Java Virtual Machine searches for and runs a main method defined in whatever class file it is given as input, the ThreadOS will search for and run a run method defined in whatever class file is loaded via the Loader (l command). Note that any Java class defined as a subclass (extension) of Thread must define a run method.

ThreadOS Loader takes care of the thread-instantiating task typically invoked by the main function, automatically instantiating a new thread object and invoking its run method.

Once you invoke ThreadOS, the Loader waits for a l command, for example

    l PingPong ping 100

Java itself provides various classes and methods that invoke real OS system calls such as System.out.println and sleep. Since ThreadOS is an operating systems simulator, user programs running on ThreadOS are prohibited from using any real OS system calls. Prohibited classes include but are not limited to the following packages:

• java.lang.System
• java.lang.Thread (with the exception of declaring an extension of Thread)
• java.io.*

Instead, user programs are provided with SysLib, a system library of ThreadOS-unique of system calls including standard I/O, disk access, and thread control. For example,

  System.out.print( word + " " );

  SysLib.cout( word + " " );

While Java threads can be terminated upon a simple return from their run method, ThreadOS needs an explicit system call to terminate the current user thread.

  SysLib.exit( );

The following Java class uses SysLib methods to print "Hello world" to standard output and then terminate:

public class HelloWorld extends Thread {
  public HelloWorld() {
  }
  public void run() {
    SysLib.cout( "Hello, world\n" );  // using SysLib.cout vs System.out.println
    SysLib.exit();                    // don't forget to explicitly exit
    return;
  }
}

As a slightly more interesting example, we can revisit and revise the PingPong class definition to work with SysLib. Since the original definition of the class includes an infinitive loop (while (true)), we will revise it so that this sample code safely terminates the invoked thread and resumes Loader.

  public class PingPong extends Thread {
    private String word;
    private int loop;
    public PingPong( String[] args ) {
      word = args[0];
      loop = Integer.parseInt( args[1] );
    }
    public void run( ) {
      for ( int j = 0; j < 100; j++ ) { // for vs. while
        SysLib.cout( word + " " );
        for (int i = 0; i < loop; i++ )
          ; // busy wait
      }
      SysLib.cout( "\n" );
      SysLib.exit( );
    }
  }

3.3. System Calls

ThreadOS Kernel receives requests from each user thread as interrupts to it. Such an interrupt is performed by calling:

   Kernel.interrupt( int interruptRequestVector, 
                     int trapNumber, 
                     int parameter, 
                     Object args );

• interruptRequestVector may be one of
  1. INTERRUPT_SOFTWARE
  2. INTERRUPT_DISK
  3. INTERRUPT_IO
• trapNumber specifies a request type of software interrupt such as
  0. BOOT
  1. EXEC
  2. WAIT
  3. KILL
• parameter is a device-specific value to control each device
• args are arguments for each interrupt request.

Since this interrupt method is fairly low-level, ThreadOS provides a system library, called SysLib that includes several important system call functions as shown below. (Unless otherwise mentioned, each of these functions returns 0 on success or -1 on error.)

1. SysLib.exec( String args[] ) loads the class specified in args[0], instantiates its object, simply passes the following elements of String array, (i.e., args[1], args[2], ...), and starts it as a child thread. It returns a child thread ID on success, otherwise -1.
2. SysLib.join( ) waits for the termination of one of child threads. It returns the ID of the child thread that has woken up the calling thread. If it fails, it returns -1.
3. SysLib.exit( ) terminates the calling thread and wakes up its parent thread if this parent is waiting on join( ).
4. SysLib.cin( StringBuffer s ) reads keyboard input to the StringBuffer s.
5. SysLib.cout( String s ) prints out the String s to the standard output. Like C's printf, it recognizes '\n' as a new-line character.
6. SysLib.cerr( String s ) prints out the String s to the standard error. Like C's printf, it recognizes '\n' as a new-line character.
7. SysLib.rawread( int blkNumber, byte[] b ) reads one block data to the byte array b from the block specified by blkNumber.
8. SysLib.rawwrite( int blkNumber, byte[] b ) writes one block data from the byte array b to the block specified by blkNumber.
9. SysLib.sync( ) writes back all on-memory data into a disk.

In addition to those system calls, the system library includes several utility functions. One of them is:

• public static String[] SysLib.stringToArgs( String s ) converts a space-delimited string into a String array in that each space-delimited word is stored into a different array element. This call returns such a String array.

[The source code for SysLib.java can be found on the uw1-320-lab network under /usr/apps/CSS430/ThreadOS]

3.4. Other components

   ps -A | grep argv[1] | wc -l

   ps -A | grep sh | wc -l
   ./processes sh

• pid_t fork( void ) creates a child process that differs from the parent process only in terms of their process IDs.
• int execlp( const char *file, const char *arg, ..., NULL ) replaces the current process image with a new process image that will be loaded from file. Note: the first argument arg must be the same as file.
• int pipe( int filedes[2] ) creates a pair of file descriptors (which point to a pipe structure), and places them in the array pointed to by filedes. filedes[0] is for reading data from the pipe, filedes[1] is for writing data to the pipe.
• int dup2( int oldfd, int newfd ) creates in newfd a copy of the file descriptor oldfd.
• pid_t wait( int *status ) waits for process termination
• int close( int fd ) closes a file descriptor.

In addition to the links included for each command above, you can also use the man command from the shell prompt line. Wolf Holzman has posted a nice overview of pipe, fork, exec and related topics. Note: Use only the Linux system calls listed above for this assignment. Do not use the system system call.

You may find the following series of simple programs, derived from the example on the Linux pipe(2) man page, helpful:

• testpipe0.cpp (writes "hello" directly to a pipe)
• testpipe1.cpp (writes any string arg directly to a pipe)
• testpipe2.cpp (uses the Linux 'echo' command to write a string arg to a pipe)

The following series of sample programs illustrates small variations in using fork, dup2 and execlp to emulate the behavior of

    ps -A | tr a-z A-Z

• pipedup2a.cpp:
  after a short sleep, parent implements tr-like loop, reading from pipe;
  the child executes ps, writing to the pipe.
  (The parent & child code is the reverse of who does what in pipedup2b.cpp)
• pipedup2b.cpp:
  parent executes ps, writing to pipe;
  after a short sleep, the child implements tr-like loop, reading from the pipe.
  (The parent & child code is the reverse of who does what in pipedup2a.cpp)
• pipedup2c.cpp:
  after a short sleep, parent executes tr, reading from pipe;
  the child executes ps, writing to the pipe.
  (The parent & child code is the reverse of who does what in pipedup2d.cpp)
• pipedup2d.cpp:
  parent executes ps, writing to pipe;
  after a short sleep, the child executes tr, reading from the pipe.
  (The parent & child code is the reverse of who does what in pipedup2c.cpp)
• pipedup2e.cpp:
  after a short sleep, parent executes tr, reading from pipe;
  the child executes ps, writing to the pipe.
  This version shows that you can close the original fd associated with the pipe
  after making a copy of it in STDIN or STDOUT via dup2,
  based on an example in CPS590 - Del's Pipes Lecture Notes, via Darren Korman
  (The parent & child code is the reverse of who does what in pipedup2f.cpp)
• pipedup2f.cpp:
  parent executes ps, writing to pipe;
  after a short sleep, the child executes tr, reading from the pipe.
  This version shows that you can close the original fd associated with the pipe
  after making a copy of it in STDIN or STDOUT via dup2,
  based on an example in CPS590 - Del's Pipes Lecture Notes, via Darren Korman
  (The parent & child code is the reverse of who does what in pipedup2e.cpp)

Imitate how the shell performs ps -A | grep argv[1] | wc -l. In other words, your parent process spawns a child that spawns a grand-child that spawns a great-grand-child. Each process should execute a different command as follows (note the order):

4.2: ThreadOS Shell Design

   uw1-320-00% java Boot
   ThreadOS ver 1.0:
   Type ? for help
   -->l MyShell
   l MyShell
   threadOS: a new thread (thread=Thread[Thread-6,2,main] tid=1 pid=0)
   shell[1]% TestProg1 & TestProg2 &
   ... A concurrent execution of TestProg1 and TestProg2
   ...  
   shell[2]% TestProg1 ; TestProg2
   ... A sequential execution of TestProg1 and TestProg2
   ...
   shell[3]% exit
   -->q
   uw1-320-00%

Once MyShell is invoked, it should print out a command prompt that contains the word "shell" and then the command number (starting at 1) in square brackets, e.g.,

   shell[1]%

When a user types multiple commands, each delimited by '&' or ';', MyShell should execute each of them as an independent child thread with a SysLib.exec() system call. Note that the symbol '&' denotes concurrent execution, while the symbol ';' denotes sequential execution. Thus, when encountering a delimiter ';', MyShell needs to call SysLib.join() system call(s) in order to wait for this child thread to be terminated. Since SysLib.join() may return the ID of any child thread that has been previously terminated, you have to repeat calling SysLib.join() until it returns the exact ID of the child thread that you are waiting for.

You do not need to implement standard I/O redirection or pipes. You do not need to provide shell variables and programming constructs, either. The only the required functionality of MyShell is handling an arbitrary number of commands in a line. You may assume that commands, arguments, and even delimiters are separated by arbitrary amounts of spaces or tabs.

To test your MyShell, use the PingPong class that is defined in the same directory as ThreadOS. Your test should be

   shell[1]% PingPong abc 100 & PingPong xyz 100 & PingPong 123 100 &
   shell[2]% PingPong abc 100 ; PingPong xyz 100 ; PingPong 123 100 ;

ThreadOS can be found in the following directory on the uw1-320-lab network:
/usr/apps/CSS430/ThreadOS/

To use ThreadOS and develop and test your program,

1. Create a directory in your account to use for ThreadOS code, e.g., to create a directory named ThreadOS under your home directory ("~" is shorthand for your home directory):

      mkdir ~/ThreadOS
   

2. Copy all the byte-compiled Java class files for ThreadOS into this directory, e.g.,

      cp /usr/apps/CSS430/ThreadOS/*.class ~/ThreadOS
   

3. Create HelloWorld.java in your ThreadOS directory based on the code shown above, and compile it in that directory (javac HelloWorld, which if successful will create HelloWorld.class).
4. Verify that your copy of ThreadOS, and the byte-compiled Shell class included with the distribution, works correctly with the sample class files HelloWorld and PingPong. The following is an example of what this might look like:

     [joemcc@uw1-320-17 ThreadOS]$ java Boot
     threadOS ver 1.0:
     Type ? for help
     threadOS: a new thread (thread=Thread[Thread-3,2,main] tid=0 pid=-1)
     -->l Shell
     l Shell
     threadOS: a new thread (thread=Thread[Thread-5,2,main] tid=1 pid=0)
     shell[1]% HelloWorld
     HelloWorld
     threadOS: a new thread (thread=Thread[Thread-7,2,main] tid=2 pid=1)
     Hello, world
     shell[2]% PingPong abc 100 & PingPong xyz 100 & PingPong 123 100 &
     PingPong
     threadOS: a new thread (thread=Thread[Thread-9,2,main] tid=3 pid=1)
     PingPong
     threadOS: a new thread (thread=Thread[Thread-11,2,main] tid=4 pid=1)
     PingPong
     threadOS: a new thread (thread=Thread[Thread-13,2,main] tid=5 pid=1)
     shell[3]% abc abc abc abc abc abc abc abc abc abc xyz abc xyz abc xyz abc xyz 
     abc xyz abc xyz abc xyz abc xyz abc xyz abc xyz abc 123 xyz abc 123 xyz abc 
     123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 
     xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz 
     abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 
     123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 
     xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz 
     abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 
     123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 
     xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz 
     abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 
     123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 
     xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz 
     abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 123 xyz abc 
     123 xyz abc 123 xyz abc 123 xyz 
     123 xyz 123 xyz 123 xyz 123 xyz 123 xyz 123 xyz 123 xyz 123 xyz 123 xyz 123 
     123 123 123 123 123 123 123 123 123 
   
     shell[3]% PingPong abc 100 ; PingPong xyz 100 ; PingPong 123 100
     PingPong
     threadOS: a new thread (thread=Thread[Thread-15,2,main] tid=6 pid=1)
     abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc 
     abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc 
     abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc 
     abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc 
     abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc 
     abc abc abc abc abc 
     PingPong
     threadOS: a new thread (thread=Thread[Thread-17,2,main] tid=7 pid=1)
     xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz 
     xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz 
     xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz 
     xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz 
     xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz 
     xyz xyz xyz xyz xyz 
     PingPong
     threadOS: a new thread (thread=Thread[Thread-19,2,main] tid=8 pid=1)
     123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 
     123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 
     123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 
     123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 
     123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 
     123 123 123 123 123 
     shell[4]% exit
     exit
     -->q
     q
     Superblock synchronized
     [joemcc@uw1-320-17 ThreadOS]$ 
   

5. Develop your program (MyShell.java) and save it in your local ThreadOS directory, and save the byte-compiled it in that same directory (Loader looks for byte-compliled Java class files only in the directory in which ThreadOS is Booted). To test your program, substitute MyShell for Shell in the sample sequence of command shown above (i.e., use l MyShell rather than l Shell after booting ThreadOS

Do not try to compile the ThreadOS source code. Some Java source files cannot be accessed (you will be writing your own Java code to substitute for the byte-compiled classes in future assignments.)

Hints:

• In order to read a command line, you should use SysLib.cin( StringBuffer s ) that returns a line of keyboard input to the StringBuffer s.
• Parsing and splitting a command line into words can be performed with the StringTokenizer class found in java.util. However, you may find it easier to use the SysLib.stringToArgs( String s ) utility function that is provided with ThreadOS.

5. What to Turn In

1. Part 1 must include:
   • processes.cpp: your C++ source code
   • processes.out: the output generated by your processes.cpp executable when passed sh, mingetty and gnome. For example, if you named your executable processes (e.g., by invoking the compiler with the '-o' option, g++ processes.cpp -o processes), your output should be include the appropriately labeled output of the following sequence of commands to the shell:

       ps -A | grep sh | wc -l
       processes sh
       ps -A | grep mingetty | wc -l
       processes mingetty
       ps -A | grep gnome | wc -l
       processes gnome
     

     To generage the output file, copy the shell script testprog1.sh into the directory containing your executable. If you have chosen to use a name other than processes for your executable, you will need to edit the PROG1EXE variable in that file. Run the script, redirecting its output to a file:

       ./testprog1.sh > processes.out
     

     Here is an example of what one might find in processes.out:

     Running ps -A | grep sh | wc -l
     19
     Running ./processes sh
     19
     Done
     Running ps -A | grep mingetty | wc -l
     6
     Running ./processes mingetty
     6
     Done
     Running ps -A | grep gnome | wc -l
     9
     Running ./processes gnome
     9
     Done
     

     Your mileage - or counts - may vary.
2. Part 2 must include:
   • MyShell.java: your Java source file.
   • MyShell.out: the output when testing running PingPong (using the parameters shown above) under MyShell in ThreadOS. To generate this output file, you can just manuall copy the output from your screen into a file.
3. Part 3 must include:
   • processes.txt, MyShell.txt: two documents describing what you learned from working on this assignment, with no more than one page for each of the two programs you wrote (use separate documents for each program). Among the aspects you should address in each document (i.e., for each program):
     • What were the most challenging aspects of the programming problem?
     • What mistakes did you make along the way, and how did you correct them?
     • What external resources (beyond CSS430 web pages) did you find most valuable?
     • If you were given another 2 weeks to work on this assignment, with the prospect of an additional 5 points of extra credit, how would you want to extend the program?

gradeguide1.txt is the grade guide that will be for used for assignment 1.

6. Note

CSS430 Operating Systems Assignments Home Page is the general guide to ensure that your assignments adhere to proper procedures. This may be modified in the near future, but will serve as a good approximation.

7. FAQ

A page with frequently asked questions (and answers) represents the collective wisdom of previous offerings of CSS430. This, too, may be updated in the near future, but should be consulted before posting questions on the General Discussion forum or emailing the professor.