How Does the Linux Kernel Work? The Linux Kernel Anatomy Explained
The Linux kernel is like a bridge that enables computing communication between applications and hardware and manages the system’s resources. Linus Torvalds developed the Linux kernel with C and Assembly and thus, he succeeded in creating a lightweight and portable core that was released to the public as open source.
You can see the Linux kernel in many different sectors such as space, computers, smart watches, mobile phones, robotics, and health. But have you ever wondered how does the Linux kernel work under the hood?
Hardware Usage on Linux
The Linux kernel, first of all, controls which hardware will run and in what way when you turn on your computer. In addition, control of high-end software is possible thanks to the programming interface. To give an example of these controls, it is possible for you to see information about the hardware installed in the slots on your motherboard and benefit from this detailed information.
Also, this programming interface provides an abstraction layer. For example, if you want to have a video conversation with your friends, you’ll need a webcam. The abstraction layer makes it possible for the software you use to employ this webcam regardless of its make and model. The software here can only use the interface that exists for Linux. The Linux kernel translates this interface’s function calls into actual hardware commands that the webcam needs.
Using the /proc and /sys virtual file systems, the Linux kernel can export detailed information about the hardware it detects. Below you can see a few tools used for this and which devices and cards they export:
- lspci: For PCI devices
- lsusb: For USB devices
- lspcmcia: For PCMCIA cards
As you can see, the Linux distribution in the screenshot above runs on VirtualBox. However, you have the opportunity to see a lot of information such as VGA, USB controller, bridges, and SATA controller.
You can also use the -v parameter to get much more detailed information.
In the Linux kernel, applications usually access devices through special files that exist in the /dev directory. These special files represent disk drives and other physical devices. Files such as /dev/hda, /dev/sdc, /dev/sdc3, /dev/input/mouse0 and dev/snd/* are examples of these special files.
Linux File System Management
File systems are one of the most notable components of the Linux kernel. The file system of Linux is one of its greatest benefits. All of the files on a Linux system gather into a single branch. Users may thus utilize this hierarchy to reach their desired places.
The starting point of this hierarchy is the root directory (/). Other subdirectories are under the root directory. The most-used subdirectory under / is the /home directory. This subdirectory contains other subdirectories and each directory has files that store the actual data.
For example, you can think of a text file on your desktop. If you create a text file called helloworld.txt on your desktop, you can refer to it as /home/muo/Desktop/helloworld.txt. The example of /muo here will of course vary. Because this subdirectory name depends on your current user’s name. With this naming system, the Linux kernel translates between actual and physical storage that exists on a disk.
Also, the Linux kernel can integrate data from several disks. This is where the mounting system comes into play. It uses one of the disks in the root system and mounts the others to existing directories in the hierarchy. Other disks are then placed under mount points. This allows users to store the /home directory on a second hard disk that also contains other subdirectories.
When you mount a disk to the /home directory, you can access these directories from normal locations. Thus, paths such as /home/muo/Desktop/helloworld.txt continue to work.
You can see the mount points between the files on your system with the findmnt -A command.
With many file system formats, you can physically store data on disks. The most widely known on Linux are the ext2, ext3, and ext4 file system formats. However, there are many other file system formats. In any case, you’ve to format the file system before mounting it. You can use commands like mkfs.ext3 (mkfs stands for make file system and ext3 is the file system) for this.
These commands accept the device file path you want to format as a parameter. It is a destructive operation and you should use it with caution if you do not want to wipe or reset a filesystem.
Apart from these, there are also network file systems such as NFS that the Linux kernel uses. NFS is a network file system where data is not stored on a local disk. With NFS, data goes over the network to a server that stores the data. Since the data will be on a server, users don’t have to constantly deal with it. They can also use the traditional hierarchical file system of Linux as usual.
Shared Function Operations
All of the software in the Linux system have common functions. This is why these functions are central in the Linux kernel. For example, when opening a file, you can open it only with the file name, without knowing where the file is physically stored, and what functions and operations it will use. All of these functions are already present in the kernel.
You can store your file on the hard disk, split it between several hard disks, or even keep it on a remote server. Shared file communication functions are important in such cases. Applications exchange data regardless of how the data is moved. Shared communication functions are there to make these data exchanges. This move can be over wireless networks or even a fixed phone line.
Process Management in Linux
An active instance of a program operating on data or information in memory is known as a process. The task of the Linux kernel is to generate and keep track of these memory regions. The kernel allocates memory for a running program and loads the executable code into memory from the file system. Immediately after, the kernel runs the code.
The Linux kernel supports multitasking. It is capable of running numerous processes at the same time. There is only one transaction in any given time frame, though. However, the Linux kernel splits time into little chunks and as a result, each procedure takes place sequentially.
Because these little time segments are in millisecond increments, they are only active at specific times and stay idle the rest of the time. The Linux kernel’s job here is to maximize performance by running multiple processes at once.
If the time slots are too long, the running application may not be as responsive as you would like. If timeframes are too short, there may be problems with task changes. Depending on the priority of the process, the time frame interval required here will vary. You may have heard of high-priority processes and low-priority processes before. This is one of the functions that the Linux kernel controls.
This explanation is not always correct. The real limitation is that there can only be one worker process per processor core at a time. Multiprocessor systems allow several processes to run in parallel. A basic system almost always has dozens of running processes.
Access Rights in Linux
As with other operating systems, you can create many users on a Linux system. In such cases, there is a rights management system that supports individual users and groups. This is where file and user permissions come into play.
The Linux kernel manages the data and checks the necessary permissions for each process. For example, if you try to open a file, the kernel has to check the process ID against access permissions. If the kernel checks and sees that you have permissions, it will open the file.
The Linux Kernel Controls Everything
As you can see, the Linux kernel oversees everything from your file security to creating users and downloading files from the internet. Everything is in a certain order. Every user has rights. The Linux kernel manages processes and time slots for peak performance.
Moreover, the file system, which is one of the biggest features that distinguish the Linux kernel from other operating systems, is very important. Linux is not a hidden box. On the contrary, all files and source codes are accessible. To better understand the practical and powerful nature of the Linux kernel, you can examine the Linux directory system hierarchy.