10张图22段代码，万字长文带你搞懂虚拟内存模型和Malloc内部原理

10张图22段代码，万字长文带你搞懂虚拟内存模型和Malloc内部原理

作者：程序喵大人 2020-11-11 08:25:45

云计算

虚拟化

存储软件 我们会通过/proc文件系统找到正在运行的进程的字符串所在的虚拟内存地址，并通过更改此内存地址的内容来更改字符串内容，使你更深入了解虚拟内存这个概念!

成都网站建设哪家好，找创新互联建站！专注于网页设计、成都网站建设公司、微信开发、小程序制作、集团成都定制网站等服务项目。核心团队均拥有互联网行业多年经验，服务众多知名企业客户；涵盖的客户类型包括：社区文化墙等众多领域，积累了大量丰富的经验，同时也获得了客户的一致赞赏！

本文转载自微信公众号「程序喵大人」，作者程序喵大人 。转载本文请联系程序喵大人公众号。

摊牌了，不装了，其实我是程序喵辛苦工作一天还要回家编辑公众号到大半夜的老婆，希望各位大哥能踊跃转发，完成我一千阅读量的KPI(梦想)，谢谢!

咳咳，有点跑题，以下是程序喵的废话，麻烦给个面子划到最后点击在看或者赞，证明我比程序喵人气高，谢谢!

通过/proc文件系统探究虚拟内存

我们会通过/proc文件系统找到正在运行的进程的字符串所在的虚拟内存地址，并通过更改此内存地址的内容来更改字符串内容，使你更深入了解虚拟内存这个概念!这之前先介绍下虚拟内存的定义!

虚拟内存

虚拟内存是一种实现在计算机软硬件之间的内存管理技术，它将程序使用到的内存地址(虚拟地址)映射到计算机内存中的物理地址，虚拟内存使得应用程序从繁琐的管理内存空间任务中解放出来，提高了内存隔离带来的安全性，虚拟内存地址通常是连续的地址空间，由操作系统的内存管理模块控制，在触发缺页中断时利用分页技术将实际的物理内存分配给虚拟内存，而且64位机器虚拟内存的空间大小远超出实际物理内存的大小，使得进程可以使用比物理内存大小更多的内存空间。

在深入研究虚拟内存前，有几个关键点：

  • 每个进程都有它自己的虚拟内存
  • 虚拟内存的大小取决于系统的体系结构
  • 不同操作管理有着不同的管理虚拟内存的方式，但大多数操作系统的虚拟内存结构如下图：

virtual_memory.png

上图并不是特别详细的内存管理图，高地址其实还有内核空间等等，但这不是这篇文章的主题。从图中可以看到高地址存储着命令行参数和环境变量，之后是栈空间、堆空间和可执行程序，其中栈空间向下延申，堆空间向上增长，堆空间需要使用malloc分配，是动态分配的内存的一部分。

首先通过一个简单的C程序探究虚拟内存。

  
 
 
 
    
   
  
  
  
  1. #include 
    2. 
   
  
  
  
  2. #include 
    3. 
   
  
  
  
  3. #include 
    4. 
   
  
  
  
  4. 
   
  
  
  
  5. /**
    6. 
   
  
  
  
  6.  * main - 使用strdup创建一个字符串的拷贝，strdup内部会使用malloc分配空间，
    7. 
   
  
  
  
  7.  * 返回新空间的地址，这段地址空间需要外部自行使用free释放
    8. 
   
  
  
  
  8.  *
    9. 
   
  
  
  
  9.  * Return: EXIT_FAILURE if malloc failed. Otherwise EXIT_SUCCESS
    10. 
   
  
  
  
  10.  */
    11. 
   
  
  
  
  11. int main(void)
    12. 
   
  
  
  
  12. {
    13. 
   
  
  
  
  13.     char *s;
    14. 
   
  
  
  
  14. 
   
  
  
  
  15.     s = strdup("test_memory");
    16. 
   
  
  
  
  16.     if (s == NULL)
    17. 
   
  
  
  
  17.     {
    18. 
   
  
  
  
  18.         fprintf(stderr, "Can't allocate mem with malloc\n");
    19. 
   
  
  
  
  19.         return (EXIT_FAILURE);
    20. 
   
  
  
  
  20.     }
    21. 
   
  
  
  
  21.     printf("%p\n", (void *)s);
    22. 
   
  
  
  
  22.     return (EXIT_SUCCESS);
    23. 
   
  
  
  
  23. }
    24. 
   
  
  
  
  24. 
   
  
  
  
  25. 编译运行：gcc -Wall -Wextra -pedantic -Werror main.c -o test; ./test
    26. 
   
  
  
  
  26. 输出：0x88f010
    27.

我的机器是64位机器，进程的虚拟内存高地址为0xffffffffffffffff， 低地址为0x0，而0x88f010远小于0xffffffffffffffff，因此大概可以推断出被复制的字符串的地址(堆地址)是在内存低地址附近，具体可以通过/proc文件系统验证.

ls /proc目录可以看到好多文件，这里主要关注/proc/[pid]/mem和/proc/[pid]/maps

