CS3250 Fall 2015 Lab 7: Final Project

Released November 3, 2015
Project proposals due by email, Monday, Nov 16, 2015, 3:00 PM
Code due: Monday, December 21, 2015, 9:00 PM
Project demos: [TENTATIVE] Friday, December 18 and Tuesday, December 22, 2015

Lab 7: Final JOS project

Introduction

For the final project, you will work on your own or in a team of two. The project can involve your JOS, or you can do something else!

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 group.

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 policies.

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 code.

You will have to demonstrate your final project for the course staff in person. The demos will be on the dates specified at the top of this page; there will be an electronic signup.

Project ideas

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 large scope!

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.
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 with swapping.
Implement mmap() of files for JOS.
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 read copy 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 lock-free reads.
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.