Due Dates

Submission instructions for all projects, please replace '0' with the appropriate number:

   1. In the 'pintos/src' directory, issue the command 

   tar cvzf project0-yourpid.tgz *

   Note: the "pintos" directory is wherever you keep a working copy of Pintos.  
   It does not need to be named "pintos".

   2. Upload project0-yourpid.tgz using the submission web page.
   To access the submission page, log on with your CS SLO account 
   (that's the same account you use to log on to rlogin.cs.vt.edu).

   Alternatively, you may directly submit from the command line 
   using the command
   submit.pl p0 project0-yourpid.tgz

   This command is found in ~cs3204/bin (even though you will 
   submit to the CS 5204 directory).

Note: Please issue a "make clean" command before submitting projects 1 through 4. The submission script will not accept files larger than 500,000 bytes.

Using git

We will be using gitlab this semester to allow git repository management in an honor code compliant way. The use of a git repository hosted on git.cs.vt.edu is required for these projects, even if you work by yourselves. This gitlab instance allows authentication with your SLO id. You need to upload an ssh key before you can start cloning.

Every group should start by forking gback/pintos-2015. Then, use gitlab's facilities to create a group and give your team members access to your fork. Each team member should be able to directly clone your fork and pull/push from it. Make sure to make your forked repository private (it will be public initially after the fork).

Coding Standards

The following portions of the documentation are relevant with respect to coding standards in as much as they affect your grade:

• 1.2.2 Design
• C. Coding Standards

Read them carefully, in particular Section 1.2.2.2 Source Code.

Bracketed notations in Pintos source code comments can be looked up in the Bibliography.

Later

how to boot Pintos on your own PC

Open Ended Projects

1. Choice 1: Pintos-SMP. As provided, Pintos cannot support multiprocessors or multicore machines. The goal of this project is to make Pintos capable of running on SMP processors! This involves:
   • Support for reading MPP tables and support for LAPIC. (Use existing code from JOS)
   • Adding support fire up a second CPU, including boot code. (Use existing code from JOS)
   • Spinlock implementation
   • Removal of uniprocessor assumptions from code (i.e., changing irq_disable() to use spinlocks()
   • Simple MP scheduler.

   Success Criteria: successfully boot a second CPU and demonstrate that both CPUs are used to schedule processes in some of the concurrent p2 workloads (syn-read, syn-write). Note that this project does not include adding support for multi-threading for user processes, which would be optional. Also optional is TLB shootdown.

2. Choice 2: Pintos-Networking. As provided, there is not support for accessing the network. The goal of this project is to add support for TCP/IP networking to Pintos. This involves:
   • Implement an interrupt-driven driver for E1000 card. The E1000 is a complex card, but only a subset of features is needed to get working.
   • Adapt the lwIP stack This is a generic IP stack targeted for embeddability.
   • Implement support for sockets at the file descriptor layer.
   • Implement simple telnetd to log into Pintos via telnet
   • Implement simple 'curl'-like program to fetch web pages
   • Implement simple web server to server web pages from Pintos

   Success Criteria: Run at least 1 substantial client (e.g. curl) and 1 substantial server program (e.g. telnetd or httpd) on Pintos and interact with it via a common web browser or command line tool. The programs themselves do not need to be full-feature, mini-versions are fine.

3. Choice 3: Pintos-2-Unix. As provided, the projects make several drastically simplifying deviations from true Unix: there is no fork(), file descriptors are not shared across processes, there are no pipes, there is no malloc(), and several other important system calls required to support more advanced user applications are missing. The goal of this project is to implement a substantial subset of Unix so that more advanced applications can be run. This involves:
   • Implement fork() traditional exec(), including the ability to inherit file descriptors, related system calls such as dup()/dup2().
   • Implement pipes.
   • Implement sbrk() and user-level malloc() (can reuse existing malloc())
   • Implement or port a shell that supports I/O redirection and pipes

   Success Criteria: Be able to successfully demonstrate your shell. Optionally, a more complex application can be ported, e.g. a Lua interpreter.