mem & maps

  
 
 
 
    
   
  
  
  
  1. man proc
    2. 
   
  
  
  
  2. 
   
  
  
  
  3. /proc/[pid]/mem
    4. 
   
  
  
  
  4.     This file can be used to access the pages of a process's memory through open(2), read(2), and lseek(2).
    5. 
   
  
  
  
  5. 
   
  
  
  
  6. /proc/[pid]/maps
    7. 
   
  
  
  
  7.     A  file containing the currently mapped memory regions and their access permissions.
    8. 
   
  
  
  
  8.           See mmap(2) for some further information about memory mappings.
    9. 
   
  
  
  
  9. 
   
  
  
  
  10.               The format of the file is:
    11. 
   
  
  
  
  11. 
   
  
  
  
  12.        address           perms offset  dev   inode       pathname
    13. 
   
  
  
  
  13.        00400000-00452000 r-xp 00000000 08:02 173521      /usr/bin/dbus-daemon
    14. 
   
  
  
  
  14.        00651000-00652000 r--p 00051000 08:02 173521      /usr/bin/dbus-daemon
    15. 
   
  
  
  
  15.        00652000-00655000 rw-p 00052000 08:02 173521      /usr/bin/dbus-daemon
    16. 
   
  
  
  
  16.        00e03000-00e24000 rw-p 00000000 00:00 0           [heap]
    17. 
   
  
  
  
  17.        00e24000-011f7000 rw-p 00000000 00:00 0           [heap]
    18. 
   
  
  
  
  18.        ...
    19. 
   
  
  
  
  19.        35b1800000-35b1820000 r-xp 00000000 08:02 135522  /usr/lib64/ld-2.15.so
    20. 
   
  
  
  
  20.        35b1a1f000-35b1a20000 r--p 0001f000 08:02 135522  /usr/lib64/ld-2.15.so
    21. 
   
  
  
  
  21.        35b1a20000-35b1a21000 rw-p 00020000 08:02 135522  /usr/lib64/ld-2.15.so
    22. 
   
  
  
  
  22.        35b1a21000-35b1a22000 rw-p 00000000 00:00 0
    23. 
   
  
  
  
  23.        35b1c00000-35b1dac000 r-xp 00000000 08:02 135870  /usr/lib64/libc-2.15.so
    24. 
   
  
  
  
  24.        35b1dac000-35b1fac000 ---p 001ac000 08:02 135870  /usr/lib64/libc-2.15.so
    25. 
   
  
  
  
  25.        35b1fac000-35b1fb0000 r--p 001ac000 08:02 135870  /usr/lib64/libc-2.15.so
    26. 
   
  
  
  
  26.        35b1fb0000-35b1fb2000 rw-p 001b0000 08:02 135870  /usr/lib64/libc-2.15.so
    27. 
   
  
  
  
  27.        ...
    28. 
   
  
  
  
  28.        f2c6ff8c000-7f2c7078c000 rw-p 00000000 00:00 0    [stack:986]
    29. 
   
  
  
  
  29.        ...
    30. 
   
  
  
  
  30.        7fffb2c0d000-7fffb2c2e000 rw-p 00000000 00:00 0   [stack]
    31. 
   
  
  
  
  31.        7fffb2d48000-7fffb2d49000 r-xp 00000000 00:00 0   [vdso]
    32. 
   
  
  
  
  32. 
   
  
  
  
  33.               The address field is the address space in the process that the mapping occupies.
    34. 
   
  
  
  
  34.           The perms field is a set of permissions:
    35. 
   
  
  
  
  35. 
   
  
  
  
  36.                    r = read
    37. 
   
  
  
  
  37.                    w = write
    38. 
   
  
  
  
  38.                    x = execute
    39. 
   
  
  
  
  39.                    s = shared
    40. 
   
  
  
  
  40.                    p = private (copy on write)
    41. 
   
  
  
  
  41. 
   
  
  
  
  42.               The offset field is the offset into the file/whatever;
    43. 
   
  
  
  
  43.           dev is the device (major:minor); inode is the inode on that device.   0  indicates
    44. 
   
  
  
  
  44.               that no inode is associated with the memory region,
    45. 
   
  
  
  
  45.           as would be the case with BSS (uninitialized data).
    46. 
   
  
  
  
  46. 
   
  
  
  
  47.               The  pathname field will usually be the file that is backing the mapping.
    48. 
   
  
  
  
  48.           For ELF files, you can easily coordinate with the offset field
    49. 
   
  
  
  
  49.               by looking at the Offset field in the ELF program headers (readelf -l).
    50. 
   
  
  
  
  50. 
   
  
  
  
  51.               There are additional helpful pseudo-paths:
    52. 
   
  
  
  
  52. 
   
  
  
  
  53.                    [stack]
    54. 
   
  
  
  
  54.                           The initial process's (also known as the main thread's) stack.
    55. 
   
  
  
  
  55. 
   
  
  
  
  56.                    [stack:] (since Linux 3.4)
    57. 
   
  
  
  
  57.                           A thread's stack (where the  is a thread ID).
    58. 
   
  
  
  
  58.               It corresponds to the /proc/[pid]/task/[tid]/ path.
    59. 
   
  
  
  
  59. 
   
  
  
  
  60.                    [vdso] The virtual dynamically linked shared object.
    61. 
   
  
  
  
  61. 
   
  
  
  
  62.                    [heap] The process's heap.
    63. 
   
  
  
  
  63. 
   
  
  
  
  64.               If the pathname field is blank, this is an anonymous mapping as obtained via the mmap(2) function.
    65. 
   
  
  
  
  65.           There is no easy  way  to  coordinate
    66. 
   
  
  
  
  66.               this back to a process's source, short of running it through gdb(1), strace(1), or similar.
    67. 
   
  
  
  
  67. 
   
  
  
  
  68.               Under Linux 2.0 there is no field giving pathname.
    69.

