Linux用户空间将虚拟地址转化为物理地址

最新推荐文章于 2024-08-05 17:46:58 发布
最新推荐文章于 2024-08-05 17:46:58 发布
阅读量5.4k 收藏 48
点赞数 4
分类专栏： 【基础知识】 【Linux内核】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Rong_Toa/article/details/108983905
版权

目录

引言

地址绑定

MMU（内存管理单元）

基本硬件

进程如何从磁盘映射到内存

磁盘和内存的映射过程

MMU方案

开始编码

创建我们的缓冲区

/proc/[pid]/pagemap

写 /dev/mem

结论和完整代码清单

DPDK是如何操作的？

推荐文章

 

引言

在理解“了解Linux内核”中有关内存管理的章节中，我认为尝试编写将虚拟内存地址转换为物理地址的程序会很有趣。而且，我想在用户空间上使用它。再进一步，为什么不尝试获取缓冲区的物理地址，转到内存中的该位置，对其进行修改，然后使用虚拟地址查看更改。

尝试在用户空间中完成此任务存在一些问题：

  • 虚拟内存背后的想法是提供连续内存的地址空间。进程的内存很可能存储在不连续的块中。
  • 没有保证page在系统的物理内存中。它可以在交换区或缓存中。可能没有实际地址！
  • 出于安全原因，即使进程的UID为0，进程也无权访问系统的原始内存。

我们可以采用两种方法来获取物理地址：

  1. 给内核添加一个系统调用，给定一个虚拟地址，它将返回物理地址。但是，修改内核违反了从用户空间执行所有操作的规则，因此我们必须将其排除在外。
  2. 将page映射文件用于进程（内核2.6.25中已添加）以获取页面映射到的帧，然后使用该页面查找/dev/mem并修改那里的缓冲区。

使用这种方法，完全有可能在用户空间中将虚拟地址转换为物理地址。但是，要验证我们的翻译是正确的，需要阅读/dev/mem。这确实需要对内核进行一次小的修改（更改配置选项），但稍后会进行更多修改。

内存由大量word或array组成，每个word或array都有与之关联的地址。现在，CPU的工作是从基于内存的程序计数器中获取指令。现在，这些指令可能会导致加载或存储到特定的存储器地址。地址绑定是从一个地址空间映射到另一地址空间的过程。逻辑地址是CPU在执行过程中生成的地址，而物理地址是指存储单元（已加载到内存中的单元）中的位置。请注意，用户仅处理逻辑地址（虚拟地址）。逻辑地址尤其由MMU或地址转换单元进行转换。该过程的输出是适当的物理地址或代码/数据在RAM中的位置。

 

地址绑定

地址绑定可以通过三种不同的方式完成：

  1. 编译时间–如果您知道在编译期间进程将驻留在内存中，则会生成绝对地址，即在编译过程中将物理地址嵌入到程序的可执行文件中。将可执行文件作为进程加载到内存中的速度非常快。但是，如果生成的地址空间被其他进程所占用，则程序将崩溃，并且有必要重新编译程序以更改地址空间。
  2. 加载时间–如果在编译时不知道进程将驻留在哪里，则将生成可重定位的地址。加载程序将可重定位地址转换为绝对地址。加载程序将主存储器中进程的基地址添加到所有逻辑地址中，以生成绝对地址。在这种情况下，如果进程的基址发生更改，则我们需要再次重新加载进程。
  3. 执行时间-指令在内存中，正在由CPU处理。此时可以分配和/或释放其他内存。如果可以在执行期间将进程从一个内存移动到另一个内存（动态链接-在加载或运行时完成链接），则使用此方法。例如–压实。

 

MMU（内存管理单元）

虚拟地址和物理地址之间的运行时映射是通过称为MMU的硬件设备完成的。

在内存管理中，操作系统将处理进程并在磁盘和内存之间移动进程以执行。它跟踪可用和已使用的内存。

