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

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/NobodyUseThisName/article/details/26622799

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 <linux/module.h>
  #include <linux/kernel.h>
  #include <linux/proc_fs.h>
  #include <linux/string.h>
  #include <linux/vmalloc.h>
  #include <asm/uaccess.h>

  
  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 <unistd.h>  
#include <fcntl.h>  
#include <stdio.h>  
#include <stdlib.h>
#include <sys/types.h>  
#include <sys/stat.h>  
#include <errno.h>  
#include <string.h>  
#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 实现读取内核的数据。

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


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







没有更多推荐了,返回首页