通过mem文件可以访问和修改整个进程的内存页，通过maps可以看到进程当前已映射的内存区域，有地址和访问权限偏移量等，从maps中可以看到堆空间是在低地址而栈空间是在高地址. 从maps中可以看到heap的访问权限是rw，即可写，所以可以通过堆地址找到上个示例程序中字符串的地址，并通过修改mem文件对应地址的内容，就可以修改字符串的内容啦，程序：

  
 
 
 
    
   
  
  
  
  1. #include 
    2. 
   
  
  
  
  2. #include 
    3. 
   
  
  
  
  3. #include 
    4. 
   
  
  
  
  4. #include 
    5. 
   
  
  
  
  5. 
   
  
  
  
  6. /**              
    7. 
   
  
  
  
  7.  * main - uses strdup to create a new string, loops forever-ever
    8. 
   
  
  
  
  8.  *                
    9. 
   
  
  
  
  9.  * Return: EXIT_FAILURE if malloc failed. Other never returns
    10. 
   
  
  
  
  10.  */
    11. 
   
  
  
  
  11. int main(void)
    12. 
   
  
  
  
  12. {
    13. 
   
  
  
  
  13.      char *s;
    14. 
   
  
  
  
  14.      unsigned long int i;
    15. 
   
  
  
  
  15. 
   
  
  
  
  16.      s = strdup("test_memory");
    17. 
   
  
  
  
  17.      if (s == NULL)
    18. 
   
  
  
  
  18.      {
    19. 
   
  
  
  
  19.           fprintf(stderr, "Can't allocate mem with malloc\n");
    20. 
   
  
  
  
  20.           return (EXIT_FAILURE);
    21. 
   
  
  
  
  21.      }
    22. 
   
  
  
  
  22.      i = 0;
    23. 
   
  
  
  
  23.      while (s)
    24. 
   
  
  
  
  24.      {
    25. 
   
  
  
  
  25.           printf("[%lu] %s (%p)\n", i, s, (void *)s);
    26. 
   
  
  
  
  26.           sleep(1);
    27. 
   
  
  
  
  27.           i++;
    28. 
   
  
  
  
  28.      }
    29. 
   
  
  
  
  29.      return (EXIT_SUCCESS);
    30. 
   
  
  
  
  30. }
    31. 
   
  
  
  
  31. 编译运行：gcc -Wall -Wextra -pedantic -Werror main.c -o loop; ./loop
    32. 
   
  
  
  
  32. 输出：
    33. 
   
  
  
  
  33. [0] test_memory (0x21dc010)
    34. 
   
  
  
  
  34. [1] test_memory (0x21dc010)
    35. 
   
  
  
  
  35. [2] test_memory (0x21dc010)
    36. 
   
  
  
  
  36. [3] test_memory (0x21dc010)
    37. 
   
  
  
  
  37. [4] test_memory (0x21dc010)
    38. 
   
  
  
  
  38. [5] test_memory (0x21dc010)
    39. 
   
  
  
  
  39. [6] test_memory (0x21dc010)
    40. 
   
  
  
  
  40. ...
    41.

这里可以写一个脚本通过/proc文件系统找到字符串所在位置并修改其内容，相应的输出也会更改。

首先找到进程的进程号

  
 
 
 
    
   
  
  
  
  1. ps aux | grep ./loop | grep -v grep
    2. 
   
  
  
  
  2. zjucad    2542  0.0  0.0   4352   636 pts/3    S+   12:28   0:00 ./loop
    3.

