c语言－遍历pci设备（2）mmio访问

前言

今天其实我在公司也没有做什么，但是昨天就把pcie遍历的mmio形式做了出来，赞扬公司的台湾服务器，至少我可以使用google来去搜索我想要的资料和答案，有一位大神在台湾的论坛上发布了一片博文，针对dos环境下的mmio的方法，在国内通过百度等等方法是无法访问到的，当然最让人失望的是，如果我不开代理，直接输入网址也是无法进入的，可能有很多人觉得你遍历pcie干吗？嘿嘿，那就是告诉你如何通过代码去访问我门电脑里面最底层的设备，这是一种极其需要能力的。好了，不扯皮了，小编带你通过c语言与汇编的模式进入dos环境访问以及Linux系统的各类方法。

mmio

可能有很多人对mmio的访问模式有一定的疑问，那么现在小编就给大家普及一下，当然有很多资料都是来自于网络，小编参考了太多的资料，在这里便不一一道谢了。说到mmio，小编会给大家普及一些概念，特别时4gb地址空间的一些概念，这些概念有助于各位去理解。

MMIO(Memory mapping I/O)即内存映射I/O，它是PCI规范的一部分，I/O设备被放置在内存空间而不是I/O空间。从处理器的角度看，内存映射I/O后系统设备访问起来和内存一样。这样访问AGP/PCI-E显卡上的帧缓存，BIOS，PCI设备就可以使用读写内存一样的汇编指令完成，简化了程序设计的难度和接口的复杂性。I/O作为CPU和外设交流的一个渠道，主要分为两种，一种是Port I/O，一种是MMIO(Memory mapping I/O)。

那么说到这些必须得提到内存映射，内存映射的机制在我们想访问pci-e的机制中是非常有用的。

内存映射，简而言之就是将用户空间的一段内存区域映射到内核空间，映射成功后，用户对这段内存区域的修改可以直接反映到内核空间，同样，内核空间对这段区域的修改也直接反映用户空间。那么对于内核空间<---->用户空间两者之间需要大量数据传输等操作的话效率是非常高的。

dos环境的mmio方式遍历pci-e

在dos环境下，你需要打开保护机制，进行访问32位的数据格式，在dos是16位访问的，然后通过相应的汇编及机器码进行，进行相关的操作，小编对此也不是非常了解，大家不妨去参考台湾那个大神的博客，我也是参考他的博客做出的dos系统下的编程。

#include<stdio.h>
#include<dos.h> 
#define BaseAddr 0xF8000000
typedef unsigned long DWORD;
//open 
void openA20()
{ while(inp(0x64) & 2); outp(0x64,0xd1);
while(inp(0x64) & 2); outp(0x60,0xdf);
while(inp(0x64) & 2); outp(0x64,0xff);
}
unsigned long GDT_def[]={0,0,0x0000FFFF,0x008F9200}; 
unsigned char GDT_Addr[6]={0};
void set4gb() 
{ asm{
	cli
	push ds ; push es
	mov word ptr GDT_Addr[0], (2*8-1) 
	mov eax,ds 
	shl eax,4 
	xor ebx,ebx
	mov bx,offset GDT_def 
	add eax,ebx 
	mov dword ptr GDT_Addr[2],eax 
	lgdt fword ptr GDT_Addr 
	mov bx,8 
	mov eax,cr0
	or al,1
	mov cr0,eax
	jmp flush1
	}
	flush1: asm{
	mov ds,bx 
	mov es,bx
	and al,0feh
	mov cr0,eax
	jmp flush2
	} 
	flush2: asm{
	pop es ; pop ds
	sti
	}
}
DWORD ReadMemByPM(DWORD addr)
{
    DWORD result;
    _asm{
	push ds;
	mov ax,0;
	mov ds,ax;
	mov esi,addr;
	mov eax,[esi];
	mov result,eax;
	pop ds;
    }
    return result;
}

