System Memory Management

One of the primary functions of the operating system kernel is memory management. Memory management is the ability to control how programs and utilities run within the memory restrictions of the system. Not only does the kernel manage the physical memory available on the server, it can also create and manage virtual memory, or memory that doesn’t actually exist but is created on the hard drive and treated as real memory.

It does this by using space on the hard disk called the swap space. The kernel swaps the contents of virtual memory locations back and forth from the swap space to the actual physical memory. This allows applications to think there is more memory available than what physically exists (as shown in FIGURE 1-2).

The memory locations are grouped into blocks called pages. The kernel locates each page of memory either in the physical memory or the swap space. The kernel then maintains a table of the memory pages that indicates which pages are in physical memory and which pages are swapped out to disk.

The kernel keeps track of which memory pages are in use and automatically copies memory pages that have not been accessed for a period of time to the swap space area (called swapping out)—even if there’s other memory available. When a program wants to access a memory page that has been swapped out, the kernel must make room for it in physical memory by swapping out a different memory page and swapping in the required page from the swap space. Obviously, this process takes time and can slow down a running process. The process of swapping out memory pages for running applications continues for as long as the Linux system is running.

You can see the current status of the virtual memory on your Linux system by viewing the special /proc/meminfo file. Here’s an example of a sample /proc/meminfo entry:

Description

The MemTotal and MemFree lines show that this Linux server has 20 GB of ­physical memory and that there is about 14 GB not currently being used (free). The output also shows that there is about 2 GB of swap space memory available on this system. The kernel continually updates the meminfo file to show exactly what’s going on in memory at that moment in time, so you can always get a picture of what’s happening on the system.

Software Program Management

With the Linux operating system, a running program is called a process. A process can run in the foreground, displaying output on a display, or it can run in the background, behind the scenes. The kernel controls how the Linux system manages all the processes running on the system.

The kernel creates the first process, called the init process, to start all other processes on the system. When the kernel starts, it loads the init process into virtual memory. As the kernel starts each additional process, it gives it a unique area in virtual memory to store the data and code that the process uses.

There are a few different types of init process implementations available in Linux, but these days, two are most popular:

• SysVinit—The SysVinit initialization method was the original method used by Linux and was based on the Unix System V initialization method. Though it is not used by many Linux distributions these days, you still may find it around in older Linux distributions

• Systemd—The systemd initialization method was created in 2010 and has become the most popular initialization and process management system used by Linux distributions.

Hardware Management

Still another of the kernel’s responsibilities is hardware management. Any device that the Linux system must communicate with needs driver code. The driver code allows the kernel to pass data back and forth to the device, acting as a middleman between ­applications and the hardware. Two methods are used for interfacing device driver code with the Linux kernel:

• Compiling the device driver code with the kernel code

• Compile the device driver code into a separate module, which then interfaces with the kernel during runtime

In the very early days of Linux, the only way to insert device driver code was to ­recompile the kernel. Each time you added a new device to the system, you had to ­recompile the kernel code. This process became even more inefficient as Linux kernels supported more hardware and as removable storage devices (such as USB sticks) became more popular. Fortunately, Linux developers devised a better method to insert driver code into the running kernel.

Programmers developed the concept of kernel modules to allow you to insert device driver code into a running kernel without having to recompile the kernel. Also, a kernel module could be removed from the kernel when the system had finished using the device. This greatly simplified using hardware with Linux.

The Linux system represents hardware devices as special files, called device files. There are three different classifications of device files:

• Character

• Block

• Network

A character device file is for a device that can only handle data one character at a time. Most types of modems and terminals are created as character files. A block device file is for a device such as a disk drive that can handle data in large blocks at a time.

The network device file types (also called socket files) are used for devices that use packets to send and receive data. This includes temporary files used to send network data between programs running on the same physical host and a special loopback device that allows the Linux system to communicate with itself using common network ­programming protocols.

Linux creates special files, called nodes, for each device on the system. All communication with the device is performed through the device node. Each node has a unique number pair that identifies it to the Linux kernel. The number pair includes a major and a minor device number. Similar devices are grouped into the same major device number. The minor device number is used to identify a specific device within the major device group. Here is an example of a few device files on a Linux server:

Description

Different Linux distributions handle devices using different device names. In this ­distribution, the sda device is the first solid state drive (SSD) on the system.

The fifth column is the major device node number. Notice that all of the sda devices have the same major device node, 8. The sixth column is the minor device node number. Each device within a major number has its own unique minor device node number.

The first column indicates the permissions for the device file. The first character of the permissions indicates the type of file. Notice that the SSD files are all marked as block (b) devices.

Filesystem Management

A filesystem defines how the operating system stores data on storage devices. Unlike some other operating systems, the Linux kernel can support different types of ­filesystems to read and write data to and from hard drives, CD or DVD devices, and USB flash drives. Besides having over a dozen filesystems of its own, Linux can read and write to and from filesystems used by other operating systems, such as Microsoft Windows. The kernel must be compiled with support for all types of filesystems that the system will use, or device driver modules must be built and installed to support the filesystem. TABLE 1-2 lists the standard filesystems that a Linux system can use to read and write data.

TABLE 1-2 Linux filesystems.

Any hard drive that a Linux system accesses must be formatted using one of the ­filesystem types listed in Table 1-1.

The Linux kernel interfaces with each filesystem using the Virtual File System (VFS). 
This provides a standard interface for the kernel to communicate with any type of ­filesystem. VFS caches information in memory as each filesystem is mounted and used.