2542即为loop程序的进程号，cat /proc/2542/maps得到

  
 
 
 
    
   
  
  
  
  1. 00400000-00401000 r-xp 00000000 08:01 811716                             /home/zjucad/wangzhiqiang/loop
    2. 
   
  
  
  
  2. 00600000-00601000 r--p 00000000 08:01 811716                             /home/zjucad/wangzhiqiang/loop
    3. 
   
  
  
  
  3. 00601000-00602000 rw-p 00001000 08:01 811716                             /home/zjucad/wangzhiqiang/loop
    4. 
   
  
  
  
  4. 021dc000-021fd000 rw-p 00000000 00:00 0                                  [heap]
    5. 
   
  
  
  
  5. 7f2adae2a000-7f2adafea000 r-xp 00000000 08:01 8661324                    /lib/x86_64-linux-gnu/libc-2.23.so
    6. 
   
  
  
  
  6. 7f2adafea000-7f2adb1ea000 ---p 001c0000 08:01 8661324                    /lib/x86_64-linux-gnu/libc-2.23.so
    7. 
   
  
  
  
  7. 7f2adb1ea000-7f2adb1ee000 r--p 001c0000 08:01 8661324                    /lib/x86_64-linux-gnu/libc-2.23.so
    8. 
   
  
  
  
  8. 7f2adb1ee000-7f2adb1f0000 rw-p 001c4000 08:01 8661324                    /lib/x86_64-linux-gnu/libc-2.23.so
    9. 
   
  
  
  
  9. 7f2adb1f0000-7f2adb1f4000 rw-p 00000000 00:00 0
    10. 
   
  
  
  
  10. 7f2adb1f4000-7f2adb21a000 r-xp 00000000 08:01 8661310                    /lib/x86_64-linux-gnu/ld-2.23.so
    11. 
   
  
  
  
  11. 7f2adb3fa000-7f2adb3fd000 rw-p 00000000 00:00 0
    12. 
   
  
  
  
  12. 7f2adb419000-7f2adb41a000 r--p 00025000 08:01 8661310                    /lib/x86_64-linux-gnu/ld-2.23.so
    13. 
   
  
  
  
  13. 7f2adb41a000-7f2adb41b000 rw-p 00026000 08:01 8661310                    /lib/x86_64-linux-gnu/ld-2.23.so
    14. 
   
  
  
  
  14. 7f2adb41b000-7f2adb41c000 rw-p 00000000 00:00 0
    15. 
   
  
  
  
  15. 7ffd51bb3000-7ffd51bd4000 rw-p 00000000 00:00 0                          [stack]
    16. 
   
  
  
  
  16. 7ffd51bdd000-7ffd51be0000 r--p 00000000 00:00 0                          [vvar]
    17. 
   
  
  
  
  17. 7ffd51be0000-7ffd51be2000 r-xp 00000000 00:00 0                          [vdso]
    18. 
   
  
  
  
  18. ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0                  [vsyscall]
    19.

