CS3250 Fall 2014 Lab 7: Final Project
Released November 2, 2014
Project proposals due by email, Monday, Nov 17, 2014, 3:00 PM
Code due, Friday, December 12, 2014, 9:00 PM
Project demos: afternoons of December 15 and 16, 2014
Lab 7: Final JOS project
For the final project, you will work in a team of one, two, or three, on
a project of your choice that involves your JOS.
The goal is to have fun and explore more advanced topics; you do not
really have the time to do novel research.
You will be evaluated on how much you got working, how elegant your
design is, how well you can explain it, and how interesting and creative
your solution is. We realize that time is limited; we don't expect you
to re-write Linux by the end of the semester. Try to make sure your
goals are reasonable; perhaps set a minimum goal that's definitely
achievable and a more ambitious goal if things go well.
Requirements and deliverables
Email a proposal to the course staff email alias (not the
course staff separately) at the deadline given above. The proposal must
include: (1) The names of your group members; (2) What you want to do
(the problem and your approach); and (3) What you are expecting to
present (a list of deliverables). Please keep it short (no more than
several paragraphs). If you wish, feel free to get in touch before this
date; we can provide feedback on project ideas either by email or in
person. The project scope should scale with the number of people in the
Develop your final project code on a new branch; name it
lab7. If you are working in a group, you will need to decide
whose source code you will use as a starting point for your group
project. Furthermore, you may wish to use git to share project code
between group members. If you use github, do not post your JOS
publicly; doing so is grounds for disciplinary action, per the course
To complete the assignment, you will turn in your code as usual (make
sure this code is on the lab7 branch). Include with your source code (a)
a brief write-up about what you did and how, and (b) a step-by-step
HOWTO or README stating what commands we should run to execute your
You will have to demonstrate your final project for the course staff
in person. The demos will be in the afternoons of December 15 and 16;
there will be an electronic signup.
Here is a list of ideas to get you started thinking. But, you should
feel free to pursue your own ideas. Some of the ideas are starting
points and by themselves not of the required scope; others are of too
- Build a virtual machine monitor that can run multiple guests (for
example, multiple instances of JOS), using
x86 VM support.
- Do something useful with the x86 Trusted
Execution Technology. For example, run applications without
having to trust the kernel. Here
is a recent paper on this topic.
- Do something useful with the hardware protection of Intel SGX. Here
is a recent paper using Intel SGX.
- Make the JOS file system support writing, file creation, logging for
durability, etc., perhaps taking ideas from Linux EXT3.
- Use file system ideas from
ZFS, or another advanced file system.
- Add snapshots to a file system, so that a user can look at
the file system as it appeared at various points in the past.
You'll probably want to use some kind of copy-on-write for disk
storage to keep space consumption down.
- Implement FlexSC in JOS.
- Develop a scalable implementation of JOS, using ideas and insights
from the Scalable Commutativity Rule paper.
- Build a
distributed shared memory (DSM) system, so that you can run
multi-threaded shared memory parallel programs on a cluster of
machines, using paging to give the appearance of real shared memory.
When a thread tries to access a page that's on another machine, the
page fault will give the DSM system a chance to fetch the page over
the network from whatever machine currently stores.
- Allow processes to migrate from one machine to another over the
network. You'll need to do something about the various pieces of a process's
state, but since much state in JOS is in user-space it may be easier than
process migration on Linux.
- Implement paging to disk
in JOS, so that processes can be bigger than RAM. Extend your pager
- Implement mmap() of files
- Use xfi to
sandbox code within a process.
- Modify JOS to have kernel-supported threads inside processes.
- Use fine-grained locking or lock-free concurrency in JOS in the kernel or
in the file server (after making it multithreaded). The Linux kernel uses
update to be able to perform read operations without holding locks.
Explore RCU by implementing it in JOS use it to support a name cache with
- Implement ideas from the Exokernel papers, for example the packet filter.
- Make JOS have soft real-time behavior. You will have to identify some
application for which this is useful.
- Make JOS run on 64-bit CPUs. This includes redoing the virtual
memory system to use 4-level page tables. See reference page
for some documentation.
- Port JOS to a different microprocessor. The osdev wiki may be helpful.
- A window system for JOS, including graphics driver and mouse. See
reference page for some documentation. sqrt(x) is
an example JOS window system (and writeup).
- Implement Dune
to export privileged hardware instructions to user-space applications in JOS.
- Intel recently announced transactional
memory support for its upcoming processors. Implement support for
Intel's TSX in the QEMU emulator. A follow-on project would be to explore
the use of Intel TSX primitives in writing concurrent software, such as
extending the JOS kernel to use transactional memory.
- Write a user-level debugger; add strace-like functionality;
hardware register profiling (e.g. Oprofile); call-traces
- Binary emulation for (static) Linux executables
Before your demo and after you are done,
make handin. Be sure to include the required
documentation, described above.