使用proc文件映射的方式实现用户态跟内核态的数据交互

Linux把进程划分为用户态和内核态，我们一般的应用程序都是直接跑在用户态的。

用户态和内核态是不能直接调用的，就像进程A不能直接调用进程B的方法一样，需要用一些其他的解决方案来完成，比如共享内存，socket等。

插一句，进程间通信有如下方案：

1无名管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。

2.高级管道(popen)：将另一个程序当做一个新的进程在当前程序进程中启动，则它算是当前程序的子进程，这种方式我们成为高级管道方式。
3 有名管道 (named pipe) ： 有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。
4信号量( semophore ) ： 信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
5 消息队列( message queue ) ： 消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。
6 信号 ( sinal ) ： 信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。
7共享内存( shared memory ) ：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。
8套接字( socket ) ： 套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同机器间的进程通信。

需要注意的是内核中是不能使用用户态的库的，比如我们平时打印输出的printf,在内核中是不能用的，因为内核里面根本就没有这个东西，与之对应的是printk.

不过内核中把我们常见的一些C函数都做了实现，所以大多的接口还是差不多的。

这根今天要讲的原里就是一样的，我们直接上代码：

  #include 
  #include 
  #include 
  #include 
  #include 
  #include 

  
  MODULE_LICENSE("GPL");
  MODULE_DESCRIPTION("Fortune Cookie Kernel Module");
  MODULE_AUTHOR("M. Tim Jones   -   lifeng ");

  
  #define MAX_COOKIE_LENGTH       PAGE_SIZE
  #define PROC_FILE                 "proc_copy"
  static struct proc_dir_entry *proc_entry;
  static char *cookie_pot;  // Space for fortune strings
  static int cookie_index;  // Index to write next fortune
  static int next_fortune;  // Index to read next fortune

  // 目前这个方式只提供一个页大小的内存读取:一般是4096B,即4kB




  // 用户态调用read的时候就触发这个函数
  // 对于proc文件，read每次最多只能读取一页的数据，
  // 如果读得多，就需要保存read的返回，然后设置lseek,然后再read一次。
  //
  // 参数讲解
  // page : 内核分配的一页缓冲区，驱动把数据写在这里，交给用户
  // start : 
  //    这个参数很复杂，如果数据量不大，就不管他。
  //    如果不设置*start的值，off的取值只能是[0,count-1]之间，
  //    所有能读取到的数据量最多也就是count-off个.
  //    可以理解为系统只拷贝了[page+off,page+count-1]的数据到用户的buff
  //    如果off超出范围，就不能读取
  //    
  //    如果设置了*start值，那么系统认为*start的地址就是off指定的地址，off就会被忽略
  //    系统会拷贝[start,star+count-1]的数据到用户buff.当然我们事先start地址定位时，可能会用到off的值
  //
  // off : 跟read一样，代表偏移,就是lseek设置的偏移
  // count : 跟read一样，代表读多少数据
  // eof : 输出参数，如果没有数据了，就置1，是文件结束符。
  //    设置了这个参数表明不想再提供数据了，神马意思呢？
  //    如果不设置这个参数，对于上面说的start为空的情况，read_proc返回后，
  //    系统如果发现 （count - off） < count 会接着下发写请求，读取off大小的数据。
  //    例如：有这样的读取操作：
  //        lseek(fd, 2, SEEK_SET); read(fd, buff_r, 30)
  //    第一次调用read_proc, off=2, count=30, 由于我们没有设置start的值，
  //    将读取28字节的数据，由于没有设置*eof, 系统会再次下发read_proc
  //    第二次调用read_proc, off=30, count=2, 在参数start的说明里提到，
  //    对于这个调用，系统默认读不到数据（怨念啊，为啥要下发）
  //    于是read返回28
  //
  //
  // data : 由驱动内部使用,这个是给驱动程序预留的参数。
  int fortune_read( char *page, char **start, off_t off,
                             int count, int *eof, void *data )
  {
      
      int len;
  	  printk(KERN_INFO "%s:fortune_read called,off= %d,count = %d\n",PROC_FILE,off,count);

      if(off+count >= MAX_COOKIE_LENGTH)
      {
         printk(KERN_INFO "%s:off+count >= MAX_COOKIE_LENGTH",PROC_FILE);
         *eof = 1;
      }

      if(off >= MAX_COOKIE_LENGTH)
      {
        printk(KERN_INFO "%s:off >= MAX_COOKIE_LENGTH",PROC_FILE);
        *eof = 1;
        return 0;
      }

      len = sprintf(page, "%s\n", cookie_pot);

      return len;




      /*
      int len;
      if (off > 0) {
          *eof = 1;
          return 0;
      }
  
      // Wrap-around
      if (next_fortune >= cookie_index) 
          next_fortune = 0;
  
      len = sprintf(page, "%s\n", &cookie_pot[next_fortune]);
      next_fortune += len;
  
      return len;
      */
  }

  // 对于write_proc函数，参数是很简单的，需要说明的只有一点，
  // 就是write_proc的第二个参数buffer是用户态的地址，
  // 需要用copy_from_user从用户态把数据拷到内核态的缓冲区里。
  ssize_t fortune_write( struct file *file, const char __user *buff,
                                  unsigned long len, void *data )
  {

      if(len > MAX_COOKIE_LENGTH)
      {
          printk(KERN_INFO "%s:Error : No More Space to Store!\n",PROC_FILE);
          return -ENOSPC;
      }

        //第一个参数，是在内核态我们分配的buffer
        //第二个参数，是用户态buffer的地址，也就是write_proc传进来的buffer参数
        //第三个参数，是拷贝的字节数
      if (copy_from_user(cookie_pot, buff, len )) {
          return -EFAULT;
      }

      return len;



      /*
    
  	  printk(KERN_INFO "fortune_write called,len = %d\n",len);
      int space_available = (MAX_COOKIE_LENGTH-cookie_index)+1;
      if (len > space_available) {
          printk(KERN_INFO "fortune: cookie pot is full!\n");
          return -ENOSPC;
      }

        //第一个参数，是在内核态我们分配的buffer
        //第二个参数，是用户态buffer的地址，也就是write_proc传进来的buffer参数
        //第三个参数，是拷贝的字节数
      if (copy_from_user( &cookie_pot[cookie_index], buff, len )) {
          return -EFAULT;
      }
  
      cookie_index += len;
      cookie_pot[cookie_index-1] = 0;
  
      return len;
      */
  }
  
  int init_fortune_module( void )
  {
      int ret = 0;
      cookie_pot = (char *)vmalloc( MAX_COOKIE_LENGTH );
      printk(KERN_INFO "%s:MAX_COOKIE_LENGTH = %d \n",PROC_FILE,MAX_COOKIE_LENGTH);
      if (!cookie_pot) {
          ret = -ENOMEM;
      } else {
          memset( cookie_pot, 0, MAX_COOKIE_LENGTH );
		  // 这里以0开头就是8进制
		  // 于是权限就是110-100-100
		  // 就是-| rw-|r--|r--
		  // 我们为了简单，就可以都有读写权限
		  //于是就写666
          //proc_entry = create_proc_entry( "fortune", 0644, NULL );
		  proc_entry = create_proc_entry( PROC_FILE, 0666, NULL );
          if (proc_entry == NULL) {
              ret = -ENOMEM;
              vfree(cookie_pot);
              printk(KERN_INFO "%s: Couldn't create proc entry\n",PROC_FILE);
          } else {
              cookie_index = 0;
              next_fortune = 0;
              proc_entry->read_proc = fortune_read;
              proc_entry->write_proc = fortune_write;
              //proc_entry->owner = THIS_MODULE;
              printk(KERN_INFO "%s: Module loaded.\n",PROC_FILE);
          }
      }
  
      return ret;
  }
  
  void cleanup_fortune_module( void )
  {
      //remove_proc_entry("fortune", &proc_root);
	  remove_proc_entry(PROC_FILE, NULL);
      vfree(cookie_pot);
      printk(KERN_INFO "%s: Module unloaded.\n",PROC_FILE);
  }
  
  module_init( init_fortune_module );
  module_exit( cleanup_fortune_module );