看见堆地址范围021dc000-021fd000，并且可读可写，而且021dc000<0x21dc010<021fd000，这就可以确认字符串的地址在堆中，在堆中的索引是0x10(至于为什么是0x10，后面会讲到)，这时可以通过mem文件到0x21dc010地址修改内容，字符串输出的内容也会随之更改，这里通过python脚本实现此功能。

  
 
 
 
    
   
  
  
  
  1. #!/usr/bin/env python3
    2. 
   
  
  
  
  2. '''             
    3. 
   
  
  
  
  3. Locates and replaces the first occurrence of a string in the heap
    4. 
   
  
  
  
  4. of a process    
    5. 
   
  
  
  
  5. 
   
  
  
  
  6. Usage: ./read_write_heap.py PID search_string replace_by_string
    7. 
   
  
  
  
  7. Where:           
    8. 
   
  
  
  
  8. - PID is the pid of the target process
    9. 
   
  
  
  
  9. - search_string is the ASCII string you are looking to overwrite
    10. 
   
  
  
  
  10. - replace_by_string is the ASCII string you want to replace
    11. 
   
  
  
  
  11.   search_string with
    12. 
   
  
  
  
  12. '''
    13. 
   
  
  
  
  13. 
   
  
  
  
  14. import sys
    15. 
   
  
  
  
  15. 
   
  
  
  
  16. def print_usage_and_exit():
    17. 
   
  
  
  
  17.     print('Usage: {} pid search write'.format(sys.argv[0]))
    18. 
   
  
  
  
  18.     sys.exit(1)
    19. 
   
  
  
  
  19. 
   
  
  
  
  20. # check usage  
    21. 
   
  
  
  
  21. if len(sys.argv) != 4:
    22. 
   
  
  
  
  22.     print_usage_and_exit()
    23. 
   
  
  
  
  23. 
   
  
  
  
  24. # get the pid from args
    25. 
   
  
  
  
  25. pid = int(sys.argv[1])
    26. 
   
  
  
  
  26. if pid <= 0:
    27. 
   
  
  
  
  27.     print_usage_and_exit()
    28. 
   
  
  
  
  28. search_string = str(sys.argv[2])
    29. 
   
  
  
  
  29. if search_string  == "":
    30. 
   
  
  
  
  30.     print_usage_and_exit()
    31. 
   
  
  
  
  31. write_string = str(sys.argv[3])
    32. 
   
  
  
  
  32. if search_string  == "":
    33. 
   
  
  
  
  33.     print_usage_and_exit()
    34. 
   
  
  
  
  34. 
   
  
  
  
  35. # open the maps and mem files of the process
    36. 
   
  
  
  
  36. maps_filename = "/proc/{}/maps".format(pid)
    37. 
   
  
  
  
  37. print("[*] maps: {}".format(maps_filename))
    38. 
   
  
  
  
  38. mem_filename = "/proc/{}/mem".format(pid)
    39. 
   
  
  
  
  39. print("[*] mem: {}".format(mem_filename))
    40. 
   
  
  
  
  40. 
   
  
  
  
  41. # try opening the maps file
    42. 
   
  
  
  
  42. try:
    43. 
   
  
  
  
  43.     maps_file = open('/proc/{}/maps'.format(pid), 'r')
    44. 
   
  
  
  
  44. except IOError as e:
    45. 
   
  
  
  
  45.     print("[ERROR] Can not open file {}:".format(maps_filename))
    46. 
   
  
  
  
  46.     print("        I/O error({}): {}".format(e.errno, e.strerror))
    47. 
   
  
  
  
  47.     sys.exit(1)
    48. 
   
  
  
  
  48. 
   
  
  
  
  49. for line in maps_file:
    50. 
   
  
  
  
  50.     sline = line.split(' ')
    51. 
   
  
  
  
  51.     # check if we found the heap
    52. 
   
  
  
  
  52.     if sline[-1][:-1] != "[heap]":
    53. 
   
  
  
  
  53.         continue
    54. 
   
  
  
  
  54.     print("[*] Found [heap]:")
    55. 
   
  
  
  
  55. 
   
  
  
  
  56.     # parse line
    57. 
   
  
  
  
  57.     addr = sline[0]
    58. 
   
  
  
  
  58.     perm = sline[1]
    59. 
   
  
  
  
  59.     offset = sline[2]
    60. 
   
  
  
  
  60.     device = sline[3]
    61. 
   
  
  
  
  61.     inode = sline[4]
    62. 
   
  
  
  
  62.     pathname = sline[-1][:-1]
    63. 
   
  
  
  
  63.     print("\tpathname = {}".format(pathname))
    64. 
   
  
  
  
  64.     print("\taddresses = {}".format(addr))
    65. 
   
  
  
  
  65.     print("\tpermisions = {}".format(perm))
    66. 
   
  
  
  
  66.     print("\toffset = {}".format(offset))
    67. 
   
  
  
  
  67.     print("\tinode = {}".format(inode))
    68. 
   
  
  
  
  68. 
   
  
  
  
  69.     # check if there is read and write permission
    70. 
   
  
  
  
  70.     if perm[0] != 'r' or perm[1] != 'w':
    71. 
   
  
  
  
  71.         print("[*] {} does not have read/write permission".format(pathname))
    72. 
   
  
  
  
  72.         maps_file.close()
    73. 
   
  
  
  
  73.         exit(0)
    74. 
   
  
  
  
  74. 
   
  
  
  
  75.     # get start and end of the heap in the virtual memory
    76. 
   
  
  
  
  76.     addr = addr.split("-")
    77. 
   
  
  
  
  77.     if len(addr) != 2: # never trust anyone, not even your OS :)
    78. 
   
  
  
  
  78.         print("[*] Wrong addr format")
    79. 
   
  
  
  
  79.         maps_file.close()
    80. 
   
  
  
  
  80.         exit(1)
    81. 
   
  
  
  
  81.     addr_start = int(addr[0], 16)
    82. 
   
  
  
  
  82.     addr_end = int(addr[1], 16)
    83. 
   
  
  
  
  83.     print("\tAddr start [{:x}] | end [{:x}]".format(addr_start, addr_end))
    84. 
   
  
  
  
  84. 
   
  
  
  
  85.     # open and read mem
    86. 
   
  
  
  
  86.     try:
    87. 
   
  
  
  
  87.         mem_file = open(mem_filename, 'rb+')
    88. 
   
  
  
  
  88.     except IOError as e:
    89. 
   
  
  
  
  89.         print("[ERROR] Can not open file {}:".format(mem_filename))
    90. 
   
  
  
  
  90.         print("        I/O error({}): {}".format(e.errno, e.strerror))
    91. 
   
  
  
  
  91.         maps_file.close()
    92. 
   
  
  
  
  92.         exit(1)
    93. 
   
  
  
  
  93. 
   
  
  
  
  94.     # read heap  
    95. 
   
  
  
  
  95.     mem_file.seek(addr_start)
    96. 
   
  
  
  
  96.     heap = mem_file.read(addr_end - addr_start)
    97. 
   
  
  
  
  97. 
   
  
  
  
  98.     # find string
    99. 
   
  
  
  
  99.     try:
    100. 
   
  
  
  
  100.         i = heap.index(bytes(search_string, "ASCII"))
    101. 
   
  
  
  
  101.     except Exception:
    102. 
   
  
  
  
  102.         print("Can't find '{}'".format(search_string))
    103. 
   
  
  
  
  103.         maps_file.close()
    104. 
   
  
  
  
  104.         mem_file.close()
    105. 
   
  
  
  
  105.         exit(0)
    106. 
   
  
  
  
  106.     print("[*] Found '{}' at {:x}".format(search_string, i))
    107. 
   
  
  
  
  107. 
   
  
  
  
  108.     # write the new string
    109. 
   
  
  
  
  109.     print("[*] Writing '{}' at {:x}".format(write_string, addr_start + i))
    110. 
   
  
  
  
  110.     mem_file.seek(addr_start + i)
    111. 
   
  
  
  
  111.     mem_file.write(bytes(write_string, "ASCII"))
    112. 
   
  
  
  
  112. 
   
  
  
  
  113.     # close files
    114. 
   
  
  
  
  114.     maps_file.close()
    115. 
   
  
  
  
  115.     mem_file.close()
    116. 
   
  
  
  
  116. 
   
  
  
  
  117.     # there is only one heap in our example
    118. 
   
  
  
  
  118.     break
    119.

