38

我想探索一个活着的进程的记忆，当我这样做时，这个进程一定不会受到干扰 - 所以将 gdb 附加到进程（这会阻止它）不是一种选择。因此，我想从 /proc/kcore 获取此信息（如果您知道另一种方法，请告诉我）。所以我做了一个小实验。我创建了一个名为 TEST 的文件，里面只有“EXTRATESTEXTRA”。然后我用更少的东西打开它

$ less TEST

我得到了这个过程的PID

$ ps aux | grep TEST
user    7785  0.0  0.0  17944   992 pts/8    S+   16:15   0:00 less TEST
user    7798  0.0  0.0  13584   904 pts/9    S+   16:16   0:00 grep TEST

然后我用这个脚本创建了所有文件的转储：

#!/bin/bash
grep rw-p /proc/$1/maps | sed -n 's/^\([0-9a-f]*\)-\([0-9a-f]*\) .*$/\1 \2/p' | while read start stop; do gdb --batch --pid $1 -ex "dump memory $1-$start-$stop.dump 0x$start 0x$stop"; done

（我在这个网站上找到了它https://serverfault.com/questions/173999/dump-a-linux-processs-memory-to-file）

$ sudo ./dump_all_pid_memory.sh 7785

在此之后，我在所有转储文件中查找“TRATESTEX”：

$ grep -a -o -e '...TRATESTEX...' ./*.dump
./7785-00624000-00628000.dump:HEXTRATESTEXTRA
./7785-00b8f000-00bb0000.dump:EXTRATESTEXTRA
./7785-00b8f000-00bb0000.dump:EXTRATESTEXTRA

所以我得出结论，这个字符串一定会在 0x00624000 和 0x00628000 之间出现。因此，我将偏移量转换为十进制数并使用 dd 从 /proc/kcore 获取内存：

$ sudo dd if="/proc/kcore" of="./y.txt" skip="0" count="1638400" bs=1

令我惊讶的是，文件 y.txt 中全是零（我没有在其中找到我要查找的字符串）。

作为一个额外的惊喜，我同时用不同的测试文件运行了一个类似的测试，发现我正在使用的另一个测试字符串（两个进程同时运行）应该在同一个位置（ dump 和 greping 给出了相同的偏移量）。所以肯定有什么我不明白的地方。

  • /proc/pid/maps 不应该显示内存的偏移量（即：如果它说“XXX”位于偏移量 0x10，那么另一个程序不能使用相同的偏移量，对吗？ - 这是我的第二个惊喜的来源）

  • 如何读取 /proc/kmap 以获取属于我知道的 pid 进程的内存？

4

6 回答 6

37

如果您具有 root 访问权限并且在 linux 系统上，则可以使用以下 linux 脚本（改编自Gilles 出色的 unix.stackexchange.com 答案和最初在上述问题中给出的答案，但包括 SyntaxErrors 而不是 pythonic）：

#!/usr/bin/env python

import re
import sys

def print_memory_of_pid(pid, only_writable=True):
    """ 
    Run as root, take an integer PID and return the contents of memory to STDOUT
    """
    memory_permissions = 'rw' if only_writable else 'r-'
    sys.stderr.write("PID = %d" % pid)
    with open("/proc/%d/maps" % pid, 'r') as maps_file:
        with open("/proc/%d/mem" % pid, 'r', 0) as mem_file:
            for line in maps_file.readlines():  # for each mapped region
                m = re.match(r'([0-9A-Fa-f]+)-([0-9A-Fa-f]+) ([-r][-w])', line)
                if m.group(3) == memory_permissions: 
                    sys.stderr.write("\nOK : \n" + line+"\n")
                    start = int(m.group(1), 16)
                    if start > 0xFFFFFFFFFFFF:
                        continue
                    end = int(m.group(2), 16)
                    sys.stderr.write( "start = " + str(start) + "\n")
                    mem_file.seek(start)  # seek to region start
                    chunk = mem_file.read(end - start)  # read region contents
                    print chunk,  # dump contents to standard output
                else:
                    sys.stderr.write("\nPASS : \n" + line+"\n")

if __name__ == '__main__': # Execute this code when run from the commandline.
    try:
        assert len(sys.argv) == 2, "Provide exactly 1 PID (process ID)"
        pid = int(sys.argv[1])
        print_memory_of_pid(pid)
    except (AssertionError, ValueError) as e:
        print "Please provide 1 PID as a commandline argument."
        print "You entered: %s" % ' '.join(sys.argv)
        raise e

如果你将它保存为 write_mem.py，你可以运行它（使用 python2.6 或 2.7）或在 python2.5 早期（如果你添加from __future__ import with_statement）：

sudo python write_mem.py 1234 > pid1234_memory_dump

将 pid1234 内存转储到文件 pid1234_memory_dump。

于 2014-04-11T00:54:03.867 回答
20

对于进程 1234，您可以通过顺序读取/proc/1234/maps（文本伪文件）来获取其内存映射，并通过例如read(2) -ing 或mmap(2)/proc/1234/mem -ing稀疏伪文件的适当段来读取虚拟内存。

但是，我相信您无法避免某种同步（可能与ptrace(2)一样gdb），因为进程 1234 可以（并且确实）随时更改其地址空间（使用mmap& 相关的系统调用）。

如果受监视进程 1234 不是任意的，但如果您可以改进它以以某种方式与监视进程通信，则情况会有所不同。

我不确定你为什么要问这个。并且gdb能够在watch不停止进程的情况下到达某个位置。

于 2012-10-19T19:10:05.673 回答
4

自3.2版内核。您可以使用process_vm_readv系统调用来读取进程内存而不会中断。

ssize_t process_vm_readv(pid_t pid,
                                const struct iovec *local_iov,
                                unsigned long liovcnt,
                                const struct iovec *remote_iov,
                                unsigned long riovcnt,
                                unsigned long flags);

这些系统调用在调用进程（“本地进程”）的地址空间和由 pid 标识的进程（“远程进程”）之间传输数据。数据直接在两个进程的地址空间之间移动，不经过内核空间。

于 2018-07-27T09:44:17.650 回答
0

您必须使用来读取进程内存。我不建议尝试读取或任何内核内存功能（这很耗时）。/proc/pid/mem/proc/kcore

于 2012-10-19T17:20:14.213 回答
0

如果只想获取全局变量或者指定地址的值，可以使用我的工具gvardump，而不是读取整个内存。gvardump 将解析变量地址并很好地打印其值，而不会导致进程中断。

例如：

root@ubuntu:/home/u/trace_test# ./gvardump.py 53670 -a 1 '*g_ss[0].sss[0].ps'
*((g_ss[0]).sss[0]).ps = {
    .a = 6,
    .sss = {
        {
            .bbb = 0,
            .ps = 0x563ca42a2020,
            .bs = {
                .m = 0,
            },
        },
        // other 9 elements are omit
    },
    ...
于 2022-02-19T10:17:31.523 回答
-3

我通过发出以下命令实现了这一点

[root@stage1 ~]# echo "PID [MySql] 的内存使用情况："; {Private,Rss,Shared,Swap,Pss} 中的内存；执行 grep $mem /proc/ ps aux |grep mysql |awk '{print $2}'|head -n 1/smaps | awk -v mem_type="$mem" '{i=i+$2} END {打印 mem_type,"内存使用情况:"i}' ;完成

结果输出

PID [MySql] 的内存使用情况：

私有内存使用量：204

Rss 内存使用量：1264

共享内存使用量：1060

交换内存使用：0

pss内存使用量：423

于 2017-03-09T08:15:20.617 回答