利用mmap /dev/mem 读写Linux内存 .

http://blog.csdn.net/zhanglei4214/article/details/6653568

使用 hexedit /dev/mem 可以显示所有物理内存中的信息。 运用mmap将/dev/mem map出来,然后直接对其读写可以实现用户空间的内核操作。

以下是我写的一个sample

[cpp] view plain copy print ?
  1. #include<stdio.h>   
  2. #include<unistd.h>   
  3. #include<sys/mman.h>   
  4. #include<sys/types.h>   
  5. #include<sys/stat.h>   
  6. #include<fcntl.h>   
  7.   
  8. int main()  
  9. {  
  10.     unsigned char * map_base;  
  11.     FILE *f;  
  12.     int n, fd;  
  13.   
  14.     fd = open("/dev/mem", O_RDWR|O_SYNC);  
  15.     if (fd == -1)  
  16.     {  
  17.         return (-1);  
  18.     }  
  19.   
  20.     map_base = mmap(NULL, 0xff, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x20000);  
  21.   
  22.     if (map_base == 0)  
  23.     {  
  24.         printf("NULL pointer!\n");  
  25.     }  
  26.     else  
  27.     {  
  28.         printf("Successfull!\n");  
  29.     }  
  30.   
  31.     unsigned long addr;  
  32.     unsigned char content;  
  33.   
  34.     int i = 0;  
  35.     for (;i < 0xff; ++i)  
  36.     {  
  37.         addr = (unsigned long)(map_base + i);  
  38.         content = map_base[i];  
  39.         printf("address: 0x%lx   content 0x%x\t\t", addr, (unsigned int)content);  
  40.   
  41.         map_base[i] = (unsigned char)i;  
  42.         content = map_base[i];  
  43.         printf("updated address: 0x%lx   content 0x%x\n", addr, (unsigned int)content);  
  44.     }  
  45.   
  46.     close(fd);  
  47.   
  48.     munmap(map_base, 0xff);  
  49.   
  50.     return (1);  
  51. }  
#include<stdio.h>
#include<unistd.h>
#include<sys/mman.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

int main()
{
    unsigned char * map_base;
    FILE *f;
    int n, fd;

    fd = open("/dev/mem", O_RDWR|O_SYNC);
    if (fd == -1)
    {
        return (-1);
    }

    map_base = mmap(NULL, 0xff, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x20000);

    if (map_base == 0)
    {
        printf("NULL pointer!\n");
    }
    else
    {
        printf("Successfull!\n");
    }

    unsigned long addr;
    unsigned char content;

    int i = 0;
    for (;i < 0xff; ++i)
    {
        addr = (unsigned long)(map_base + i);
        content = map_base[i];
        printf("address: 0x%lx   content 0x%x\t\t", addr, (unsigned int)content);

        map_base[i] = (unsigned char)i;
        content = map_base[i];
        printf("updated address: 0x%lx   content 0x%x\n", addr, (unsigned int)content);
    }

    close(fd);

    munmap(map_base, 0xff);

    return (1);
}

上面的例子将起始地址0x20000(物理地址), 长度为0xff映射出来。 然后就可以像普通数组一样操作内存。

下面是输出结果

address: 0x7f3f95391000   content 0x0           updated address: 0x7f3f95391000   content 0x0
address: 0x7f3f95391001   content 0x0           updated address: 0x7f3f95391001   content 0x1
address: 0x7f3f95391002   content 0x0           updated address: 0x7f3f95391002   content 0x2
address: 0x7f3f95391003   content 0x0           updated address: 0x7f3f95391003   content 0x3
address: 0x7f3f95391004   content 0x0           updated address: 0x7f3f95391004   content 0x4
。。。

我的测试机器是64位机。 该例子将物理地址0x20000映射到了虚拟地址0x7f3f95391000。

首先将当前地址下的内容输出, 然后写入新值。

可以通过 hexedit /dev/mem 验证新值已经写入。


如果想在用户态处理kernel分配的地址可以这么做。 首先用virt_addr = get_free_pages(GFP_KERNEL, order)分配内存,通过phy_addr = __pa(virt_addr)得到物理地址,然后在用户态将/dev/mem用mmap 映射出来, offset就是phy_addr, length设为 2^order。 此时就可以在用户态读写内核分配的内存了。

注:该操作需要有root权限。

 

 

Linux下读/写物理内存
来源: ChinaUnix博客  日期: 2006.07.11 15:18 (共有条评论) 我要评论
 