运行这个Python脚本

  
 
 
 
    
   
  
  
  
  1. zjucad@zjucad-ONDA-H110-MINI-V3-01:~/wangzhiqiang$ sudo ./loop.py 2542 test_memory test_hello
    2. 
   
  
  
  
  2. [*] maps: /proc/2542/maps
    3. 
   
  
  
  
  3. [*] mem: /proc/2542/mem
    4. 
   
  
  
  
  4. [*] Found [heap]:
    5. 
   
  
  
  
  5.         pathname = [heap]
    6. 
   
  
  
  
  6.         addresses = 021dc000-021fd000
    7. 
   
  
  
  
  7.         permisions = rw-p
    8. 
   
  
  
  
  8.         offset = 00000000
    9. 
   
  
  
  
  9.         inode = 0
    10. 
   
  
  
  
  10.         Addr start [21dc000] | end [21fd000]
    11. 
   
  
  
  
  11. [*] Found 'test_memory' at 10
    12. 
   
  
  
  
  12. [*] Writing 'test_hello' at 21dc010
    13.

同时字符串输出的内容也已更改

  
 
 
 
    
   
  
  
  
  1. [633] test_memory (0x21dc010)
    2. 
   
  
  
  
  2. [634] test_memory (0x21dc010)
    3. 
   
  
  
  
  3. [635] test_memory (0x21dc010)
    4. 
   
  
  
  
  4. [636] test_memory (0x21dc010)
    5. 
   
  
  
  
  5. [637] test_memory (0x21dc010)
    6. 
   
  
  
  
  6. [638] test_memory (0x21dc010)
    7. 
   
  
  
  
  7. [639] test_memory (0x21dc010)
    8. 
   
  
  
  
  8. [640] test_helloy (0x21dc010)
    9. 
   
  
  
  
  9. [641] test_helloy (0x21dc010)
    10. 
   
  
  
  
  10. [642] test_helloy (0x21dc010)
    11. 
   
  
  
  
  11. [643] test_helloy (0x21dc010)
    12. 
   
  
  
  
  12. [644] test_helloy (0x21dc010)
    13. 
   
  
  
  
  13. [645] test_helloy (0x21dc010)
    14.

实验成功。

通过实践画出虚拟内存空间分布图

再列出内存空间分布图

基本上每个人或多或少都了解虚拟内存的空间分布，那如何验证它呢，下面会提到。

堆栈空间

首先验证栈空间的位置，我们都知道C中局部变量是存储在栈空间的，malloc分配的内存是存储在堆空间，所以可以通过打印出局部变量地址和malloc的返回内存地址的方式来验证堆栈空间在整个虚拟空间中的位置。

  
 
 
 
    
   
  
  
  
  1. #include 
    2. 
   
  
  
  
  2. #include 
    3. 
   
  
  
  
  3. #include 
    4. 
   
  
  
  
  4. 
   
  
  
  
  5. /**
    6. 
   
  
  
  
  6.  * main - print locations of various elements
    7. 
   
  
  
  
  7.  *
    8. 
   
  
  
  
  8.  * Return: EXIT_FAILURE if something failed. Otherwise EXIT_SUCCESS
    9. 
   
  
  
  
  9.  */
    10. 
   
  
  
  
  10. int main(void)
    11. 
   
  
  
  
  11. {
    12. 
   
  
  
  
  12.     int a;
    13. 
   
  
  
  
  13.     void *p;
    14. 
   
  
  
  
  14. 
   
  
  
  
  15.     printf("Address of a: %p\n", (void *)&a);
    16. 
   
  
  
  
  16.     p = malloc(98);
    17. 
   
  
  
  
  17.     if (p == NULL)
    18. 
   
  
  
  
  18.     {
    19. 
   
  
  
  
  19.         fprintf(stderr, "Can't malloc\n");
    20. 
   
  
  
  
  20.         return (EXIT_FAILURE);
    21. 
   
  
  
  
  21.     }
    22. 
   
  
  
  
  22.     printf("Allocated space in the heap: %p\n", p);
    23. 
   
  
  
  
  23.     return (EXIT_SUCCESS);
    24. 
   
  
  
  
  24. }
    25. 
   
  
  
  
  25. 编译运行:gcc -Wall -Wextra -pedantic -Werror main.c -o test; ./test
    26. 
   
  
  
  
  26. 输出：
    27. 
   
  
  
  
  27. Address of a: 0x7ffedde9c7fc
    28. 
   
  
  
  
  28. Allocated space in the heap: 0x55ca5b360670
    29.

通过结果可以看出堆地址空间在栈地址空间下面，整理如图:

可执行程序

