{"id":2915,"date":"2023-12-18T10:32:37","date_gmt":"2023-12-18T15:32:37","guid":{"rendered":"https:\/\/www.both.org\/?p=2915"},"modified":"2024-02-23T08:15:40","modified_gmt":"2024-02-23T13:15:40","slug":"how-to-tune-the-linux-kernel-with-the-proc-filesystem","status":"publish","type":"post","link":"https:\/\/www.both.org\/?p=2915","title":{"rendered":"How to tune the Linux kernel with the \/proc filesystem"},"content":{"rendered":"
\r\n
\r\n \r\n <\/i>\r\n <\/a>\r\n <\/span>\r\n<\/div><\/div>\n

Image by David Both: CC-by-SA 4.<\/p>\n\n\n\n

The Linux kernel is a tunable marvel that allows you to make changes to its parameters while it is running and without requiring a reboot.<\/h2>\n\n\n\n

Linux is an amazing and powerful operating system. More specifically, the Linux kernel is the source of many of its superpowers. <\/p>\n\n\n\n

I’ve been using Linux for 25 years and have used a lot of versions of the Linux kernel. I have even compiled the kernel a time or two in class and a few times just for grins. Most users and even sysadmins never need to compile the kernel. In most distributions, the default compile is perfectly fine for most use cases. But there are times when a bit of tuning is in order. The good news is that the kernel can be tuned easily without recompiling it or even rebooting.<\/p>\n\n\n\n

This article is not intended to be a detailed exposure of all the kernel data available for viewing or modification. It is an homage to an incredible piece of software that allows the flexibility to make significant functional changes while it’s in use.<\/p>\n\n\n\n

What is the \/proc filesystem?<\/h2>\n\n\n\n

The \/proc<\/code> filesystem is one of the most critical components of the kernel. It is a virtual filesystem that exists only in memory. The \/proc<\/code> filesystem is defined by the Linux Filesystem Hierarchical Standard<\/a> (FHS) as the location for Linux to store information about the system, the kernel, and all processes running on the host. It is intended to be a place for the kernel to expose information about itself to facilitate access to data about the system for programmers, developers, and sysadmins.<\/p>\n\n\n\n

Collecting this data does not impact the overall performance of a Linux host. The Linux kernel is designed to continuously collect and store the performance data that can be accessed and displayed by any and all performance monitoring tools. The tools access that data to read it and then manipulate and display it in a meaningful format. Because this data is already stored in the \/proc<\/code> filesystem, it avoids complex and time-consuming function calls to the kernel’s internals.<\/p>\n\n\n\n

Some of the data in the \/proc<\/code> filesystem is used to tune the kernel. The values in those files can be easily changed by simple and familiar Linux tools.<\/p>\n\n\n\n

Viewing the data<\/h2>\n\n\n\n

When used as a window into the state of the operating system and its view of the system and hardware, the kernel provides easy access to virtually every bit of information you might want as a sysadmin. All the cool tools that sysadmins use to view the status of the operating system and the kernel, access that data from the \/proc<\/code> filesystem.<\/p>\n\n\n\n

Start by viewing some of the available data. First, make \/proc<\/code> the present working directory (PWD) and list the contents. Many of these are directories and others are files. I use the Konsole terminal emulator<\/a>. The default color for directories is blue, and the files are the terminal text color, which I set to amber. Symbolic links are cyan.<\/p>\n\n\n

\n
\"Listing

Figure 1: A listing of the \/proc directory. (David Both, CC BY-SA 4.0)<\/figcaption><\/figure>\n<\/div>\n\n\n

<\/a>All the numeric directories represent the process ID (PID) of a process and contain the data required for the kernel to manage that process. The named files\u2014as opposed to named directories\u2014contain data pertaining to the file’s name. The named directories usually contain a series of files and subdirectories related to the directory’s name.<\/p>\n\n\n\n

One example is the stat<\/code> file. This file contains the statistical data pertaining to the system’s CPUs. You can use the cat<\/code> command to view that file. Do that multiple times, or use the following command as root to watch the file as it changes:<\/p>\n\n\n\n

# watch cat \/proc\/stat<\/code><\/pre>\n\n\n\n
The watch<\/code> command repeats the command every two seconds by default until you use Ctrl+C<\/strong> to break out. You could also specify a different interval. Read the man page for that information.<\/p>\n\n\n\n
Another interesting file is proc\/meminfo<\/code>. Try watching that one for a few minutes. All of my favorite problem determination and monitoring tools use the contents of \/proc<\/code> to obtain their data. Look at the free<\/code> command, for instance:<\/p>\n\n\n\n
# free\n               total        used        free      shared  buff\/cache   available\nMem:        32726880      727108    31104776        1560      894996    31610372\nSwap:       16777208           0    16777208<\/code><\/pre>\n\n\n\n
This next command displays the results of the free<\/code> command as well as the meminfo<\/code> file at the same time. Be sure to get the single and double quotes correct. The line of #<\/code> symbols provides a bit of visual separation between the outputs of the two commands and can be as long as you need it to be to provide enough of a visual clue for yourself. I shortened it here so that it all shows up on a single line.<\/p>\n\n\n\n
# watch 'free ; echo \"###########\" ; cat \/proc\/meminfo | head -20'<\/code><\/pre>\n\n\n\n
Interpreting the data that is output from these commands is outside the scope of this article but can be found in Section 1.14, the \/proc page of the LFSH description<\/a>, on the Linux Documentation Project<\/a> website. The man 5 proc<\/code> page also has good descriptions of the contents of all of the \/proc<\/code> files.<\/p>\n\n\n\n
Kool kernel tools<\/h2>\n\n\n\n
The free<\/code> command is just one of the many tools that allow you to view the status of the running kernel in real time.<\/p>\n\n\n\n
Others I like are top<\/code>, htop<\/code>, and glances<\/code>, which all show a comprehensive view of the running system. Using somewhat different layouts and varying options to configure how the data is displayed, they can all show memory and swap usage; individual and total CPU usage; a list of system and user processes; and data about each process such as memory, CPU usage, total run time for the process, the PID and the parent process ID (PPID).<\/p>\n\n\n\n
These three tools, along with the renice<\/code> command, can also renice or kill running processes. Renicing a process changes the data in the \/proc\/PID\/stat<\/code> file. The data in this file are complex, and the file is not writable by editors or redirection, so it’s necessary to use the renice tools that are available. <\/p>\n\n\n\n
Other tools I use frequently are lsblk<\/code>, iptop<\/code>, lsusb<\/code>, lspci<\/code>, and other related tools that list and manage hardware. Any of the many tools that manage processes, memory, networking, attached hardware, and everything else use the \/proc<\/code> filesystem to do so. <\/p>\n\n\n\n
Making changes to the running kernel<\/h2>\n\n\n\n
The \/proc<\/code> filesystem is also designed to provide access to modify many configuration values when necessary to allow you to tune the running system without needing to perform reboots after making changes. This is an incredibly powerful tool.<\/p>\n\n\n\n
One of the first things I need to tune on the Linux host I use for a router is to enable it to be a router. This is accomplished by setting the contents of the file \/proc\/sys\/net\/ipv4\/ip_forward<\/code> to 1<\/code>. There are multiple methods for making changes to the kernel-tuning variables, and all of them simply change the value present in the \/proc<\/code> filesystem. The first two methods are only temporary and must be performed after every reboot.<\/p>\n\n\n\n
First, I can use the command:<\/p>\n\n\n\n
# echo 1 > \/proc\/sys\/net\/ipv4\/ip_forward<\/code><\/pre>\n\n\n\n
The sysctl<\/code> command does exactly the same thing: it sets the value of that file to 1:<\/p>\n\n\n\n
#  sysctl -w net.ipv4.ip_forward = 1<\/code><\/pre>\n\n\n\n
You can check the value of any file:<\/p>\n\n\n\n
# sysctl net.ipv4.ip_forward\nnet.ipv4.ip_forward = 1<\/code><\/pre>\n\n\n\n
or:<\/p>\n\n\n\n
# cat sysctl net.ipv4.ip_forward\nnet.ipv4.ip_forward = 1<\/code><\/pre>\n\n\n\n
But all of these changes are only transient, and they reset to their default values at each boot.<\/p>\n\n\n\n
Making the changes permanent<\/h2>\n\n\n\n
Making these changes permanent is quite easy. Just add the following lines to the \/etc\/sysctl.conf<\/code> file or to a new file in \/etc\/sysctl.d<\/code>. These files are read and used to set kernel parameters at boot time. You can see some of the other kernel options I have set to meet my needs in this file:<\/p>\n\n\n\n
################################################################################\n#                            Local-sysctl.conf                                 #\n#                                                                              #\n# Local kernel option settings.                                                #\n# Install this file in the \/etc\/sysctl.d directory.                            #\n#                                                                              #\n# Use the command: sysctl -p \/etc\/sysctl.d\/local-sysctl.conf to activate.      #\n#                                                                              #\n################################################################################\n################################################################################\n# Local Network settings - Specifically to disable IPV6                        #\n################################################################################\nnet.ipv6.conf.all.disable_ipv6 = 1\nnet.ipv6.conf.default.disable_ipv6 = 1\n################################################################################\n# And to make this a router                                                    #\n################################################################################\nnet.ipv4.ip_forward = 1\n################################################################################\n# Virtual Memory Swappiness                                                    #     \n################################################################################\n# Set swappiness\nvm.swappiness = 13<\/code><\/pre>\n\n\n\n
For more details about performing these tasks, see my Opensource.com article, How I disabled IPv6 on Linux<\/a>.<\/p>\n\n\n\n
Final thoughts<\/h2>\n\n\n\n
The \/proc<\/code> filesystem is the “single point of truth” (SPOT) for obtaining information about the running system and changing the kernel-tuning variables. I use it frequently, either directly or indirectly, using the common GNU utilities and other tools already provided in every Linux distribution.<\/p>\n\n\n\n
The ability to tune the Linux kernel while it is running is one of the most powerful aspects of using Linux. It enables making changes to the kernel parameters while it is running and without requiring a reboot.<\/p>\n\n\n\n
Resources<\/h2>\n\n\n\n