DWORD ReadMem(DWORD mAddr)
{
	#ifdef DEBUG
	printf("this Memory is 0x%llX\n",mAddr);
	#endif
	DWORD result=0;
	_asm{
		push eax;
		mov eax,[mAddr];
		mov result,eax;
		pop eax;
	}
	return result;
}
int main(){
	DWORD busNum,devNum,funNum,result=0,addr,CabID,mOffset,DevPortType;
	DWORD vendorID,deviceID,LinkWidth,LinkSpeed;
	char* PortType[]={"PCI-E Endpoint","Leg PCIE Endpoint"," Root Complex","Upstream PCI-E Switch","Downstream PCI-E Switch","PCI-E to PCI Bridge","PCI to PCI-E Bridge","Igrd Endpoint","Event Collector","null"},TypeIndex;
	char* SpeedType[]={"2.5G/S","2.5G/S OR 5G/S","2.5G/S OR 5G/S OR 8G/S","NO Speed"},SpeedIndex;
	openA20();
	set4gb();
	printf("busNum devNum  funNum\t vendorID  deviceID  type\tWidth\tSpeed\n");
	for(busNum=0;busNum<16;busNum++)
		for(devNum=0x0;devNum<32;devNum++)
			for(funNum=0;funNum<8;funNum++)
			{
				addr=(0xF8000000)|(busNum<<20)|(devNum<<15)|(funNum<<12);
				result=ReadMemByPM(addr);
				if(result!=0xffffffff)
				{
					result=ReadMemByPM(addr|0x34);
					mOffset=result&0x000000ff;
					LinkWidth=0;
					LinkSpeed=0;
					while(1)
					{
						result=ReadMemByPM(addr|mOffset);
						CabID=result&0x000000ff;
						if(CabID == 0x00000010){
							result=ReadMemByPM(addr);
							vendorID=result&0x0000ffff;
							deviceID=(result&0xffff0000)>>16;
							result=ReadMemByPM(addr|mOffset);
							DevPortType=(result&0x00f00000)>>20;
							switch(DevPortType)
							{
								case 0x0:TypeIndex = 0;break;
								case 0x1:TypeIndex = 1;break;
								case 0x4:TypeIndex = 2;break;
								case 0x5:TypeIndex = 3;break;
								case 0x6:TypeIndex = 4;break;
								case 0x7:TypeIndex = 5;break;
								case 0x8:TypeIndex = 6;break;
								case 0x9:TypeIndex = 7;break;
								case 0xa:TypeIndex = 8;break;
								default:TypeIndex = 9;break;
							}
							result=ReadMemByPM(addr+mOffset+0x0C);
							LinkSpeed=(result&0x0000000f);
							switch(LinkSpeed){
								case 0x1:SpeedIndex = 0;break;
								case 0x2:SpeedIndex = 1;break;
								case 0x3:SpeedIndex = 2;break;
								default:SpeedIndex = 3;break;
							}
							LinkWidth=(result&0x000003f0)>>4;
							printf("%2.2llx \t%2.2llx\t  %2.2llx\t %4.4llx\t     %4.4llx %s   X%2lu  %s\n",busNum,devNum,funNum,vendorID,deviceID,PortType[TypeIndex],LinkWidth,SpeedType[SpeedIndex]);
							break;
						}else{
						mOffset=(result&0x0000ff00)>>8;
						if(mOffset==0x00000000)
						 break;
						 }
					}
				}	
			}	
  return 0;	
}

在这里需要注意的是你的电脑的基地址并非是0xF8000000。

linux环境下

提到linux就不得不说Linux下的一个api，mmap.

mmap系统调用

mmap将一个文件或者其它对象映射进内存。文件被映射到多个页上，如果文件的大小不是所有页的大小之和，最后一个页不被使用的空间将会清零。munmap执行相反的操作，删除特定地址区域的对象映射。
当使用mmap映射文件到进程后,就可以直接操作这段虚拟地址进行文件的读写等操作,不必再调用read,write等系统调用.但需注意,直接对该段内存写时不会写入超过当前文件大小的内容.

