on 06-Jul-2021 (Tue)

The kernel is a computer program at the core of a computer's operating system and has complete control over everything in the system.^[1]

The critical code of the kernel is usually loaded into a separate area of memory, which is protected from access by application software or other, less critical parts of the operating system. The kernel performs its tasks, such as running processes, managing hardware devices such as the hard disk, and handling interrupts, in this protected kernel space. In contrast, application programs like browsers, word processors, or audio or video players use a separate area of memory, user space. This separation prevents user data and kernel data from interfering with each other and causing instability and slowness,^[1] as well as preventing malfunctioning applications from affecting other applications or crashing the entire operating system.

There are different kernel architecture designs. Monolithic kernels run entirely in a single address space with the CPU executing in supervisor mode, mainly for speed.

Random-access memory (RAM) is used to store both program instructions and data.^{[note 1]}

Key aspects necessary in resource management are defining the execution domain (address space) and the protection mechanism used to mediate access to the resources within a domain.^[5] Kernels also provide methods for synchronization and inter-process communication (IPC). These implementations may be within the kernel itself or the kernel can also rely on other processes it is running. Although the kernel must provide IPC in order to provide access to the facilities provided by each other, kernels must also provide running programs with a method to make requests to access these facilities. The kernel is also responsible for context switching between processes or threads.

An efficient and simple way to provide hardware support of capabilities is to delegate to the memory management unit (MMU) the responsibility of checking access-rights for every memory access, a mechanism called capability-based addressing.^[11] Most commercial computer architectures lack such MMU support for capabilities.

The principle of separation of mechanism and policy is the substantial difference between the philosophy of micro and monolithic kernels.^[25][26] Here a mechanism is the support that allows the implementation of many different policies, while a policy is a particular "mode of operation". Example:

• Mechanism: User login attempts are routed to an authorization server
• Policy: Authorization server requires a password which is verified against stored passwords in a database

In minimal microkernel just some very basic policies are included,^[26] and its mechanisms allows what is running on top of the kernel (the remaining part of the operating system and the other applications) to decide which policies to adopt (as memory management, high level process scheduling, file system management, etc.).^[5][22] A monolithic kernel instead tends to include many policies, therefore restricting the rest of the system to rely on them.

The idea of a kernel where I/O devices are handled uniformly with other processes, as parallel co-operating processes, was first proposed and implemented by Brinch Hansen (although similar ideas were suggested in 1967^[23][24]). In Hansen's description of this, the "common" processes are called internal processes, while the I/O devices are called external processes.^[22]

In a monolithic kernel, all OS services run along with the main kernel thread, thus also residing in the same memory area.

• Coding in kernel can be challenging, in part because one cannot use common libraries (like a full-featured libc), and because one needs to use a source-level debugger like gdb. Rebooting the computer is often required. This is not just a problem of convenience to the developers. When debugging is harder, and as difficulties become stronger, it becomes more likely that code will be "buggier".