is done through device drivers . The pilots are small lightweight software dedicated to a given material that allows to communicate this material. Due to the very large number of access to certain materials (hard disks for example), some drivers are very solicited. They are usually included in kernel security check failure space and communicate with user space via system calls.
Indeed, as seen in the previous paragraph, a system call is expensive: it requires at least two context changes. In order to reduce the number of system calls made to access a device, basic interactions with the device are made in the kernel security check failure space. Programs use these devices through a limited number of system calls.
However, regardless of the architecture, many slow devices (some digital cameras, tools on serial link, etc.) are / can be controlled from the user space, the kernel security check failure intervening to a minimum.
There are hardware abstraction layers ( HALs ) that have the same interface to the user space and thus simplify the work of application developers. In UNIX systems , the abstraction used is the file system: the open , close , read and write primitives are presented to the user space to handle all kinds of devices. In this case we speak of a synthetic file system .
Different types of nuclei
There are all kinds of nuclei, more or less specialized. Architecture-specific kernels, often monotasks, other generalists and often multi-tasking and multi-user. All these nuclei can be divided into two opposite approaches of software architectures: monolithic nuclei and micro-nuclei.
Monolithic nuclei, of old design, are generally considered obsolete because they are difficult to maintain and less “clean”. The Linux kernel was already described as obsolete by Andrew Tanenbaum 6 , 7 , from its creation in 1991. He did not believe, at the time, to be able to make a monolithic nucleus multiplatform and modular. The implementation of micro-nuclei, which consists of moving most of the functions of the nucleus to the user space, is very interesting in theory but proves difficult in practice. Thus the performances of the Linux kernel security check failure (monolithic) are superior to those of its competitors (general nuclei with micro-cores), without counting that it was finally carried on many platforms and that it is modular since 1995 .
For these reasons of performance, general systems based on micro-kernel security check failure technology, such as Windows and Mac OS X, do not have a “real” enriched micro-kernel. They use a hybrid micro-kernel: some features that should exist in the form of mini-servers are found integrated in their micro-kernel, using the same address space. For Mac OS X, this forms XNU : the BSD monolithic kernel operates as a Mach service and the latter includes BSD code in its own address space to reduce latencies.
Thus, the two approaches to core architectures, the micro-cores and the monolithic cores, considered to be diametrically different in terms of design, come together almost in practice by the hybrid micro-nuclei and the modular monolithic nuclei.
Non-modular monolithic kernels
Some operating systems, such as older versions of Linux , some BSD, or some old Unix have a monolithic kernel. That is, all system and driver functions are grouped into a single block of code and a single binary block generated at compile time .
The simplicity of their concept but also their excellent speed of execution, the monolithic cores were the first to be developed and implemented. However, as they developed, the code of these monolithic nuclei increased in size and it proved difficult to maintain them. Support by monolithic architectures of hot loadingsor dynamic implies an increase in the number of hardware drivers compiled in the kernel security check failure , and hence an increase in the size of the memory footprint of the kernels. This quickly becomes unacceptable. Multiple dependencies created between different kernel functions prevented replay and code understanding. The evolution of the code was done in parallel with the evolution of the material, and portage problems were then highlighted on the monolithic nuclei.
In fact the problems of code portability have proved over time independent of the problem of the technology of the cores. As proof, NetBSD is a monolithic kernel security check failure and is focused on a very large number of architectures, while kernels such as GNU Mach or NT use micro-kernels supposed to facilitate the porting but