指令执行周期包括以下步骤：

  1. 从存储器中获取第一条指令，例如ADD A，B
  2. 然后将这些指令解码，即A和B的加法
  3. 然后在某个特定的存储位置进行进一步的加载或存储。

基本硬件

由于主存储器和寄存器内置在处理器中，CPU只能访问它们，因此每条指令都应写入直接访问存储
设备中。

  1. 如果从寄存器访问CPU指令，则由于寄存器内置在CPU中，因此可以在一个CPU时钟周期内完成。
  2. 如果指令驻留在主存储器中，那么它将通过存储器总线进行访问，这将花费大量时间。因此，对此的补救措施是在CPU和主内存之间添加快速内存，即为事务添加缓存。
  3. 现在，我们应该确保流程位于法定地址内。
  4. 合法地址由基址寄存器（拥有最小的物理地址）和限制寄存器（范围的大小）组成。

例如：

基址寄存器= 300040
限制寄存器= 120900 
那么合法地址=（300040 + 120900）= 420940（含）。
法定地址=基本寄存器+限制寄存器

 

进程如何从磁盘映射到内存

  1. 通常，进程以二进制可执行文件的形式驻留在磁盘中。
  2. 因此，执行过程应驻留在主存储器中。
  3. 根据使用的内存管理，进程从磁盘移动到内存。
  4. 进程以就绪队列的形式在磁盘中等待以获取内存。

 

磁盘和内存的映射过程

正常过程是从输入队列中选择进程并将其加载到内存中。进程执行时，它将访问内存中的数据和指令，一旦完成，它将释放内存，现在内存可用于其他进程。

 

MMU方案

 CPU ------- MMU ------内存

  1. CPU将为例如346生成逻辑地址
  2. MMU将为例如：14000生成重定位寄存器（基址寄存器）
  3. 内存中的物理地址位于例如：（346 + 14000 = 14346）

图来源：https://users.dimi.uniud.it/~antonio.dangelo/OpSys/materials/Operating_System_Concepts.pdf
本文由Vaishali Bhatia贡献。如果您喜欢GeeksforGeeks并且愿意做出贡献，那么您也可以使用contribution.geeksforgeeks.org撰写文章或将您的文章邮寄至contribution@geeksforgeeks.org。查看您的文章出现在GeeksforGeeks主页上，并帮助其他Geeks。

 

开始编码

创建我们的缓冲区

除了通常的malloc()调用之外，创建缓冲区以查找地址的过程还需要另外一步。内核不保证虚拟地址空间中的地址实际映射到内存中的物理地址。它可以存储在交换空间中，某个地方或整个地方的缓存中。为了避免这种可能性，我们可以mlock()用来强制将页面保留在系统的物理内存中。幸运的是，这很简单。只需将mlock()指针传递到缓冲区和缓冲区的大小，它将处理其余的内容。看起来像这样：

void* create_buffer(void) {
   size_t buf_size = strlen(ORIG_BUFFER) + 1;

   // Allocate some memory to manipulate
   void *buffer = malloc(buf_size);
   if(buffer == NULL) {
      fprintf(stderr, "Failed to allocate memory for buffer\n");
      exit(1);
   }

   // Lock the page in memory
   // Do this before writing data to the buffer so that any copy-on-write
   // mechanisms will give us our own page locked in memory
   if(mlock(buffer, buf_size) == -1) {
      fprintf(stderr, "Failed to lock page in memory: %s\n", strerror(errno));
      exit(1);
   }

   // Add some data to the memory
   strncpy(buffer, ORIG_BUFFER, strlen(ORIG_BUFFER));

   return buffer;
}

请注意，锁定后我将数据复制到缓冲区中。这是因为如果缓冲区所在的页面与父进程共享，则OS可能会采用写时复制分页机制。为了强制操作系统提供我们自己的页面，我们将数据锁定后写入缓冲区。

 

/proc/[pid]/pagemap

页面映射为用户提供了访问空间，以访问内核如何管理进程页面。这是一个二进制文件，因此从中提取信息有些棘手。

