Introduction

Every summer, Google sponsors a Summer of Code project in which students are paid to work on open source projects. We applied and were accepted. If you are interested in working on our project, read on.

MINIX 3 is a small, modular, multiserver operating system aimed at being highly reliable, fault tolerant and self healing. Only about 5000 lines of code run in kernel mode. The rest runs as a collection of user processes, mostly separate processes for each device driver and server. If a driver fails, it is automatically replaced by a fresh copy, without user intervention (or even knowledge) and without affecting running programs. Few other systems can survive fatal errors in some critical system components without even missing a beat. The goal of reliable systems will have been achieved when no computer has a RESET button and no user has ever experienced a crash and does not know anyone personally who has ever experienced a crash.

MINIX 3 supports the POSIX interface and about 500 of the standard UNIX programs have been ported to it, including X11, gcc, perl, python, ghostview, mplayer, the GNU core utilities, and many more. There is also a a simple GUI (EDE). Nevertheless there is much more to do.

We would like to continue the development to demonstrate that building a system out of small replaceable components leads to a highly robust design that is far easier to understand and maintain than systems with millions of lines of kernel code. While good performance is important, it is hardly the overriding criteria it once was. If most ordinary users were given a choice between the fastest possible system and one that was 10-20% slower but never crashed, we believe a large number of users would choose the latter. For many companies (e.g., banks, e-commerce sites), having their systems run 24/7 with no failures ever is a top priority.

Embedded systems are another area where high reliability is important. People do not expect their TV sets, digital cameras, and camcorders to exhibit blue screens, except when images of the sky are being shown.

In short, we are trying to build a modular, reliable (and secure) operating system out of small components that can be replaced on the fly and we would like you to help. Here is a paper describing MINIX 3 and its architecture in more detail. More papers are listed on the DOCUMENTATION page.

As an aside, MINIX 3 is not your grandfather's MINIX. It started out as an educational system but has evolved greatly since then into a tight system with a focus on high reliability (and security). As open-source projects go, it is quite popular. We have had over 1.3 million visitors to the new Website (which has been up about 3 years). Currently about 12,000 people a month download the CD-ROM image file to install it.

Last Year's Star

We participated in the Google Summer of Code in 2008 and would like to mention one project that stood out: the Software RAID project. The goal of this project was enhance MINIX 3 with support for filter drivers that could be transparently inserted between the file system and block-device driver. In particular, we requested the student to implement a server process that checksummed all data and could mirror data to a backup partition. In this way, it became possible to detect and recover from data corruption due to bit rot on disk or a buggy driver. The student not only implemented the functionality, but also measured the performance of the resulting framework. The project was highly successful and even resulted in a publication that was coauthored by the student and has recently been submitted to an international conference.

About You

The project ideas below range from straightforward to challenging. All require you to be an experienced C programmer. For some of them it would be helpful if you have already read the MINIX book for example, in a course you took at your university. Given the difficulty of these projects, we expect you to work full time all summer on them. That means not having a job and not going to school.

Since this is an open-source project, many other people will study the code later. It is therefore essential that you are someone who takes pride in his or her work and wants to produce code that is clean, efficient, elegant, and well documented so that other people will marvel at its beauty. Just hacking it together quickly so it mostly works some of the time doesn't cut it. We want people to admire the code, even to envy your ability to write truly great code.

If you are an experienced C programmer who knows something about operating systems and can write clear, well-documented code check out the ideas below and then our our application template. Please answer all these questions in your application.

If you want to impress us, download and install MINIX 3 and all the application programs on the CD-ROM image you have downloaded and all the software on the Website. Then port or write some program we don't have that you like to MINIX 3 and package it in the packman format and send it here. Or write a relevant article for the MINIX 3 Wiki. Or do something else that shows you have some skills and you have backed your application with some real effort.

You are encouraged to interact with us before applying via the Google Newsgroup. This will help your application and help you pick some small project to do in advance to show us you are serious, as mentioned above.

During the project we want you to interact with our community via the Google Newsgroup. Also, you will get your own page on the Wiki and will be expected to use it as a blog posting your progress, at least weekly, but also when you reach a milestone.

Ideas

Here are some ideas, but we are open to suggestions for other projects. To do the kernel projects, you must be an experienced kernel hacker. To do the drivers, you need solid programming experience and at least some exposure to kernel hacking. The third group does not require kernel hacking experience.

Accepted students get $500 right off the bat. If you pass the "midterm" you get $2000 from Google and a rare MINIX 3 T-shirt from us. Upon successful completion of the project, you get another $2000 from Google.

MINIX 3 is open source and uses the BSD license. By applying, you agree that we can distribute your code under this license. However, you also retain your right to reuse it as you wish.

Kernel Projects

• Using Virtual Memory. We have recently implemented virtual memory, but it isn't used for much yet. In this project you could build on it, for example, providing support for the POSIX model of shared memory. This project is not for beginners.
  
  
• Support Floating-Point Hardware.We don't currently support the use of the floating-point hardware. Instead we use software floating point. To support the hardware, we have to save and restore the registers and do some other things. This project is about supporting the floating-point hardware. To do this, you need extensive kernel hacking experience.
  
  

