pmap Command in Linux

Introduction

In this lab, we will delve into the Linux pmap command, a robust utility for examining the memory utilization of active processes. We'll cover understanding the pmap command's functionality, analyzing a process's memory consumption, and spotting possible memory leaks. The pmap command delivers a granular breakdown of a process's memory segments, encompassing the starting address, size, permissions, and linked files or libraries. This data is incredibly useful for fine-tuning application performance and finding memory-related problems. This lab offers hands-on examples and use cases for the pmap command, assisting you in building crucial system monitoring and management expertise.

Understanding the pmap Command

In this section, we will explore the pmap command, a valuable asset in Linux that grants detailed insights into a running process's memory usage. The pmap command proves especially helpful for pinpointing memory leaks and grasping the memory footprint of your applications.

Let's begin by executing the pmap command on an active process. We'll employ the top command to determine the process ID (PID) of a process we wish to scrutinize:

top

Example output:

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
 1234 labex     20   0  124.3m  12.3m   3.4m S   0.3   0.6   0:00.12 nginx

In this instance, the PID of the nginx process is 1234. We can now leverage the pmap command to dissect this process's memory usage:

sudo pmap 1234

Example output:

1234:   nginx: nginx worker process
0000562a0f4f3000      4K r-x-- /usr/sbin/nginx
0000562a0f6f4000    132K r---- /usr/sbin/nginx
0000562a0f6ff000     16K rw--- /usr/sbin/nginx
0000562a0f703000     12K rw---   [ anon ]
0000562a0f706000   2044K r-x-- /lib/x86_64-linux-gnu/libc-2.35.so
0000562a0f908000   2048K ----- /lib/x86_64-linux-gnu/libc-2.35.so
0000562a0fb08000     16K r---- /lib/x86_64-linux-gnu/libc-2.35.so
0000562a0fb0c000      8K rw--- /lib/x86_64-linux-gnu/libc-2.35.so
0000562a0fb0e000     20K rw---   [ anon ]
0000562a0fb13000    132K r-x-- /lib/x86_64-linux-gnu/ld-2.35.so
0000562a0fd2c000     12K r---- /lib/x86_64-linux-gnu/ld-2.35.so
0000562a0fd2f000      4K rw--- /lib/x86_64-linux-gnu/ld-2.35.so
0000562a0fd30000      4K rw---   [ anon ]
total            4,436K

The pmap command delivers a comprehensive breakdown of the designated process's memory usage. Each line signifies a memory segment, complete with details concerning the starting address, size, permissions, and the file or library tied to that segment.

This output empowers you to comprehend your application's memory usage, detect potential memory leaks, and optimize its performance.

Analyzing Memory Usage of a Process

In this phase, we will explore further into dissecting a process's memory usage using the pmap command. We'll investigate diverse options and techniques to acquire a thorough understanding of how a process is employing system memory.

Let's commence by executing the pmap command with the -x option, which grants more extensive details about the memory segments utilized by the process:

sudo pmap -x 1234

Example output:

1234:   nginx: nginx worker process
Address   Kbytes Mode  Offset           Device     Mapping
0000562a0f4f3000      4     r-x--    0000000000000000 /usr/sbin/nginx
0000562a0f6f4000    132     r----   0000000000001000 /usr/sbin/nginx
0000562a0f6ff000     16     rw---   0000000000002000 /usr/sbin/nginx
0000562a0f703000     12     rw---                [ anon ]
0000562a0f706000   2044     r-x--   0000000000000000 /lib/x86_64-linux-gnu/libc-2.35.so
0000562a0f908000   2048     -----   0000000000202000 /lib/x86_64-linux-gnu/libc-2.35.so
0000562a0fb08000     16     r----   0000000000202000 /lib/x86_64-linux-gnu/libc-2.35.so
0000562a0fb0c000      8     rw---   0000000000204000 /lib/x86_64-linux-gnu/libc-2.35.so
0000562a0fb0e000     20     rw---                [ anon ]
0000562a0fb13000    132     r-x--   0000000000000000 /lib/x86_64-linux-gnu/ld-2.35.so
0000562a0fd2c000     12     r----   0000000000019000 /lib/x86_64-linux-gnu/ld-2.35.so
0000562a0fd2f000      4     rw---   000000000001b000 /lib/x86_64-linux-gnu/ld-2.35.so
0000562a0fd30000      4     rw---                [ anon ]
total            4,436

