Practical Methods for Listing Mapped Memory Regions in GDB Debugging

When debugging crashed processes in Linux systems, particularly when handling core dump files, developers often need to locate memory addresses for searching or analysis. For instance, when using GDB's find command to search for specific binary strings, find halts upon encountering inaccessible addresses, limiting the search scope. Thus, obtaining all readable memory region addresses of the process becomes crucial.

Problem Background and Challenges

In GDB, conventional commands like info mem or info proc are typically used to display memory information, but in post-mortem debugging scenarios, such as when analyzing core dumps, these commands may not function properly. Specifically, info proc mappings relies on the /proc filesystem, which is unavailable during core dump analysis, necessitating an alternative approach.

Solution: The maintenance info sections Command

GDB provides the maintenance info sections command to list all memory regions in the debugging target, including core dumps. This command outputs the start address, end address, and permissions for each region, allowing developers to precisely specify search ranges. For example, in a GDB session, enter the following command:

(gdb) maintenance info sections

This will display output similar to:

Exec file:
    `.text'， file offset 0x200， [0x400000-0x401000] loads ALLOC LOAD READONLY CODE HAS_CONTENTS
    `.data'， file offset 0x1000， [0x600000-0x601000] loads ALLOC LOAD DATA HAS_CONTENTS

By parsing this output, developers can extract all readable address regions and search them individually, avoiding the issue where the find command halts due to invalid addresses.

Code Example and Usage Instructions

Here is a practical example demonstrating how to use maintenance info sections with the find command to search for a specific address across the entire heap. Suppose you need to find structs pointing to the address 0x12345678.

First, run maintenance info sections to get the list of memory regions, then iterate over each region using the find command. In a GDB script, this can be implemented as follows:

(gdb) python
import gdb
output = gdb.execute("maintenance info sections"， to_string=True)
lines = output.split("
")
for line in lines:
    if "loads" in line and "READ" in line:  # Check for read permissions
        parts = line.split()
        for part in parts:
            if "[" in part and "]" in part:
                addr_range = part.strip("[]").split("-")
                start_addr = int(addr_range[0]， 16)
                end_addr = int(addr_range[1]， 16)
                cmd = f"find /w {hex(start_addr)}， {hex(end_addr)}， 0x12345678"
                result = gdb.execute(cmd， to_string=True)
                if "pattern found" in result:
                    print(f"Found in range: {part}")
                    break

This script automatically extracts readable memory regions and performs the search, enhancing debugging efficiency. Note that the /w parameter in the find command specifies word-wise searching, while other parameters like /b can be used for byte-wise searches.

Comparison and Additional Commands

While maintenance info sections is recommended for post-mortem debugging, info proc mappings might be more straightforward for live process debugging. Developers should choose the appropriate command based on context. Additionally, other GDB commands like info files or info target can provide partial memory information, but may be incomplete.

Conclusion and Best Practices

In GDB debugging, effectively managing mapped memory regions is essential for resolving complex memory errors. By using the maintenance info sections command, developers can overcome limitations in core dump debugging and precisely control search ranges. It is advisable to integrate scripting automation in practical debugging to reduce manual errors and improve productivity.