Mon Oct 10, 2016
The Operating System (OS) is the software that pulls together all of the hardware components, processors, disks, memory, etc., into a cohesive interface for all users and programs to use. The kernel is the name for the core of the operating system: the program that handles all the software-components controlling the hardware.
Things that the kernel implements are considered to be in kernel space. Everything else, outside of the kernel, is considered user space, and is where software that uses the kernel’s interface runs (managing files, graphical interface, games, word processing, etc).
Operating Systems come in all sizes: UNIX, SunOS, Windows, macOS are just a few of the popular platforms. One would argue that these few major forerunners are all that are really needed for the different niches to which they market.
However, times are constantly changing and new and improved ways to do things are always in high demand. This is especially apparent when put into perspective of the fast-paced advances in the technology on which operating systems operate. Even today there is still a need for smaller, faster, more stable operating systems to control faster, more complex, and more compact devices.
One popular type of operating system design is the monolithic kernel design used in older UNIX and Windows. However, monolithic kernels tend to be very big, complex, and just plain messy in some areas. This is mainly due to their nature of having so much functionality implemented inside kernel space. The structure within the operating system that is needed to handle all of this functionality must be complex and can be quite susceptible to unexpected modular interactions. The code required to successfully implement everything in a monolithic kernel system tends to be large and complex.
Since the early 1980s, a new way to model the kernel has developed: the client-server microkernel model; the design of Qubit falls into this category. This is a much simpler model where kernel space and user space are divided differently from the monolithic design. In this newer model, most of the traditional OS functionality occurs in programs that reside outside the kernel in user space.
Essentially, the kernel handles only processes and threads, their scheduling, message passing between them, as well as their memory management. Everything else, from device drivers to filesystems to networking, takes place outside the kernel. This was a pretty radical idea, but is now incorporated in operating systems such as MachOS, QNX, Minix, and Plan9. Yet, none of these microkernel designs separate the kernel and user spaces in the way that Qubit is designed, especially while maintaining POSIX compliance (POSIX is a standard for compatibility between UNIX-like operating systems).
Because of the close relation Qubit has to operating systems QNX and Plan9, I will discuss them a lot in this article series. One of the uses of the microkernel design is as an embedded operating system: an embedded OS is hidden from users so they only speak to the OS via some nice interface. A microkernel is a good idea for this application because the kernel is small due to its simplicity, and the only things needed in user space are proprietary to the device.
Enter Qubit Operating System.