从文档1中可以看到，每页有64位信息。我们对页帧号0-54位感兴趣。

我们如何从页面地图中获取给定页面的页面框架号？首先，我们需要确定要映射到页面地图中的偏移量。可以这样进行：

#define PAGEMAP_LENGTH 8
offset = (unsigned long)addr / getpagesize() * PAGEMAP_LENGTH

给定一个地址，我们将其除以页面大小，然后乘以8。为什么是8？每页有64位或8字节的信息。

然后，我们在文件中寻找该位置并读取前7个字节。为什么是7？我们对咬伤0-54感兴趣。总共有55位。因此，我们读取了前7个字节（56位）并清除了位55。位55是我们不关心的软脏标志。

unsigned long get_page_frame_number_of_address(void *addr) {
   // Open the pagemap file for the current process
   FILE *pagemap = fopen("/proc/self/pagemap", "rb");

   // Seek to the page that the buffer is on
   unsigned long offset = (unsigned long)addr / getpagesize() * PAGEMAP_LENGTH;
   if(fseek(pagemap, (unsigned long)offset, SEEK_SET) != 0) {
      fprintf(stderr, "Failed to seek pagemap to proper location\n");
      exit(1);
   }

   // The page frame number is in bits 0-54 so read the first 7 bytes and clear the 55th bit
   unsigned long page_frame_number = 0;
   fread(&page_frame_number, 1, PAGEMAP_LENGTH-1, pagemap);

   page_frame_number &= 0x7FFFFFFFFFFFFF;

   fclose(pagemap);

   return page_frame_number;
}

现在我们有了页面帧号，我们可以轻松计算出缓冲区的物理地址，例如2：

physcial_addr = (page_frame_number << PAGE_SHIFT) + distance_from_page_boundary_of_buffer

PAGE_SHIFT内核#define在哪里。对于我的x86_64系统，它定义为12，但这可能因您而异。您应该自己查看内核源代码来确认该值。

 

写 /dev/mem

现在我们已经确定了物理地址，我们可以继续在内存中找到该位置并对其进行修改。

Linux通过/dev/mem块设备提供对系统内存的直接访问。但是，由于明显的安全隐患，即使是root用户，也无法读取（更不用说写入）该文件了。这是由于CONFIG_STRICT_DEVMEM内核配置选项。作为配置选项，必须在编译时设置它，以便更改它，您必须重新编译内核。

内核的编译和安装会因发行版的不同而有所差异，因此在此不再赘述。如果您已经熟悉该过程，则只需CONFIG_STRICT_DEVMEM=n在配置中设置，重新编译，安装和重新启动即可。希望所有虚拟机都存在，因为这显然会带来巨大的安全漏洞。

假设您的内核已CONFIG_STRICT_DEVMEM禁用，我们可以继续。首先是要知道在哪里寻找/dev/mem我们放入缓冲区的字符串。实际上，这很简单。我们需要寻找的偏移量等于我们上面计算的物理地址。

// Find the difference from the buffer to the page boundary
unsigned int distance_from_page_boundary = (unsigned long)buffer % getpagesize();

// Determine how far to seek into memory to find the buffer
uint64_t offset = (page_frame_number << PAGE_SHIFT) + distance_from_page_boundary;

现在让我们打开/dev/mem并寻找我们计算出的偏移量：

int open_memory(void) {
   // Open the memory (must be root for this)
   int fd = open("/dev/mem", O_RDWR);

   if(fd == -1) {
      fprintf(stderr, "Error opening /dev/mem: %s\n", strerror(errno));
      exit(1);
   }

   return fd;
}

void seek_memory(int fd, unsigned long offset) {
   unsigned pos = lseek(fd, offset, SEEK_SET);

   if(pos == -1) {
      fprintf(stderr, "Failed to seek /dev/mem: %s\n", strerror(errno));
      exit(1);
   }
}

int mem_fd = open_memory();
seek_memory(mem_fd, offset);

