| In contrast to current operating-system developments tending toward a microkernel architecture, the Linux operating system is based on a monolithic kernel. In microkernel architectures, such as the Mach kernel [Tane95] or the Windows NT kernel, the operating system kernel represents merely the absolute necessary minimum of functionality. Good examples are interprocess communication (IPC) and memory management (MM). Building on the microkernel, the remaining functionality of the operating system is moved to independent processes or threads, running outside the operating system kernel. They use a defined interface to communicate with the microkernel, generally via system calls. In monolithic kernels, to which the Linux kernel belongs, the entire functionality is concentrated in one (large) kernel. In addition to the basic mechanisms known from microkernels, the Linux operating system kernel also includes device drivers, file system drivers, most instances of the network protocols, and much more. (See Figure 2-1.) Compared to microkernel architectures, the use of a monolithic kernel has both benefits and drawbacks, as we will see below. The benefits include the fact that the entire functionality of the operating system is concentrated in the kernel, allowing the system to work more efficiently. You can access resources directly from within the kernel, so costly system calls and context changes are needed less frequently. One major drawback is that the source code for the operating system kernel can quickly become rather complex, even messy, because no defined interfaces are required within the kernel. In addition, the development of new drivers can be made more difficult by the lack of an interface definition. For example, if you install a new device, you have to retranslate the entire kernel to ensure that this device driver can be compiled with the kernel, a need avoided by microkernel architectures. That Linux is based on a monolithic operating-system kernel is due to historical reasons. A system that had not been planned to become such a big project, at the beginning, has continually been developed further, so that it became impossible, at some point in time, to migrate to a microkernel architecture. However, since Version 2.0, Linux has made a step towards microkernel architectures. More specifically, the possibility was created of moving certain functionalities into modules, which are loaded into the kernel at runtime, from which they can be removed again. This removed an important drawback of monolithic kernels and opened the way to loading drivers or other functionalities at runtime. In addition, modularization offers another benefit: Uniform interfaces are defined. This feature had previously been characteristic only of microkernel architectures. Linux has a number of such interfaces, allowing the kernel to be dynamically enhanced by a number of functionalities. This very flexibility and openness of its interfaces is one of the most important benefits of Linux. Table 2-1 shows a selection of the most important interfaces, including the pertinent methods used to register and unregister functionalities. Table 2-1. Interfaces in the Linux kernel to embed new functionalities.Functionality | Functions for Dynamic Registration |
|---|
Character devices | (un)register_chrdev( ) | Block devices | (un)register_blkdev( ) | Binary formats | (un)register_binfmt( ) | File systems | (un)register_filesystem( ) | Serial interfaces | (un)register_serial( ) | Network adapters | (un)register_netdev( ) | Layer-3 protocols | dev_add_pack( ), dev_remove_pack( ) | Layer-4 protocols (TCP/IP) | inet_add_protocol( ), inet_del_protocol( ) | Console drivers | tty_(un)register_driver( ) | Symbol tables | (un)register_symtab( ) | Modules | init_module( ), cleanup_module( ) |
Despite its modularization, Linux has preserved a major benefit of monolithic kernels: All functions implemented in modules run in protected kernel mode, which means that they do not require any context change when called from within the kernel. This can be seen as a clever combination of the benefits from both main operating-system architectures. The following sections briefly introduce the kernel components, to better explain the Linux network architecture. You should know the structure and properties of these components to understand how the Linux network architecture works. We refer again to [RuCo01, BBDK+01, BoCe00] for an in-depth study of the Linux kernel components described below. |