一、基础知识:
1.  设备文件:
mem是一个字符设备文件,是计算机主存的一个影象。通常只有root用户对其有读写权限。因此只有root用户能进行这些操作。
       如果要打开设备文件/dev/mem,需要系统调用open()函数,作用是打开一个文件或设备,其函数原型为:
       #include
       #include
       int open(const char *path, int flags);
       open 函数定义在/usr/include/fcntl.h中;如果操作成功则返回一个文件描述符,否则返回-1;其中path是被打开文件的路径即文件名描述;flags是文件的访问模式描述,可常用的选项见下表:
       flags的取值及其含义   flags                    含义
                           O_RDONLY                  只读方式
                           O_WRONLY                  只写方式
                             O_RDWR                  可读写方式
2.内存映像:
内存映像其实在内存中创建一个与外存中文件完全相同的映像。用户可以将整个文件映射到内存中,也可以将文件的一部分映射到内存中。使用操作内存的方法对文件进行操作。系统会将内存映像文件所做的改动反映到真实文件中去。
在内存映像I/O的实现过程中需要用到一些系统调用:
首先是创建内存映像文件的系统调用mmap()函数,其函数原型为:
#include
#include  
void *mmap(void *start,size_t length,int prot,int flags,int fd,off_t offset);  mmap函数定义在/usr/include/sys/mman.h中;
      
此函数用于将一个文件或它的一部分映射到内存中。参数start是一个void指针,表示希望将文件映射到此指针指向的位置,通常为NULL;参数
length定义内存映像文件所占用的内存空间大小,以字节计;参数prot表示内存映像文件的安全属性,它的可使用的选项见表1,注意和open函数中
的flags属性保持一致;参数flags是内存映像的标志,相关的标志见表2;参数fd是要映射的文件的描述符;参数offset表示所映射的数据内容
距离文件头的偏移量。
当调用成功时,返回值为指向内存映像起始地址的指针;当调用失败时,返回值为-1。
表1 prot的取值及其含义
prot                  含义
PROT_EXEC          被映像内存可能含义机器码,可被执行
PROT_NONE          映像内存不允许访问
PROT_READ          映像内存可读
PROT_WRITE         映像内存可写
表2 flags的取值及其含义
Flags                  含义
MAP_FIXED          若无法在指定位置建立内存映像文件,则出错返回
MAP_PRIVATE        对内存映像文件所做操作不反映到外存文件中
MAP_SHARED         对内存映像文件所做操作都将被保存到外存文件中
另外我们使用完内存映像文件后,要用系统调用函数munmap()函数来撤销,其函数原型为:
#include
#include
int munmap(void *start,size_t length);
参数start表示要撤销的内存映像文件的起始地址;参数length表示要撤销的内存映像文件的大小。调用成功时,返回值为0;调用失败时返回值为-1,并将errno设置为相应值。
最后,如果我们要将内存映像的改动保存到外存中,还需要系统调用msync()函数,其函数原型为:
#include
#include
int msync(const void *start,size_t length,int flags);
参数start表示要保存到外存的那些源文件的起始地址;参数length表示内存映像文件的大小;参数flags设置了函数的相应操作,其具体选项见表3。
表3 flags的取值及其含义        
flags                        含义
MS_ASYNC              调用一个写操作并返回
MS_INVALIDATE         映像到相同文件的内存映像数据更新
MS_SYNC               完成写操作后函数返回
通过/dev/mem设备文件和mmap系统调用,可以将线性地址描述的物理内存映射到进程的地址空间,然后就可以直接访问这段内存了。
二、应用实例:
1.  源代码:
/*
file:          RWPhy.c
function:   Read the the first 5 bytes of the memory and then Write it with "HELLO"
*/
#include
#include
#include
#include
#include
#include
int main (int args, char* arg[])
{
int i;
int fd;
char* mem;
char *buff = "HELLO";
//open /dev/mem with read and write mode
if ((fd = open ("/dev/mem", O_RDWR)) < 0)      
{      
        perror ("open error"

;
        return -1;
}     
//map physical memory 0-10 bytes
mem = mmap (0, 10, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (mem == MAP_FAILED) {
    perror ("mmap error:"

;
   return 1;
   }
//Read old value
    for (i = 0; i < 5; i++)
   {
        printf("\nold mem[%d]:%d", i, mem);   
   }
   //write memory
   memcpy(mem, buff, 5);
//Read new value
   for (i = 0; i<5 ; i++)
   {
        printf("\nnew mem[%d]:%c", i, mem);
   }
   printf("\n"

;
   munmap (mem, 10); //destroy map memory
  close (fd);  //close file
  return 0;
}
2.编译、运行:
#gcc -o RWPhy RWPhy.c
#./RWPhy
结果如下:
old mem[0]:1
old mem[1]:0
old mem[2]:0
old mem[3]:0
old mem[4]:83
new mem[0]:H
new mem[1]:E
new mem[2]:L
new mem[3]:L
new mem[4]:O
               
               
               

本文来自ChinaUnix博客,如果查看原文请点:http://blog.chinaunix.net/u/21164/showart_139144.html


你可能感兴趣的:(利用mmap /dev/mem 读写Linux内存 .)