快完成了！我们在内部找到了正确的文件描述符，/dev/mem所以现在我们只需要写3。

if(write(mem_fd, NEW_BUFFER, strlen(NEW_BUFFER)) == -1) {
   fprintf(stderr, "Write failed: %s\n", strerror(errno));
}

请注意，NEW_BUFFER长度必须等于或短于ORIG_BUFFER。就我而言，我将它们定义为相同的长度，因此我不必费心复制NUL终止符。

最后，我们可以从原始缓冲区中读取内容，如果一切正常，我们将看到通过写入更改了缓冲区的内容/dev/mem。

printf("Buffer: %s\n", buffer);

 

结论和完整代码清单

值得注意的是，这只是一个实验。这并不是要依赖的行为。实际上，在我的测试中，我体验了内核在计算偏移量以查找该偏移量并将数据写入该偏移量之间的时间在物理地址周围乱码的情况。底线是：坚持虚拟内​​存；它真的很好。而且，如果您需要从用户空间修改物理内存，请寻找另一种方法。

完整代码清单：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/mman.h>
#include <errno.h>
#include <fcntl.h>
#include <stdint.h>

// ORIG_BUFFER will be placed in memory and will then be changed to NEW_BUFFER
// They must be the same length
#define ORIG_BUFFER "Hello, World!"
#define NEW_BUFFER "Hello, Linux!"

// The page frame shifted left by PAGE_SHIFT will give us the physcial address of the frame
// Note that this number is architecture dependent. For me on x86_64 with 4096 page sizes,
// it is defined as 12. If you're running something different, check the kernel source
// for what it is defined as.
#define PAGE_SHIFT 12
#define PAGEMAP_LENGTH 8

void* create_buffer(void);
unsigned long get_page_frame_number_of_address(void *addr);
int open_memory(void);
void seek_memory(int fd, unsigned long offset);

int main(void) {
   // Create a buffer with some data in it
   void *buffer = create_buffer();

   // Get the page frame the buffer is on
   unsigned int page_frame_number = get_page_frame_number_of_address(buffer);
   printf("Page frame: 0x%x\n", page_frame_number);

   // Find the difference from the buffer to the page boundary
   unsigned int distance_from_page_boundary = (unsigned long)buffer % getpagesize();

   // Determine how far to seek into memory to find the buffer
   uint64_t offset = (page_frame_number << PAGE_SHIFT) + distance_from_page_boundary;

   // Open /dev/mem, seek the calculated offset, and
   // map it into memory so we can manipulate it
   // CONFIG_STRICT_DEVMEM must be disabled for this
   int mem_fd = open_memory();
   seek_memory(mem_fd, offset);

   printf("Buffer: %s\n", buffer);
   puts("Changing buffer through /dev/mem...");

   // Change the contents of the buffer by writing into /dev/mem
   // Note that since the strings are the same length, there's no purpose in
   // copying the NUL terminator again
   if(write(mem_fd, NEW_BUFFER, strlen(NEW_BUFFER)) == -1) {
      fprintf(stderr, "Write failed: %s\n", strerror(errno));
   }

   printf("Buffer: %s\n", buffer);

   // Clean up
   free(buffer);
   close(mem_fd);

   return 0;
}

void* create_buffer(void) {
   size_t buf_size = strlen(ORIG_BUFFER) + 1;

   // Allocate some memory to manipulate
   void *buffer = malloc(buf_size);
   if(buffer == NULL) {
      fprintf(stderr, "Failed to allocate memory for buffer\n");
      exit(1);
   }

   // Lock the page in memory
   // Do this before writing data to the buffer so that any copy-on-write
   // mechanisms will give us our own page locked in memory
   if(mlock(buffer, buf_size) == -1) {
      fprintf(stderr, "Failed to lock page in memory: %s\n", strerror(errno));
      exit(1);
   }

   // Add some data to the memory
   strncpy(buffer, ORIG_BUFFER, strlen(ORIG_BUFFER));

   return buffer;
}