可执行程序也在虚拟内存中，可以通过打印main函数的地址，并与堆栈地址相比较，即可知道可执行程序地址相对于堆栈地址的分布。

  
 
 
 
    
   
  
  
  
  1. #include 
    2. 
   
  
  
  
  2. #include 
    3. 
   
  
  
  
  3. #include 
    4. 
   
  
  
  
  4. 
   
  
  
  
  5. /**
    6. 
   
  
  
  
  6.  * main - print locations of various elements
    7. 
   
  
  
  
  7.  *
    8. 
   
  
  
  
  8.  * Return: EXIT_FAILURE if something failed. Otherwise EXIT_SUCCESS
    9. 
   
  
  
  
  9.  */
    10. 
   
  
  
  
  10. int main(void)
    11. 
   
  
  
  
  11. {
    12. 
   
  
  
  
  12.     int a;
    13. 
   
  
  
  
  13.     void *p;
    14. 
   
  
  
  
  14. 
   
  
  
  
  15.     printf("Address of a: %p\n", (void *)&a);
    16. 
   
  
  
  
  16.     p = malloc(98);
    17. 
   
  
  
  
  17.     if (p == NULL)
    18. 
   
  
  
  
  18.     {
    19. 
   
  
  
  
  19.         fprintf(stderr, "Can't malloc\n");
    20. 
   
  
  
  
  20.         return (EXIT_FAILURE);
    21. 
   
  
  
  
  21.     }
    22. 
   
  
  
  
  22.     printf("Allocated space in the heap: %p\n", p);
    23. 
   
  
  
  
  23.     printf("Address of function main: %p\n", (void *)main);
    24. 
   
  
  
  
  24.     return (EXIT_SUCCESS);
    25. 
   
  
  
  
  25. }
    26. 
   
  
  
  
  26. 编译运行:gcc main.c -o test; ./test
    27. 
   
  
  
  
  27. 输出：
    28. 
   
  
  
  
  28. Address of a: 0x7ffed846de2c
    29. 
   
  
  
  
  29. Allocated space in the heap: 0x561b9ee8c670
    30. 
   
  
  
  
  30. Address of function main: 0x561b9deb378a
    31.

由于main(0x561b9deb378a) < heap(0x561b9ee8c670) < (0x7ffed846de2c)，可以画出分布图如下:

virtual_memory_stack_heap_executable.png

命令行参数和环境变量

程序入口main函数可以携带参数:

  • 第一个参数(argc): 命令行参数的个数
  • 第二个参数(argv): 指向命令行参数数组的指针
  • 第三个参数(env): 指向环境变量数组的指针

通过程序可以看见这些元素在虚拟内存中的位置：

  
 
 
 
    
   
  
  
  
  1. #include 
    2. 
   
  
  
  
  2. #include 
    3. 
   
  
  
  
  3. #include 
    4. 
   
  
  
  
  4. 
   
  
  
  
  5. /**
    6. 
   
  
  
  
  6.  * main - print locations of various elements
    7. 
   
  
  
  
  7.  *
    8. 
   
  
  
  
  8.  * Return: EXIT_FAILURE if something failed. Otherwise EXIT_SUCCESS
    9. 
   
  
  
  
  9.  */
    10. 
   
  
  
  
  10. int main(int ac, char **av, char **env)
    11. 
   
  
  
  
  11. {
    12. 
   
  
  
  
  12.         int a;
    13. 
   
  
  
  
  13.         void *p;
    14. 
   
  
  
  
  14.         int i;
    15. 
   
  
  
  
  15. 
   
  
  
  
  16.         printf("Address of a: %p\n", (void *)&a);
    17. 
   
  
  
  
  17.         p = malloc(98);
    18. 
   
  
  
  
  18.         if (p == NULL)
    19. 
   
  
  
  
  19.         {
    20. 
   
  
  
  
  20.                 fprintf(stderr, "Can't malloc\n");
    21. 
   
  
  
  
  21.                 return (EXIT_FAILURE);
    22. 
   
  
  
  
  22.         }
    23. 
   
  
  
  
  23.         printf("Allocated space in the heap: %p\n", p);
    24. 
   
  
  
  
  24.         printf("Address of function main: %p\n", (void *)main);
    25. 
   
  
  
  
  25.         printf("First bytes of the main function:\n\t");
    26. 
   
  
  
  
  26.         for (i = 0; i < 15; i++)
    27. 
   
  
  
  
  27.         {
    28. 
   
  
  
  
  28.                 printf("%02x ", ((unsigned char *)main)[i]);
    29. 
   
  
  
  
  29.         }
    30. 
   
  
  
  
  30.         printf("\n");
    31. 
   
  
  
  
  31.         printf("Address of the array of arguments: %p\n", (void *)av);
    32. 
   
  
  
  
  32.         printf("Addresses of the arguments:\n\t");
    33. 
   
  
  
  
  33.         for (i = 0; i < ac; i++)
    34. 
   
  
  
  
  34.         {
    35. 
   
  
  
  
  35.                 printf("[%s]:%p ", av[i], av[i]);
    36. 
   
  
  
  
  36.         }
    37. 
   
  
  
  
  37.         printf("\n");
    38. 
   
  
  
  
  38.         printf("Address of the array of environment variables: %p\n", (void *)env);
    39. 
   
  
  
  
  39.     printf("Address of the first environment variable: %p\n", (void *)(env[0]));
    40. 
   
  
  
  
  40.         return (EXIT_SUCCESS);
    41. 
   
  
  
  
  41. }
    42. 
   
  
  
  
  42. 编译运行:gcc main.c -o test; ./test nihao hello
    43. 
   
  
  
  
  43. 输出：
    44. 
   
  
  
  
  44. Address of a: 0x7ffcc154a748
    45. 
   
  
  
  
  45. Allocated space in the heap: 0x559bd1bee670
    46. 
   
  
  
  
  46. Address of function main: 0x559bd09807ca
    47. 
   
  
  
  
  47. First bytes of the main function:
    48. 
   
  
  
  
  48.         55 48 89 e5 48 83 ec 40 89 7d dc 48 89 75 d0
    49. 
   
  
  
  
  49. Address of the array of arguments: 0x7ffcc154a848
    50. 
   
  
  
  
  50. Addresses of the arguments:
    51. 
   
  
  
  
  51.         [./test]:0x7ffcc154b94f [nihao]:0x7ffcc154b956 [hello]:0x7ffcc154b95c
    52. 
   
  
  
  
  52. Address of the array of environment variables: 0x7ffcc154a868
    53. 
   
  
  
  
  53. Address of the first environment variable: 0x7ffcc154b962
    54.

