by Paul Swanson
The design and implementation of ACM/OS (A Complete, Minimal Operating System) is constantly evolving out of the many discussions that SigOps has had since the beginning of the year. The OS is being developed to run on an i386 computer, using protected, 32-bit code. ACM/OS should not have any dependencies on existing software.
Our primary goals from the start have been modularity, simplicity, and raw speed; secondary goals include stability, security, and utility. Compatibility and portability are not considerations. With this model in mind, ACM/OS is free from most constraints that many commercial operating systems have to consider.
ACM/OS has adopted a microkernel1 design to accommodate the modularity and simplicity goals. Kernel services for ACM/OS are limited to interrupt allocation (for interrupt-driven devices), memory mapping (for memory mapped devices), basic memory allocation, task and thread setup, and memory sharing. The kernel does not include support for devices; while this would make development much easier, the end goals of modularity, security, and stability would be compromised.
Going a step further than most microkernels, ACM/OS does not include support for virtual memory2 and multitasking inside the kernel. Rather, paging and process scheduling can be viewed as interrupt-driven devices, driven off of the Page Fault and Timer (both of which map into the i386's interrupt space). However, the kernel was designed with these "extensions" in mind, making it feasible (and possible) to implement them later.
To facilitate raw speed, the only form of inter-process communication3 that will be supported is shared memory. Typically, message passing is included in an OS design as well, as its implementation and use tends to be much easier. However, in the interest of simplicity (and to encourage the use of shared memory), it is not supported in ACM/OS.
Security (and stability, in some respects) is implemented using the i386's hardware. The i386 knows 4 distinct protection levels, segments, and paging; segments and paging are typically used to ensure that a task stays within its memory boundaries. A typical approach to memory protection is to give each task a separate address space and utilize the paging hardware, which provides read/write and privilege protection on a page by page basis.
However, ACM/OS will use the i386's segments for memory protection, and save the paging hardware for virtual memory. Design and implementation of the OS will be more complex, but segments provide protection with a byte, instead of page, granularity (each page on the i386 is 4k bytes).
Many experimental operating systems are written in higher-level languages and ignore the possibility of getting anything useful done. The kernel of ACM/OS, on the other hand, will be completely written in i386 32-bit assembler, and its eventual utility is an ever-present concern in its design and implementation.
ACM/OS, while still a long way off from even usable, is not entirely vaporware. A significant portion of the kernel has been written and is being tested, and coding the paging and scheduling "devices" will start soon. SigOps will also start writing important and usable device drivers (such as keyboard, video, and disk) and other utilities (a command-line interface and program monitor will be first).
(1)macrokernel and microkernel - two opposing approaches to kernel design. The macrokernel approach lumps all hardware specific code into the kernel, whereas a microkernel is a simple, minimalistic approach. For example, UNIX was designed around a macrokernel, and VSTa was designed around a microkernel.
(2)virtual memory - using hardware (typically disk) other than memory transparently as memory. Swapping and paging are the mechanisms on a Virtual Memory Manager.
(3)inter-process communication (IPC) - the mechanism by which two processes pass data. Common IPC methods include message-passing, pipes, and shared memory.
SigOps: http://www.acm.uiuc.edu/sigops
VSTa: http://www.cen.uiuc.edu/~jeske/VSTa
UNIX: http://www.utexas.edu/cc/docs/ccug1.html