unsigned long get_page_frame_number_of_address(void *addr) {
   // Open the pagemap file for the current process
   FILE *pagemap = fopen("/proc/self/pagemap", "rb");

   // Seek to the page that the buffer is on
   unsigned long offset = (unsigned long)addr / getpagesize() * PAGEMAP_LENGTH;
   if(fseek(pagemap, (unsigned long)offset, SEEK_SET) != 0) {
      fprintf(stderr, "Failed to seek pagemap to proper location\n");
      exit(1);
   }

   // The page frame number is in bits 0-54 so read the first 7 bytes and clear the 55th bit
   unsigned long page_frame_number = 0;
   fread(&page_frame_number, 1, PAGEMAP_LENGTH-1, pagemap);

   page_frame_number &= 0x7FFFFFFFFFFFFF;

   fclose(pagemap);

   return page_frame_number;
}

int open_memory(void) {
   // Open the memory (must be root for this)
   int fd = open("/dev/mem", O_RDWR);

   if(fd == -1) {
      fprintf(stderr, "Error opening /dev/mem: %s\n", strerror(errno));
      exit(1);
   }

   return fd;
}

void seek_memory(int fd, unsigned long offset) {
   unsigned pos = lseek(fd, offset, SEEK_SET);

   if(pos == -1) {
      fprintf(stderr, "Failed to seek /dev/mem: %s\n", strerror(errno));
      exit(1);
   }
}

 

DPDK是如何操作的？



#define _FILE_OFFSET_BITS 64
#include <errno.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/queue.h>
#include <sys/file.h>
#include <unistd.h>
#include <limits.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <signal.h>
#include <setjmp.h>
#ifdef RTE_EAL_NUMA_AWARE_HUGEPAGES
#include <numa.h>
#include <numaif.h>
#endif


#define phys_addr_t	uint64_t
static bool phys_addrs_available = true;
typedef uint64_t rte_iova_t;
#define RTE_BAD_IOVA ((rte_iova_t)-1)
#define RTE_LOG(l, t, fmt...) printf(fmt)
#define PFN_MASK_SIZE	8

enum rte_iova_mode {
	RTE_IOVA_DC = 0,	/* Don't care mode */
	RTE_IOVA_PA = (1 << 0), /* DMA using physical address */
	RTE_IOVA_VA = (1 << 1)  /* DMA using virtual address */
};

/*
 * Get physical address of any mapped virtual address in the current process.
 */
phys_addr_t rte_mem_virt2phy(const void *virtaddr)
{
	int fd, retval;
	uint64_t page, physaddr;
	unsigned long virt_pfn;
	int page_size;
	off_t offset;

	/* Cannot parse /proc/self/pagemap, no need to log errors everywhere */
	if (!phys_addrs_available)
		return RTE_BAD_IOVA;

	/* standard page size */
	page_size = getpagesize();

	fd = open("/proc/self/pagemap", O_RDONLY);
	if (fd < 0) {
		RTE_LOG(ERR, EAL, "%s(): cannot open /proc/self/pagemap: %s\n",
			__func__, strerror(errno));
		return RTE_BAD_IOVA;
	}

	virt_pfn = (unsigned long)virtaddr / page_size;
	offset = sizeof(uint64_t) * virt_pfn;
	if (lseek(fd, offset, SEEK_SET) == (off_t) -1) {
		RTE_LOG(ERR, EAL, "%s(): seek error in /proc/self/pagemap: %s\n",
				__func__, strerror(errno));
		close(fd);
		return RTE_BAD_IOVA;
	}

	retval = read(fd, &page, PFN_MASK_SIZE);
	close(fd);
	if (retval < 0) {
		RTE_LOG(ERR, EAL, "%s(): cannot read /proc/self/pagemap: %s\n",
				__func__, strerror(errno));
		return RTE_BAD_IOVA;
	} else if (retval != PFN_MASK_SIZE) {
		RTE_LOG(ERR, EAL, "%s(): read %d bytes from /proc/self/pagemap "
				"but expected %d:\n",
				__func__, retval, PFN_MASK_SIZE);
		return RTE_BAD_IOVA;
	}

	/*
	 * the pfn (page frame number) are bits 0-54 (see
	 * pagemap.txt in linux Documentation)
	 */
	if ((page & 0x7fffffffffffffULL) == 0)
		return RTE_BAD_IOVA;

	physaddr = ((page & 0x7fffffffffffffULL) * page_size)
		+ ((unsigned long)virtaddr % page_size);

	RTE_LOG(ERR, EAL, "phyaddr %p\n", (void*)physaddr);

	return physaddr;
}