采用共享内存通信的一个显而易见的好处是效率高，因为进程可以直接读写内存，而不需要任何数据的拷贝。对于像管道和消息队列等通信方式，则需要在内核和用户空间进行四次的数据拷贝，而共享内存则只拷贝两次数据：一次从输入文件到共享内存区，另一次从共享内存区到输出文件。实际上，进程之间在共享内存时，并不总是读写少量数据后就解除映射，有新的通信时，再重新建立共享内存区域。而是保持共享区域，直到通信完毕为止，这样，数据内容一直保存在共享内存中，并没有写回文件。共享内存中的内容往往是在解除映射时才写回文件的。因此，采用共享内存的通信方式效率是非常高的。

基于文件的映射，在mmap和munmap执行过程的任何时刻，被映射文件的st_atime可能被更新。如果st_atime字段在前述的情况下没有得到更新，首次对映射区的第一个页索引时会更新该字段的值。用PROT_WRITE 和 MAP_SHARED标志建立起来的文件映射，其st_ctime 和 st_mtime在对映射区写入之后，但在msync()通过MS_SYNC 和 MS_ASYNC两个标志调用之前会被更新。
用法:

void mmap(void start, size_t length, int prot, int flags,int fd, off_t offset);
int munmap(void *start, size_t length);
返回说明：
成功执行时，mmap()返回被映射区的指针，munmap()返回0。失败时，mmap()返回MAP_FAILED[其值为(void *)-1]，munmap返回-1。errno被设为以下的某个值

• EACCES：访问出错
  
• EAGAIN：文件已被锁定，或者太多的内存已被锁定
  
• EBADF：fd不是有效的文件描述词
  
• EINVAL：一个或者多个参数无效
  
• ENFILE：已达到系统对打开文件的限制
  
• ENODEV：指定文件所在的文件系统不支持内存映射
  
• ENOMEM：内存不足，或者进程已超出最大内存映射数量
  
• EPERM：权能不足，操作不允许
  
• ETXTBSY：已写的方式打开文件，同时指定MAP_DENYWRITE标志
  
• SIGSEGV：试着向只读区写入
  
• SIGBUS：试着访问不属于进程的内存区
  参数：
  
• start：映射区的开始地址。
  
• length：映射区的长度。
  
• prot：期望的内存保护标志，不能与文件的打开模式冲突。是以下的某个值，可以通过or运算合理地组合在一起

• PROT_EXEC //页内容可以被执行
  
• PROT_READ //页内容可以被读取
  
• PROT_WRITE //页可以被写入
  

• PROT_NONE //页不可访问

• flags：指定映射对象的类型，映射选项和映射页是否可以共享。它的值可以是一个或者多个以下位的组合体

  • MAP_FIXED //使用指定的映射起始地址，如果由start和len参数指定的内存区重叠于现存的映射空间，重叠部分将会被丢弃。如果指定的起始地址不可用，操作将会失败。并且起始地址必须落在页的边界上。

• MAP_SHARED //与其它所有映射这个对象的进程共享映射空间。对共享区的写入，相当于输出到文件。直到msync()或者munmap()被调用，文件实际上不会被更新。
  
• MAP_PRIVATE //建立一个写入时拷贝的私有映射。内存区域的写入不会影响到原文件。这个标志和以上标志是互斥的，只能使用其中一个。
  
• MAP_DENYWRITE //这个标志被忽略。
  
• MAP_EXECUTABLE //同上
  
• MAP_NORESERVE //不要为这个映射保留交换空间。当交换空间被保留，对映射区修改的可能会得到保证。当交换空间不被保留，同时内存不足，对映射区的修改会引起段违例信号。
  
• MAP_LOCKED //锁定映射区的页面，从而防止页面被交换出内存。
  
• MAP_GROWSDOWN //用于堆栈，告诉内核VM系统，映射区可以向下扩展。
  
• MAP_ANONYMOUS //匿名映射，映射区不与任何文件关联。
  
• MAP_ANON //MAP_ANONYMOUS的别称，不再被使用。
  
