c语言－遍历pci设备（2）mmio访问
前言
今天其实我在公司也没有作什么，可是昨天就把pcie遍历的mmio形式作了出来，赞赏公司的台湾服务器，至少我可使用google来去搜索我想要的资料和答案，有一位大神在台湾的论坛上发布了一片博文，针对dos环境下的mmio的方法，在国内经过百度等等方法是没法访问到的，固然最让人失望的是，若是我不开代理，直接输入网址也是没法进入的，可能有不少人以为你遍历pcie干嘛？嘿嘿，那就是告诉你如何经过代码去访问我门电脑里面最底层的设备，这是一种极其须要能力的。好了，不扯皮了，小编带你经过c语言与汇编的模式进入dos环境访问以及Linux系统的各种方法。php
mmio
可能有不少人对mmio的访问模式有必定的疑问，那么如今小编就给你们普及一下，固然有不少资料都是来自于网络，小编参考了太多的资料，在这里便不一一道谢了。说到mmio，小编会给你们普及一些概念，特别时4gb地址空间的一些概念，这些概念有助于各位去理解。linux
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的机制中是很是有用的。api
内存映射，简而言之就是将用户空间的一段内存区域映射到内核空间，映射成功后，用户对这段内存区域的修改能够直接反映到内核空间，一样，内核空间对这段区域的修改也直接反映用户空间。那么对于内核空间<---->用户空间二者之间须要大量数据传输等操做的话效率是很是高的。缓存
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.app
mmap系统调用
mmap将一个文件或者其它对象映射进内存。文件被映射到多个页上，若是文件的大小不是全部页的大小之和，最后一个页不被使用的空间将会清零。munmap执行相反的操做，删除特定地址区域的对象映射。
当使用mmap映射文件到进程后,就能够直接操做这段虚拟地址进行文件的读写等操做,没必要再调用read,write等系统调用.但需注意,直接对该段内存写时不会写入超过当前文件大小的内容.this
采用共享内存通讯的一个显而易见的好处是效率高，由于进程能够直接读写内存，而不须要任何数据的拷贝。对于像管道和消息队列等通讯方式，则须要在内核和用户空间进行四次的数据拷贝，而共享内存则只拷贝两次数据：一次从输入文件到共享内存区，另外一次从共享内存区到输出文件。实际上，进程之间在共享内存时，并不老是读写少许数据后就解除映射，有新的通讯时，再从新创建共享内存区域。而是保持共享区域，直到通讯完毕为止，这样，数据内容一直保存在共享内存中，并无写回文件。共享内存中的内容每每是在解除映射时才写回文件的。所以，采用共享内存的通讯方式效率是很是高的。google
基于文件的映射，在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;
}
- 1. c语言－遍历pci设备（1）io访问
- 2. C++ 遍历设备
- 3. BinaryTree-递归遍历&建树--C语言
- 4. 图bfs和dfs遍历 c语言版
- 5. C语言二叉树及遍历
- 6. C语言 · 求先序遍历
- 7. c语言的二叉树遍历
- 8. C语言文件访问
- 9. C语言历史
- 10. c语言历史
- 更多相关文章...
- • XML DOM 遍历节点树 - XML DOM 教程
- • Swift 访问控制 - Swift 教程
- • C# 中 foreach 遍历的用法
- • Kotlin学习（一）基本语法
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. c语言－遍历pci设备（1）io访问
- 2. C++ 遍历设备
- 3. BinaryTree-递归遍历&建树--C语言
- 4. 图bfs和dfs遍历 c语言版
- 5. C语言二叉树及遍历
- 6. C语言 · 求先序遍历
- 7. c语言的二叉树遍历
- 8. C语言文件访问
- 9. C语言历史
- 10. c语言历史