rte_iova_t rte_mem_virt2iova(const void *virtaddr)
{
//	if (rte_eal_iova_mode() == RTE_IOVA_VA)
//		return (uintptr_t)virtaddr;
	return rte_mem_virt2phy(virtaddr);
}

int main()
{
	int *addr1 = malloc(10);

	printf("addr1 = %p\n", addr1);
	rte_iova_t rte_iova = rte_mem_virt2iova(addr1);

	printf("addr1 = %p, 0x%x\n", addr1, (void*)rte_iova);

	return 0;
}

 

推荐文章

将虚拟地址映射到物理地址

在用户空间中将虚拟地址转换为物理地址

用户态进程如何得到虚拟地址对应的物理地址？

操作系统中的逻辑和物理地址

物理和逻辑数据独立

物理和逻辑文件系统

物理层中的设计问题

私有和公共IP地址之间的区别

操作系统中的虚拟内存

虚拟内存| 问题

虚拟内存和缓存内存之间的区别

操作系统中的虚拟机

虚拟机和容器之间的区别

虚拟机类型

创建连接点

抢占优先级与循环调度算法的关系

cd cmd命令

https://www.kernel.org/doc/Documentation/vm/pagemap.txt

https://www.kernel.org/doc/gorman/html/understand/understand005.html

https ：//www.blackhat.com/presentations/bh-europe-09/Lineberry/BlackHat-Europe-2009-Lineberry-code-injection-via-dev-mem.pdf

 