要编译这运行在内核态的代码的话，跟我们平常的编译也不大一样(Makefile不一样)，

下面把Makefile传上来：

MODULENAME = proc_copy

AP_PROCESSOR_TYPE=x86
HOME := $(shell pwd)
KVER := $(shell uname -r)
#INCLUDE := -I$(PWD)/../Include

MODULEOBJS	=main.o

#ifeq ($(AP_PROCESSOR_TYPE),x86)
#     MODULEOBJS+= amix86.o
#else ifeq ($(AP_PROCESSOR_TYPE),be)
#     MODULEOBJS+= amibe.o
#else
#     MODULEOBJS+= amiarm.o
#endif
   
obj-m := $(MODULENAME).o
$(MODULENAME)-y := $(MODULEOBJS)
EXTRA_CFLAGS = $(INCLUDE)

all:
	make -C /lib/modules/$(KVER)/build M=$(HOME) modules
	
clean:
	make -C /lib/modules/$(KVER)/build M=$(HOME) clean
	

在Linux里面直接make就可以生成proc_copy.ko的一个驱动文件。

接下来就是“运行”他，我们需要把它加载到内核才可以用：

执行如下命令：

sudo insmod proc_copy.ko

即可加载到内核并开始运行。

从内核异常就执行如下命令：

sudo rmmod proc_copy.ko

查看内核中有哪些模块使用：

lsmod

怎么测试呢？

下面一步一步来。

一旦运行起来，我们就可以在/proc/目录下面看到我们的一个文件proc_copy

他就是内核创建的一个虚拟的文件，我们用户态的应用程序对这个文件的读写，就是对内核程序的数据的传输了。

所以你可以写一个测试程序：

#include   
#include   
#include   
#include 
#include   
#include   
#include   
#include   
#define BUFFER_SIZE 1024  


#define PROC_FILE "/proc/proc_copy"

FILE* fd;

  
int main(int argc, char **argv) {  


	if( (fd = fopen(PROC_FILE,"r+")) == NULL )
	{
        printf("Error : open file %s faild \n",PROC_FILE);
		exit(-1);
	}

    // 写文件
    const char* put = "1234";
    printf("Infor : wirte into file : %s\n",put);
    int index = 0;
    while(put[index] != '\0')
    {
        fputc(put[index],fd);
        index ++;
    }
    //fputc('\0',fd);


    // 读取文件
    printf("Infor : read from file : \n");
    fseek(fd,0,SEEK_SET);
    char ch;
    while( (ch=fgetc(fd)) != EOF)
        printf("%c",ch);
    
    
    fclose(fd);
   
}  

执行他，就可以看到结果了。这应用程序就是普通的文件操作的程序。

我们也可以直接echo "kkkkkk" > /proc/proc_copy 实现对这个内核文件写数据

然后cat /proc/proc_copy 实现读取内核的数据。

在应用程序看来他就是普通的文件而已。

至于代码的讲解已经在注释上写得很清楚了。所以不再赘述。