结果如下：

main(0x559bd09807ca) < heap(0x559bd1bee670) < stack(0x7ffcc154a748) < argv(0x7ffcc154a848) < env(0x7ffcc154a868) < arguments(0x7ffcc154b94f->0x7ffcc154b95c + 6)(6为hello+1('\0')) < env first(0x7ffcc154b962)

可以看出所有的命令行参数都是相邻的，并且紧接着就是环境变量。

argv和env数组地址是相邻的吗

上例中argv有4个元素，命令行中有三个参数，还有一个NULL指向标记数组的末尾，每个指针是8字节，8*4=32, argv(0x7ffcc154a848) + 32(0x20) = env(0x7ffcc154a868)，所以argv和env数组指针是相邻的.

命令行参数地址紧随环境变量地址之后吗

首先需要获取环境变量数组的大小，环境变量数组是以NULL结束的，所以可以遍历env数组，检查是否为NULL，获取数组大小，代码如下：

  
 
 
 
    
   
  
  
  
  1. #include 
    2. 
   
  
  
  
  2. #include 
    3. 
   
  
  
  
  3. #include 
    4. 
   
  
  
  
  4. 
   
  
  
  
  5. /**                                                                                                      
    6. 
   
  
  
  
  6.  * main - print locations of various elements                                                            
    7. 
   
  
  
  
  7.  *                                                                                                       
    8. 
   
  
  
  
  8.  * Return: EXIT_FAILURE if something failed. Otherwise EXIT_SUCCESS                                      
    9. 
   
  
  
  
  9.  */
    10. 
   
  
  
  
  10. int main(int ac, char **av, char **env)
    11. 
   
  
  
  
  11. {
    12. 
   
  
  
  
  12.      int a;
    13. 
   
  
  
  
  13.      void *p;
    14. 
   
  
  
  
  14.      int i;
    15. 
   
  
  
  
  15.      int size;
    16. 
   
  
  
  
  16. 
   
  
  
  
  17.      printf("Address of a: %p\n", (void *)&a);
    18. 
   
  
  
  
  18.      p = malloc(98);
    19. 
   
  
  
  
  19.      if (p == NULL)
    20. 
   
  
  
  
  20.      {
    21. 
   
  
  
  
  21.           fprintf(stderr, "Can't malloc\n");
    22. 
   
  
  
  
  22.           return (EXIT_FAILURE);
    23. 
   
  
  
  
  23.      }
    24. 
   
  
  
  
  24.      printf("Allocated space in the heap: %p\n", p);
    25. 
   
  
  
  
  25.      printf("Address of function main: %p\n", (void *)main);
    26. 
   
  
  
  
  26.      printf("First bytes of the main function:\n\t");
    27. 
   
  
  
  
  27.      for (i&n            
    
                当前题目：10张图22段代码，万字长文带你搞懂虚拟内存模型和Malloc内部原理
                
    
                当前地址：http://www.csdahua.cn/qtweb/news22/299272.html
            
    
            
    
                网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                快上网

成都快上网为您推荐相关内容

微信小程序知识

各行业网站

营销网站建设　　 　视频运营　　 　东电技服　　 　简阳电信机房　　 　成都企业网站建设　　 　虚拟主机　　 　乐山网站建设　　 　成都工商注册代办　　 　中国电信西部信息中心机房　　 　成都门户网站建设设计方案　　 　雅安做网站　　 　雅安机房托管　　 　微信小程序开发　　 　成都做网站　　 　联通机柜租用　　 　php空间　　 　短视频拍摄　　 　网站推广营销　　 　模板商城网站　　 　装饰公司网站建设方案