rtoax
关注
专栏目录
Linux内存管理之高端内存
ibless的博客
08-10 6453
Linux对内存的管理划分成三个层次，分别是Node、Zone、Page。对这三个层次简介如下： 层次 说明 Node（存储节点） CPU被划分成多个节点，每个节点都有自己的一块内存，可以参考NUMA架构有关节点的介绍 Zone（管理区） 每一个Node（节点）中的内存被划分成多个管理区域（Zone），用于表示不同范围的内存 Page（页面） 每一个管理区又进...
深入Linux内核（内存篇）—用户内存空间之VMA
liyuewuwunaile的博客
07-10 6294
用户内存空间之VMA一、VMA二、VMA Flag三、VMA Find四、VMA Insert五、VMA Merge 内核管理用户空间的数据结构是struct vm_area_struct，简称VMA。 一、VMA 用户进程拥有用户空间的地址，其可以通过malloc和mmap等函数来申请内存。malloc和mmap等函数的实现都基于进程线性区描述struct vm_area_struct。 内核管理进程地址空间使用的数据结构是struct vm_area_struct，简称VMA。 对于每个进程的内存描述符
Linux下如何在进程中获取虚拟地址对应的物理地址
颖豆豆啦
10-11 3044
linux的/proc目录下记录了进程内存信息的映射，称其为虚拟目录。在/proc目录下有一个链接目录名为self，哪一个进程打开了它，它存储的信息就是该进程的。self中有一个pagemap文件，用来记录所链接进程的物理页号信息。pagemap是linux中一组新的接口集合，他通过读取/proc中的文件允许用户态的程序检查页表以及相关的信息。 /proc/pid/pagemap：这个文件允许一个
wince内存释放,wince内存释放
05-09
wince内存释放,wince内存释放,wince内存释放,wince内存释放
linux驱动：（7）物理地址到虚拟地址映射
最新发布
weixin_59669309的博客
08-05 351
在单片机和裸机中操作硬件是通过指针来对寄存器赋值来进行操控但对于linux中不能这样，不能直接对物理地址直接修改，因为linux使能了mmu，所以不能直接菜操作物理地址如果要操作硬件，需要先把物理地址转换成虚拟地址。
linux vma,VMA（虚拟内存空间）_百度百科
weixin_39980002的博客
05-29 647
VMA(虚拟内存空间)编辑锁定讨论上传视频本词条缺少概述图，补充相关内容使词条更完整，还能快速升级，赶紧来编辑吧！VMA全称为virtual memory area，指虚拟内存空间，又称作线性区，表示一个线性区间。中文名虚拟内存空间外文名virtual memory area称作称作线性区描述表示一个线性区间VMA含义简介编辑从user process 角度来说明的话，VMA 是 ...
【WINCE】使用GDI时如何正常释放内存避免内存泄漏
UniverseLin的博客
07-19 471
【WINCE】使用GDI时如何释放内存避免内存泄漏前言正文 前言 最近在做wince平台的上位机开发，因此用到了控件的重绘和图形的绘制，所以使用到了GDI。 但是在程序运行的过程中，发现wince6.0的运行内存不断增加，怀疑是GDI使用时，申请的内存未及时释放导致内存泄漏。 这是就需要了解如何正确释放申请的内存来避免内存泄漏。 正文 首先需要清楚的是，无论是CPen还是CBrush等类还是CDC，它们都有自己的申请和释放的对应关系： new -> delete; Malloc ->
Linux 转换物理地址函数,Linux中的虚拟地址转换物理地址实现
weixin_28899845的博客
05-07 788
2014 December 10 memoryLinux中的虚拟地址转换物理地址实现Linux中的虚拟地址转换物理地址实现Linux使用一种4级页表机制，即页全局目录(Page Global Directory)、页上级目录(Page Upper Directory)、页中间目录(Page Middle Directory)和页表(Page Table)。在这种分页机制下.一个完整的线性地址被分为...
用户虚拟地址转化成物理地址，物理地址转换成内核虚拟地址，内核虚拟地址转换成物理地址，虚拟地址和对应页的关系
qq_41683305的博客
05-23 1964
文章目录1. 用户虚拟地址转换成物理地址2. 内核虚拟地址转换成物理地址3. 物理地址转换成内核虚拟地址4 虚拟地址和对应页 1. 用户虚拟地址转换成物理地址 2. 内核虚拟地址转换成物理地址 3. 物理地址转换成内核虚拟地址 4 虚拟地址和对应页 ...
Linux内核分析与应用课件第2章-动手实践-把虚拟地址转换为物理地址.pdf
01-01
在Linux操作系统中，虚拟地址和物理地址是两个不同的概念，它们之间通过页表进行映射。虚拟地址是应用程序看到的内存地址，而物理地址则是内存芯片实际存储数据的位置。理解和掌握虚拟地址到物理地址的转换对于系统...
Linux系统用户态根据虚拟地址获取物理地址的方式
tugouxp的专栏
08-09 3629
之前做项目的时候，也会遇到过根据页表，由虚拟地址翻译物理地址的需求，一般的做法是HACK内核，在内核中加入HACK代码，思路无非就是通过页表进行转换，但是现在有了一种新的方式，这种方式下，不需要HACK内核，也不需要重新编译内核，便能够根据进程的虚拟地址，得到它的物理地址，下面展开介绍。
Linux进程地址空间（虚拟地址和物理地址的映射、页表）
杨同学的博客
10-17 1912
在学习 C/C++ 的时候，我们知道内存会分为几个区域：栈区、堆区、全局/静态区、代码区、字符常量区 …这只是语言层面的理解，是远远不够的，如下空间布局图，请问这是物理内存吗？—— 不是，是进程地址空间。两点结论：进程地址空间不是物理内存！进程地址空间，会在进程的整个 [生命周期] 内一直存在，直到进程退出！这也就解释了为什么全局/静态变量的生命周期是整个程序，因为全局/静态变量是随着进程一直存在的。验证地址空间的基本排布？进程地址空间究竟是什么？地址空间和物理内存之间的关系？
用/proc/pid/pagemap将虚拟地址转换为物理地址
weixin_30508309的博客
06-23 1171
kernel 在2.6.25的时候加入了这样一个功能/proc/self/pagemap 也就是在每个进程的/proc里面都有一个pagemap通过读取里面的内容就可以算出当前虚拟地址对应的物理页，然后加入page_offset就可以知道当前虚拟地址对应的物理地址。 /proc/pagemap需要你的应用有root权限才能使用。 转载于:https://www.cnblogs.com/fo...
linux内存管理之高端内存
小吕的博客
08-31 306
用户0-3G内核3-4G 所谓用户和内核对于CPU来说只是运行的级别不一样，是否处于特权级 不管用户还是内核最终都是要通过MMU映射到你的物理上的896M内存 对于任何用户进程，0~3G的映射都是不同的，但是所有用户进程3~4G的映射都是相同的 高端内存引入原因在于：如果你的物理内存是1G那刚好映射 当你的物理内存大于1G时，为了访问到所有的物理内存引入了高端内存，建立一个临时映射表去访问其它地方的内存用完了就释放掉。 ...
Linux 内存管理 —— 高端内存
Jia ming 的日常学习笔记
09-11 653
高端内存
Linux HighMemory（高端内存）
lzf的博客
07-03 3317
目前。32位的x86架构是最受欢迎的计算机架构。在这种架构中，传统上Linux内核将4GB的虚拟内存地址空间分为3GB用户内存和1GB内核空间。在传统大小的32位系统上，这意味着内核可以将所有物理内存映射到其地址空间，这使得以下内容成为可能：直接从内核中访问任何内存，这使事情变得更加简单和快捷。使用从内核对象到另一个对象的指针。 另一种方法是跟踪物理地址，映射到物理地址，并在访问之前计算结构的虚拟...
Linux内存管理 (7)VMA操作
hbcbgcx的博客
03-21 561
https://www.cnblogs.com/arnoldlu/p/8329279.html 专题：Linux内存管理专题 关键词：VMA、vm_area_struct、查找/插入/合并VMA、红黑树。 用户进程可以拥有3GB大小的空间，远大于物理内存，那么这些用户进程的虚拟地址空间是如何管理的呢？ malloc()或mmap()操作都会要求在虚拟地址空间中分配内存块，但这些内存在物理上往往都是...
linux高端内存
xqzhan的专栏
03-21 470
高端内存是指物理地址大于 896M 的内存。对于这样的内存，无法在“内核直接映射空间”进行映射。 为什么？ 　　因为“内核直接映射空间”最多只能从 3G 到 4G，只能直接映射 1G 物理内存，对于大于 1G 的物理内存，无能为力。 　　实际上，“内核直接映射空间”也达不到 1G， 还得留点线性空间给“内核动态映射空间” 呢。 　　因此，Linux 规定“内核直接映射空
wince 内存释放_解决WinCE内存不足问题
weixin_39878247的博客
12-22 361
我们采用的ti的 Omap3530， 板上有256MB SDRAM 和 512MB Nandflash. 采用的是WinCE 6.0操作系统运行应用程序时却时不时出现严重的内存不足问题。在控制面板中查了内存情况，才有40MB可用，出了NK占用的30MB，其余内存不知用到哪里了。Google几下，能够找到的信息不多。gooogleman的郁闷，怎么我的2440 PDA 的内存从90M变成31M了...
Linux内存管理笔记：虚拟地址与物理地址解析
- 内核空间：Linux内存被划分为内核空间和用户空间，内核空间通常位于地址空间的低端，如0x00000000到0xC0000000（32位系统），这部分内存只能由内核访问和管理，用于系统调用、驱动程序等。 - 用户空间：剩余的...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值