• MAP_FILE //兼容标志，被忽略。
  
• MAP_32BIT //将映射区放在进程地址空间的低2GB，MAP_FIXED指定时会被忽略。当前这个标志只在x86-64平台上得到支持。
  
• MAP_POPULATE //为文件映射通过预读的方式准备好页表。随后对映射区的访问不会被页违例阻塞。
  

• MAP_NONBLOCK //仅和MAP_POPULATE一起使用时才有意义。不执行预读，只为已存在于内存中的页面建立页表入口。

• fd：有效的文件描述词。如果MAP_ANONYMOUS被设定，为了兼容问题，其值应为-1。

offset：被映射对象内容的起点。

系统调用munmap()

int munmap( void * addr, size_t len )
该调用在进程地址空间中解除一个映射关系，addr是调用mmap()时返回的地址，len是映射区的大小。当映射关系解除后，对原来映射地址的访问将导致段错误发生。

系统调用msync()

int msync ( void * addr , size_t len, int flags)
一般说来，进程在映射空间的对共享内容的改变并不直接写回到磁盘文件中，往往在调用munmap（）后才执行该操作。可以通过调用msync()实现磁盘上文件内容与共享内存区的内容一致。

系统调用mmap()用于共享内存的两种方式：

（1）使用普通文件提供的内存映射：适用于任何进程之间；此时，需要打开或创建一个文件，然后再调用mmap()；典型调用代码如下：

fd=open(name, flag, mode);
if(fd<0)
...
ptr=mmap(NULL, len , PROT_READ|PROT_WRITE, MAP_SHARED , fd , 0);
通过mmap()实现共享内存的通信方式有许多特点和要注意的地方

（2）使用特殊文件提供匿名内存映射：适用于具有亲缘关系的进程之间；由于父子进程特殊的亲缘关系，在父进程中先调用mmap()，然后调用fork()。那么在调用fork()之后，子进程继承父进程匿名映射后的地址空间，同样也继承mmap()返回的地址，这样，父子进程就可以通过映射区域进行通信了。注意，这里不是一般的继承关系。一般来说，子进程单独维护从父进程继承下来的一些变量。而mmap()返回的地址，却由父子进程共同维护。
对于具有亲缘关系的进程实现共享内存最好的方式应该是采用匿名内存映射的方式。此时，不必指定具体的文件，只要设置相应的标志即可.

mmap进行内存映射的原理

mmap系统调用的最终目的是将,设备或文件映射到用户进程的虚拟地址空间,实现用户进程对文件的直接读写,这个任务可以分为以下三步:

在用户虚拟地址空间中寻找空闲的满足要求的一段连续的虚拟地址空间,为映射做准备(由内核mmap系统调用完成)每个进程拥有3G字节的用户虚存空间。但是，这并不意味着用户进程在这3G的范围内可以任意使用，因为虚存空间最终得映射到某个物理存储空间（内存或磁盘空间），才真正可以使用。

那么，内核怎样管理每个进程3G的虚存空间呢？概括地说，用户进程经过编译、链接后形成的映象文件有一个代码段和数据段（包括data段和bss段），其中代码段在下，数据段在上。数据段中包括了所有静态分配的数据空间，即全局变量和所有申明为static的局部变量，这些空间是进程所必需的基本要求，这些空间是在建立一个进程的运行映像时就分配好的。除此之外，堆栈使用的空间也属于基本要求，所以也是在建立进程时就分配好的.

在内核中,这样每个区域用一个结构struct vm_area_struct 来表示.它描述的是一段连续的、具有相同访问属性的虚存空间，该虚存空间的大小为物理内存页面的整数倍。可以使用 cat /proc//maps来查看一个进程的内存使用情况,pid是进程号.其中显示的每一行对应进程的一个vm_area_struct结构.
下面是struct vm_area_struct结构体的定义：

#include <linux/mm_types.h>

/* This struct defines a memory VMM memory area. */