The extra data furnished by the -x option incorporates the memory mode (read, write, execute), the offset within the mapped file, the device number, and the name of the mapped file or library.

You can also leverage the pmap command with the -d option to exhibit the dynamic memory segments employed by the process:

sudo pmap -d 1234

Example output:

1234:   nginx: nginx worker process
Address   Kbytes Mode  Offset           Device     Mapping
0000562a0f703000     12     rw---                [ anon ]
0000562a0fb0e000     20     rw---                [ anon ]
0000562a0fd30000      4     rw---                [ anon ]
total                36

The -d option displays the anonymous memory segments, which are dynamically allocated by the process and not linked to any particular file or library.

These pmap command options can aid you in pinpointing your application's memory usage patterns, detecting potential memory leaks, and optimizing its performance. System administrators often rely on this to ensure optimal system health.

Identifying Memory Leaks with pmap

In this concluding section, we will acquire the knowledge to employ the pmap command to detect potential memory leaks within an active process. Memory leaks can trigger excessive memory consumption and performance complications, thus being able to detect and resolve them is paramount.

Let's initiate by executing a basic Python script that simulates a memory leak:

cat << EOF > leak.py
import time

def leak():
    x = []
    while True:
        x.append([0] * 1000000)
        time.sleep(1)

if __name__ == "__main__":
    leak()
EOF

python3 leak.py &

This script incessantly allocates sizable arrays, which will eventually instigate a memory leak. Let's utilize the pmap command to oversee the memory usage of this process:

sudo pmap -x $(pgrep -f leak.py)

Example output (after a few minutes):

18768:   python3 leak.py
Address   Kbytes Mode  Offset           Device     Mapping
00005612b3a4f000      4     r-x--    0000000000000000 /usr/bin/python3.10
00005612b3c50000   1028     r----   0000000000001000 /usr/bin/python3.10
00005612b3d54000    408     rw---   0000000000002000 /usr/bin/python3.10
00005612b3e7c000    144     rw---                [ anon ]
00005612b3ea0000   2048     r-x--   0000000000000000 /lib/x86_64-linux-gnu/libc-2.35.so
00005612b40a0000   2048     -----   0000000000200000 /lib/x86_64-linux-gnu/libc-2.35.so
00005612b42a0000     16     r----   0000000000200000 /lib/x86_64-linux-gnu/libc-2.35.so
00005612b42a4000      8     rw---   0000000000202000 /lib/x86_64-linux-gnu/libc-2.35.so
00005612b42a6000     20     rw---                [ anon ]
00005612b42ab000    132     r-x--   0000000000000000 /lib/x86_64-linux-gnu/ld-2.35.so
00005612b44c4000     12     r----   0000000000019000 /lib/x86_64-linux-gnu/ld-2.35.so
00005612b44c7000      4     rw---   000000000001b000 /lib/x86_64-linux-gnu/ld-2.35.so
00005612b44c8000      4     rw---                [ anon ]
00005612b44c9000 1048576     rw---                [ anon ]
total           1,054,448

As evident, the memory usage of the Python process persistently escalates over time, implying a potential memory leak. The pmap command reveals that the process is allocating a substantial amount of anonymous memory, which is a telling indication of a memory leak. Root cause analysis would be the next step.

To corroborate the memory leak, you can periodically execute the pmap command and observe the expansion in the "total" memory usage.

Summary

In this lab, we examined the Linux pmap command, which furnishes detailed data regarding the memory usage of an active process. We acquired the knowledge to employ the pmap command to dissect a process's memory usage, encompassing identifying the memory segments, their sizes, and the linked files or libraries. This data can be invaluable for grasping the memory footprint of your applications and detecting potential memory leaks. This is a crucial skill for any Linux systemadmin.

Furthermore, we deliberated on how the pmap command can be utilized to detect memory leaks within your applications. By consistently monitoring the memory usage of your processes utilizing pmap, you can detect any unforeseen increases in memory usage, which may signal a memory leak. This can facilitate you in troubleshooting and resolving performance impediments in your applications. Regular use of pmap is a recommended practice for maintaining a stable Linux environment.

400+ Linux Commands