How to check if a specific kernel memory allocator is used in Linux

Introduction

In this lab, we will explore how to check if a specific kernel memory allocator is being used in Linux. We will achieve this by examining allocator statistics, kernel configuration, and system logs.

First, we'll use cat /proc/slabinfo to view the kernel's slab allocator statistics, providing insights into memory management. We'll then verify the allocator in use by inspecting the kernel configuration file using zcat /proc/config.gz. Finally, we'll inspect allocator logs in dmesg for relevant information. These steps will help you understand how to identify and verify the kernel memory allocator in use.

Skills Graph

Check allocator stats with cat /proc/slabinfo

In this step, we'll explore how to check the allocator statistics using the cat /proc/slabinfo command. This command provides a detailed view of the kernel's slab allocator, which is responsible for managing memory efficiently. Understanding this information can be helpful for debugging memory-related issues and optimizing system performance.

First, let's execute the command:

cat /proc/slabinfo

This command will display a list of slab caches, along with their associated statistics. The output might seem overwhelming at first, but we'll break it down.

Here's an example of what you might see:

slabinfo - version: 2.1
kmem_cache            48     72    192    19    1    1
...
kmalloc-192           48     72    192    19    1    1
...

Each line represents a slab cache. The columns provide information about the cache, such as:

• name: The name of the slab cache.
• <active_objs>: The number of active objects in the cache.
• <num_objs>: The total number of objects in the cache.
• <objsize>: The size of each object in bytes.
• <objperslab>: The number of objects per slab.
• <pagesperslab>: The number of pages per slab.
• <flags>: Flags associated with the cache.

The kmem_cache is a general-purpose cache, while kmalloc-192 is a cache for objects of size 192 bytes.

To make the output more readable, you can use the less command:

cat /proc/slabinfo | less

This allows you to scroll through the output page by page. Press q to exit less.

You can also use grep to filter the output and focus on specific slab caches. For example, to find information about the kmalloc-192 cache, you can use the following command:

cat /proc/slabinfo | grep kmalloc-192

This will display only the lines that contain "kmalloc-192".

By examining the output of cat /proc/slabinfo, you can gain insights into how the kernel is managing memory and identify potential areas for optimization.

Verify allocator in zcat /proc/config.gz

In this step, we'll verify the allocator configuration by examining the kernel configuration file, which is typically compressed and located at /proc/config.gz. This file contains the configuration options used to build the kernel, including those related to memory allocation.

First, let's use the zcat command to decompress and view the contents of the configuration file:

zcat /proc/config.gz

The zcat command is similar to cat, but it automatically decompresses gzipped files. The output will be a long list of kernel configuration options.

To find allocator-related options, we can use grep to filter the output. For example, to find options related to the slab allocator, we can use the following command:

zcat /proc/config.gz | grep SLAB

This will display lines that contain "SLAB". You might see something like this:

CONFIG_SLAB=y
## CONFIG_SLAB_DEPRECATED is not set
CONFIG_SLUB=y
## CONFIG_SLOB is not set

These options indicate which slab allocator is enabled in the kernel. CONFIG_SLAB=y indicates that the original slab allocator is enabled, while CONFIG_SLUB=y indicates that the SLUB allocator is enabled. Only one of these should be enabled. CONFIG_SLOB is a simplified allocator for embedded systems.

You can also search for other allocator-related options, such as those related to the page allocator or the buddy system. For example:

zcat /proc/config.gz | grep PAGE_ALLOC

This will show options related to page allocation.

By examining the kernel configuration file, you can verify which allocator is being used and what options are enabled. This can be helpful for understanding the memory management behavior of the system.

Inspect allocator logs in dmesg

In this step, we'll inspect the kernel's message buffer using the dmesg command to look for logs related to the memory allocator. The dmesg command displays messages from the kernel ring buffer, which can contain valuable information about system events, including memory allocation and deallocation.

To view the kernel messages, simply type:

dmesg

This will output a large amount of text. To filter the output and focus on allocator-related messages, we can use grep. For example, to find messages related to the slab allocator, use:

dmesg | grep slab

You might see output similar to this:

[    0.000000] SLUB: HWalign slab flags
[    1.234567] kmem_cache_create: slab created at <memory_address>

These messages can provide information about slab cache creation, destruction, and other events.

You can also search for messages related to memory allocation failures:

dmesg | grep alloc

Or messages related to out-of-memory (OOM) situations:

dmesg | grep OOM

These messages can help you diagnose memory-related problems.

To make the output more manageable, you can use less to scroll through the messages:

dmesg | less

Press q to exit less.

By examining the dmesg output, you can gain insights into the behavior of the memory allocator and identify potential issues.

Summary

In this lab, we explored how to check kernel memory allocator statistics using the cat /proc/slabinfo command. This command provides a detailed view of the kernel's slab allocator, displaying a list of slab caches and their associated statistics, including the cache name, number of active and total objects, object size, objects per slab, pages per slab, and flags.

We also learned how to use less to make the output more readable and grep to filter the output and focus on specific slab caches, such as kmalloc-192. By examining the output, we can gain insights into how the kernel is managing memory.