struct vm_area_struct {
struct mm_struct * vm_mm; /* VM area parameters */
unsigned long vm_start;
unsigned long vm_end;

/* linked list of VM areas per task, sorted by address */
struct vm_area_struct *vm_next;
pgprot_t vm_page_prot;
unsigned long vm_flags;

/* AVL tree of VM areas per task, sorted by address */
short vm_avl_height;
struct vm_area_struct * vm_avl_left;
struct vm_area_struct * vm_avl_right;

/* For areas with an address space and backing store,
vm_area_struct *vm_next_share;
struct vm_area_struct **vm_pprev_share;
struct vm_operations_struct * vm_ops;
unsigned long vm_pgoff; /* offset in PAGE_SIZE units, *not* PAGE_CACHE_SIZE */
struct file * vm_file;
unsigned long vm_raend;
void * vm_private_data; /* was vm_pte (shared mem) */
};

通常，进程所使用到的虚存空间不连续，且各部分虚存空间的访问属性也可能不同。所以一个进程的虚存空间需要多个vm_area_struct结构来描述。在vm_area_struct结构的数目较少的时候，各个vm_area_struct按照升序排序，以单链表的形式组织数据（通过vm_next指针指向下一个vm_area_struct结构）。但是当vm_area_struct结构的数据较多的时候，仍然采用链表组织的化，势必会影响到它的搜索速度。针对这个问题，vm_area_struct还添加了vm_avl_hight（树高）、vm_avl_left（左子节点）、vm_avl_right（右子节点）三个成员来实现AVL树，以提高vm_area_struct的搜索速度。

　　假如该vm_area_struct描述的是一个文件映射的虚存空间，成员vm_file便指向被映射的文件的file结构，vm_pgoff是该虚存空间起始地址在vm_file文件里面的文件偏移，单位为物理页面。

因此,mmap系统调用所完成的工作就是准备这样一段虚存空间,并建立vm_area_struct结构体,将其传给具体的设备驱动程序.
下面分享的是我写的linux的mmio遍历。

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/mman.h>
//#include<linux/pci.h>

//#define DEBUG1

#define PCI_MAX_BUS 2
#define PCI_MAX_DEV 31
#define PCI_MAX_FUN 7
#define PCI_BASE_ADDR 0xfc000000L
#define LEN_SIZE sizeof(unsigned long)
#define SIZE 4096


typedef unsigned int WORD;
typedef unsigned long DWORD;
typedef unsigned char BYTE;


                    
                            
void typeshow(BYTE Type){  
    switch(Type){
      case 0x0f:{
               printf("endpoint\t");
               break;
                 }
      case 0x1f:{
             printf("legacy endpoint\t");
                 break;
               }
      case 0x4f:{
             printf("root complex\t");
                break;
              }
      case 0x5f:{
             printf("upstream pci-e switch\t");
             break;
                }
      case 0x6f:{
             printf("downstream pci-e switch\t");
             break;
             }
      case 0x7f:{
            printf("pci-e to pci bridge\t");
             break;
              }
      case 0x8f:{
             printf("pci to pci-e bridge\t");
             break;
              }
     case 0x9f:{
             printf("root co inte endpoint\t");
             break;
               }
     case 0xaf:{
             printf("root co event endpoint\t");
             break;
                }
     defult:{
             printf("b\t");
             break;     
            }
      }
       
}