Device Driver Projects

• NDIS wrapper. All open source operating systems have a problem getting drivers written. One approach is to take binary drivers from other operating systems and wrap them to make them usable in the target system. This has been done for drivers for wireless cards for Linux but not for MINIX 3. In this project the student will do the same thing for MINIX 3. This project should not be attempted unless you have extensive experience with Linux, BSD, or Windows drivers.
  
  
• Implement AHCI Commands. MINIX 3 supports IDE disks but not AHCI disks, so when installing MINIX 3 on a new machine you often have to change the BIOS settings to use IDE emulation instead of the native AHCI interface. We would like you to modify the disk driver to use the native AHCI command set instead of the IDE set. Experience with I/O devices and their drivers is needed for this project.
  
  
• Porting or writing device drivers. We need all kinds of device drivers. Almost anything you can think of would be useful. It might be possible to port drivers from other operating systems, but our experience is that it is extremely difficult because each of our drivers runs as a separate user process, outside the kernel. It is usually best to study an existing driver to see how it works, but then write a new one from scratch. Our highest priority is a gigabit Ethernet driver (e.g., Intel Pro/1000). You should have some background in this area to do this project.
  
  
• Handle for remote debugger. MINIX 3 is moving into the embedded systems world. This means we need to debug it running on machines with no display and no keyboard. What we need is a small module that can take commands over the serial port from a remote debugger, such as gdb and execute them. Your job is to write this code.
  
  

Other Projects

None of the following projects require any kernel hacking experience, but you still need to be a good C programmer.

• Writing /proc and /dev File Systems. This project consists of two closely related subprojects. First, MINIX 3 does not yet have a /proc file system that provides information about processes. In this project, you will have to implement a new file-system server that populates the /proc directory with per-process information, allowing 'ps' to query it. Other functionality could include, for example, /proc/meminfo for memory usage statistics and /proc/modules for a list of servers and drivers in the system. Second, MINIX 3 currently allocates all device nodes statically on the root device. A better solution would be to use a /dev file system where device drivers can dynamically register their devices. We would like you to implement a new /dev file-system server that provides an interface for the drivers and modify the system to use it.
  
  
  
• Performance tuning. We have made little effort to measure the performance of the system and tune it. We have some tools though, and porting and using the BSD Pmc tools might also be possible. This project requires you to measure the performance and find bottlenecks and, if possible, fix them. You should start out by finding and porting existing benchmarks used on other systems and writing scripts to run them and collect the results automatically.
  
  
• Porting the BSD Utilities to MINIX 3. We have hundreds of standard utility programs we wrote ourselves and which were contributed by MINIX users. We also have the GNU utilities. However, some people prefer the BSD versions of the utilities, which we don't have. Your job is to port them.
  
  
• Stress Testing MINIX 3. People have written various stress test suites for other systems that push the system very hard and try to make it collapse. Your job here is to port some of them to MINIX 3 and write scripts to automate the stress testing. If you manage to crash MINIX 3, then we would like you to figure out how it happened.
  
  
• Porting application programs to MINIX 3. We have over 500 application programs, but more are welcome. Porting Linux or FreeBSD software takes some effort because although we have cc and gcc and are POSIX conformant, we don't support all the Linux or FreeBSD system calls and the header tree is organized differently, etc. The only caveat is that we already have all the easy stuff. The things left are bigger and more complicated.
  
  Functionally useful programs that are small and lightweight are especially valued, particularly for (mobile) resource-constrained environments, but good desktop programs, frameworks, and libraries are also useful. Some examples are:

  The Dillo Web browser The Lighttpd Web server The Qt software framework Networking programs like Tcpdump, Traceroute, Netcat, nslookup, and so on etc.

  We are open to suggestions for programs to port. In some cases, the ports may be easy enough that you should do multiple ports.
  
  
• Enhancing Portability. Trying to run MINIX 3 commands on Linux or FreeBSD (for comparison purposes) turns out to be surprisingly difficult despite their being written in ANSI Standard C and being POSIX conformant. The problems are often related to the structure and content of header files (e.g., precisely what is defined in types.h) and how Makefiles are organized. In this project you will work on the MINIX 3 headers and Makefiles of the application programs to make it easy to use gcc and to move MINIX 3 software simply to Linux or FreeBSD.
  
  

We are open to suggestions for alternative projects. You might first look at the Wishlist on the MINIX 3 Wiki.

Resources

There are several pages available with helpful information. These include:

• Advice for students
• GSoC FAQ
• Timeline
• How to apply
• How to use the application program

Keep in mind that the deadline for applications is April 3. No exceptions.

Conclusion

Thanks for your interest. But even if you do not want to participate in the Google Summer of Code, give MINIX 3 a try. You might be surprised. For example, it can compile itself, kernel, all servers, drivers, etc.--125 compilations--in about 6 seconds on a modern PC. And if you want to help on the project outside the framework of the Google Summer of Code, you are most welcome. We have a Google newsgroup: Google newsgroup where your input is welcomed. We also recently started a MINIX 3 Wiki so users can help document the system.

Thanks for reading so far. We hope you will apply to GSoC to help us. Again, here is our application template.