void speedshow(int speed){
    if(speed == 0x0){
            printf("speed is 2.5G/s\t");
         }
    else if(speed == 0x2){
            printf("speed is 5G/s\t");
         }
    else if(speed == 0x4){
            printf("speed is 8G/s\t");
         }
    else{
           printf("no speed!\t");
        }
}
void linkspeedshow(int flag){
     switch(flag){
         case 0x1:{
            printf("link speed 0\t");
            break;
              }
         case 0x2:{
            printf("link speed 1\t");
            break;
              }
         case 0x3:{
            printf("link speed 2\t");
            break;
              }
         case 0x4:{
            printf("link speed 3\t");
            break;
              }
         case 0x5:{
            printf("link speed 4\t");
            break;
              }
         case 0x6:{
            printf("link speed 5\t");
            break;
              }
         case 0x7:{
            printf("link speed 6\t");
            break;
              }
         default:
               {
             printf("no speed!\t");
              break;
              }
     }
}
void linkwidthshow(int flag){
    printf("linkwidth:");
    switch(flag){
           case 0x00:{
                   printf("reserved\t");
                   break;
                 }
           case 0x01:{
                   printf("x1\t");
                   break;
                 }
           case 0x02:{
                   printf("x2\t");
                   break;
                 }
           case 0x04:{
                   printf("x4\t");
                   break;
                 }
           case 0x08:{
                   printf("x8\t");
                   break;
                 }
           case 0x0c:{
                   printf("x12\t");
                   break;
                 }
           case 0x10:{
                   printf("x16\t");
                   break;
                 }
           case 0x20:{
                   printf("x32\t");
                   break;
                 }
           default:{
                    printf("null\t");
                 }
  }
}

int main()
{  
    DWORD addr = 0;
    WORD bus,dev,fun;
    WORD* DATA;
    WORD* dwDATA;
    BYTE nextPoint;
    int fd,i = 1;
    fd = open("/dev/mem",O_RDWR);
    if(fd < 0)
    {
      printf("can't open port!\n");
    }
#ifdef DEBUG
    printf("fd = %d\n",fd);
#endif
     for(bus = 0; bus <= PCI_MAX_BUS; bus++)
        for(dev = 0; dev <= PCI_MAX_DEV; dev++)
           for(fun = 0; fun <= PCI_MAX_FUN; fun++)
              {
                 addr = 0;
                 addr = PCI_BASE_ADDR|(bus<<20)|(dev<<15)|(fun<<12);
                 DATA = mmap(NULL,LEN_SIZE,PROT_READ|PROT_WRITE,MAP_SHARED,fd,addr);
                 if(DATA == (void *)-1)
                 {
                     munmap(DATA,LEN_SIZE);
                     break;
                 }
                 if(*DATA != 0xffffffff)
                 {
                    nextPoint = (BYTE)(*(DATA+0x34/4)); 
                    dwDATA = DATA+nextPoint/4;
                     #ifdef DEBUG1
                    printf("nextpoint = %x\n",nextPoint);
                    printf("addr1=%x\n",*dwDATA);
                     #endif                    
                 while(1){
                    if((BYTE)*(dwDATA)==0x10)
                     {        
                             
                             printf("PCI-E:");
                             printf("bus# = %x,dev# = %x,fun# = %x\t",bus,dev,fun);
                             printf("vender id:%.4x\t",*DATA&0xffff);
                             printf("device id:%.4x\t",((*DATA)>>8)&0XFFFF);
                             printf("\ntype:");
                             typeshow((BYTE)((*dwDATA)>>8)|0x0f);
                             speedshow(*(dwDATA+0x2c/4)>>1&0xf);
                          //   linkspeedshow(*(dwDATA+0x0c/4)&0xf);
                             linkwidthshow((*(dwDATA+0x0c/4)>>4)&0x3f);
                             printf("\n");
                             break;
                     }
                     dwDATA = DATA+((*(dwDATA)>>8)&0xff)/4;
                     #ifdef DEBUG1
                     printf("dwDATA = %x\n",*dwDATA);
                     #endif
    
                     if((BYTE)(*(dwDATA)) == 0x00)
                     break;
                     }
                 #ifdef DEBUG                    
                    printf("bus = %x,dev = %x,fun = %x\n",bus,dev,fun); 
                    for(i = 0; i < 0;i++)
                    {
                        printf("data%d:%x\n",i,*(DATA+i));
                    }
                   printf(" next Point:%x\n",nextPoint);
                   printf("data:%x\n",(BYTE)*(DATA+nextPoint/4));
                 #endif
                    
                 
                 }
                  munmap(DATA,LEN_SIZE);
              } 
    close(fd);
    return 0;
}