简介

操作系统将虚拟内存分为内核空间和用户空间。内核空间严格保留用于运行内核，内核扩展和大多数设备驱动程序。相反，用户空间是所有用户模式应用程序都在其中工作的存储区，并且可以在必要时将该存储区换出。
在用户空间和内核空间之间进行通信的方法有很多

  1. IOCTL
  2. Procfs
  3. Sysfs
  4. Configfs
  5. Debugfs
  6. Sysctl
  7. UDP Sockets
  8. Netlink Sockets

在这里我们讨论Procfs

Procfs in Linux

/proc 文件是procfs（进程文件系统）的挂载点，该文件是内存中的文件系统。许多进程在此虚拟文件系统上存储有关自身的信息。ProcFS还存储其他系统信息。用户空间程序可以使用proc文件来读取内核导出的信息。proc文件系统中的每个条目都提供了一些来自内核的信息。

  1. cat /proc/meminfo
  2. cat /proc/modules
  4. /proc/devices -注册字符和主号码
  5. /proc/iomem —系统上的物理RAM和总线设备地址
  6. /proc/ioports —系统上的I / O端口地址（尤其是x86系统）
  7. /proc/interrupts —已注册的中断请求号
  8. /proc/softirqs —已注册的软IRQ
  9. /proc/swaps -当前有效的掉期
  10. /proc/kallsyms —运行内核符号，包括从加载的模块中
  11. /proc/partitions —当前连接的块设备及其分区
  12. /proc/filesystems —当前活动的文件系统驱动程序
  13. /proc/cpuinfo —有关系统上CPU的信息

当我们要调试内核模块时，proc文件系统也非常有用。在调试时，我们可能想知道模块中各种变量的值，或者也许是模块正在处理的数据。在这种情况下，我们可以为自己创建一个proc条目，并转储我们要在条目中查找的所有数据。
proc条目可以用于通过写入内核将数据传递到内核，因此可以有两种proc条目。

  1. 仅从内核空间读取数据的条目。
  2. 一个在内核空间中读取和写入数据的条目。

    创建过程条目

    proc条目的创建在3.10及更高版本的内核中经历了相当大的变化。在本文中，我们将看到可以在Linux内核3.10及更高版本中使用的一种方法，让我们看看如何在3.10及更高版本中创建proc条目。我使用的linux版本为
    1. VERSION = 4
    2. PATCHLEVEL = 19
    3. SUBLEVEL = 19
    ```c

    include

    static inline struct proc_dir_entry proc_create(const char name, umode_t mode,
    1.                                  struct proc_dir_entry *parent, 
    2.                                  const struct file_operations *proc_fops)

: The name of the proc entry

: The access mode for proc entry

: The name of the parent directory under /proc. If NULL is passed as a parent, the /proc directory will be set as a parent.

: The structure in which the file operations for the proc entry will be created.

  1. 例如，要在/ proc下创建一个名称为“ etx_proc”的proc条目，上述功能将定义如下，
  2. ```c
  3. proc_create("etx_proc",0666,NULL,&proc_fops);

Procfs文件系统

现在，我们需要创建file_operations结构proc_fops，在其中可以映射proc条目的读写功能。

  1. static struct file_operations proc_fops = {
  2.     .open = open_proc,
  3.     .read = read_proc,
  4.     .write = write_proc,
  5.     .release = release_proc
  6. };

打开和释放功能

这些功能可选

  1. static int open_proc(struct inode *inode, struct file *file)
  2. {
  3.     printk(KERN_INFO "proc file opend.....\t");
  4.     return 0;
  5. }
  7. static int release_proc(struct inode *inode, struct file *file)
  8. {
  9.     printk(KERN_INFO "proc file released.....\n");
  10.     return 0;
  11. }

写功能

写函数将使用函数copy_from_user从用户空间接收数据到数组“ etx_array”中。

  1. static ssize_t write_proc(struct file *filp, const char *buff, size_t len, loff_t * off)
  2. {
  3.     printk(KERN_INFO "proc file write.....\t");
  4.     copy_from_user(etx_array,buff,len);
  5.     return len;
  6. }

读取功能

一旦将数据写入proc条目，我们就可以使用读取功能从proc条目读取数据，即使用copy_to_user函数将数据传输到用户空间。

  1. static ssize_t read_proc(struct file *filp, char __user *buffer, size_t length,loff_t * offset)
  2. {
  3.     printk(KERN_INFO "proc file read.....\n");
  4.     if(len)
  5.         len=0;
  6.     else{
  7.         len=1;
  8.         return 0;
  9.     }
  10.     copy_to_user(buffer,etx_array,20);
  12.     return length;;
  13. }

删除过程条目

  1. void remove_proc_entry(const char *name, struct proc_dir_entry *parent);

代码

  1. #include <linux/kernel.h>
  2. #include <linux/init.h>
  3. #include <linux/module.h>
  4. #include <linux/kdev_t.h>
  5. #include <linux/fs.h>
  6. #include <linux/cdev.h>
  7. #include <linux/device.h>
  8. #include <linux/slab.h>    //kmalloc()
  9. #include <linux/uaccess.h> //copy_to/from_user()
  10. #include <linux/ioctl.h>
  11. #include <linux/proc_fs.h>
  13. #define WR_VALUE _IOW('a', 'a', int32_t *)
  14. #define RD_VALUE _IOR('a', 'b', int32_t *)
  16. int32_t value = 0;
  17. char etx_array[20] = "try_proc_array\n";
  18. static int len = 1;
  20. dev_t dev = 0;
  21. static struct class *dev_class;
  22. static struct cdev etx_cdev;
  24. static int __init etx_driver_init(void);
  25. static void __exit etx_driver_exit(void);
  26. /*************** Driver Functions **********************/
  27. static int etx_open(struct inode *inode, struct file *file);
  28. static int etx_release(struct inode *inode, struct file *file);
  29. static ssize_t etx_read(struct file *filp, char __user *buf, size_t len, loff_t *off);
  30. static ssize_t etx_write(struct file *filp, const char *buf, size_t len, loff_t *off);
  31. static long etx_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
  33. /***************** Procfs Functions *******************/
  34. static int open_proc(struct inode *inode, struct file *file);
  35. static int release_proc(struct inode *inode, struct file *file);
  36. static ssize_t read_proc(struct file *filp, char __user *buffer, size_t length, loff_t *offset);
  37. static ssize_t write_proc(struct file *filp, const char *buff, size_t len, loff_t *off);
  39. static struct file_operations fops =
  40.     {
  41.         .owner = THIS_MODULE,
  42.         .read = etx_read,
  43.         .write = etx_write,
  44.         .open = etx_open,
  45.         .unlocked_ioctl = etx_ioctl,
  46.         .release = etx_release,
  47. };
  49. static struct file_operations proc_fops = {
  50.     .open = open_proc,
  51.     .read = read_proc,
  52.     .write = write_proc,
  53.     .release = release_proc};
  55. static int open_proc(struct inode *inode, struct file *file)
  56. {
  57.     printk(KERN_INFO "proc file opend.....\t");
  58.     return 0;
  59. }
  61. static int release_proc(struct inode *inode, struct file *file)
  62. {
  63.     printk(KERN_INFO "proc file released.....\n");
  64.     return 0;
  65. }
  67. static ssize_t read_proc(struct file *filp, char __user *buffer, size_t length, loff_t *offset)
  68. {
  69.     int ret = 0x00;
  70.     printk(KERN_INFO "proc file read.....\n");
  71.     if (len)
  72.         len = 0;
  73.     else
  74.     {
  75.         len = 1;
  76.         return 0;
  77.     }
  78.     ret = copy_to_user(buffer, etx_array, 20);
  79.     (void)ret;
  80.     return length;
  81.     ;
  82. }
  84. static ssize_t write_proc(struct file *filp, const char *buff, size_t len, loff_t *off)
  85. {
  86.     int ret = 0x00;
  87.     int maxlen = sizeof(etx_array) / sizeof(etx_array[0]);
  88.     int length = len;
  89.     if (length > maxlen)
  90.         length = maxlen;
  92.     ret = copy_from_user(etx_array, buff, length);
  93.     etx_array[length] = '\0';
  94.     // printk(KERN_INFO "proc file write....., %s,%d byte\n", etx_array, length);
  95.     printk(KERN_INFO "proc file write...\n");
  96.     (void)ret;
  97.     return len;
  98. }
  100. static int etx_open(struct inode *inode, struct file *file)
  101. {
  102.     printk(KERN_INFO "Device File Opened...!!!\n");
  103.     return 0;
  104. }
  106. static int etx_release(struct inode *inode, struct file *file)
  107. {
  108.     printk(KERN_INFO "Device File Closed...!!!\n");
  109.     return 0;
  110. }
  112. static ssize_t etx_read(struct file *filp, char __user *buf, size_t len, loff_t *off)
  113. {
  114.     int ret = 0x00;
  115.     printk(KERN_INFO "Readfunction\n");
  116.     ret = copy_to_user(buf, etx_array, sizeof(etx_array) / sizeof(etx_array[0]));
  117.     return len;
  118. }
  119. static ssize_t etx_write(struct file *filp, const char __user *buf, size_t len, loff_t *off)
  120. {
  122.     printk(KERN_INFO "Write Function\n");
  124.     return 0x0;
  125. }
  127. static long etx_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  128. {
  129.     int ret = 0x00;
  130.     switch (cmd)
  131.     {
  132.     case WR_VALUE:
  133.         ret = copy_from_user(&value, (int32_t *)arg, sizeof(value));
  134.         printk(KERN_INFO "Value = %d\n", value);
  135.         break;
  136.     case RD_VALUE:
  137.         ret = copy_to_user((int32_t *)arg, &value, sizeof(value));
  138.         break;
  139.     }
  140.     (void)ret;
  141.     return 0;
  142. }
  144. static int __init etx_driver_init(void)
  145. {
  146.     /*Allocating Major number*/
  147.     if ((alloc_chrdev_region(&dev, 0, 1, "etx_Dev")) < 0)
  148.     {
  149.         printk(KERN_INFO "Cannot allocate major number\n");
  150.         return -1;
  151.     }
  152.     printk(KERN_INFO "Major = %d Minor = %d \n", MAJOR(dev), MINOR(dev));
  154.     /*Creating cdev structure*/
  155.     cdev_init(&etx_cdev, &fops);
  157.     /*Adding character device to the system*/
  158.     if ((cdev_add(&etx_cdev, dev, 1)) < 0)
  159.     {
  160.         printk(KERN_INFO "Cannot add the device to the system\n");
  161.         goto r_class;
  162.     }
  164.     /*Creating struct class*/
  165.     if ((dev_class = class_create(THIS_MODULE, "etx_class")) == NULL)
  166.     {
  167.         printk(KERN_INFO "Cannot create the struct class\n");
  168.         goto r_class;
  169.     }
  171.     /*Creating device*/
  172.     if ((device_create(dev_class, NULL, dev, NULL, "etx_device")) == NULL)
  173.     {
  174.         printk(KERN_INFO "Cannot create the Device 1\n");
  175.         goto r_device;
  176.     }
  178.     /*Creating Proc entry*/
  179.     proc_create("etx_proc", 0666, NULL, &proc_fops);
  181.     printk(KERN_INFO "Device Driver Insert...Done!!!\n");
  182.     return 0;
  184. r_device:
  185.     class_destroy(dev_class);
  186. r_class:
  187.     unregister_chrdev_region(dev, 1);
  188.     return -1;
  189. }
  191. void __exit etx_driver_exit(void)
  192. {
  193.     remove_proc_entry("etx_proc", NULL);
  194.     device_destroy(dev_class, dev);
  195.     class_destroy(dev_class);
  196.     cdev_del(&etx_cdev);
  197.     unregister_chrdev_region(dev, 1);
  198.     printk(KERN_INFO "Device Driver Remove...Done!!!\n");
  199. }
  201. module_init(etx_driver_init);
  202. module_exit(etx_driver_exit);
  204. MODULE_LICENSE("GPL");
  205. MODULE_AUTHOR("zhouchengzhu <1073355312@qq.com>");
  206. MODULE_DESCRIPTION("A Sample Profs Demo");
  207. MODULE_VERSION("2:1.0");
  • 测试 ```c /proc # ls | grep etx_proc etx_proc

write

echo “helloworld1234” >> /proc/etx_proc

读数据

/mnt # hexdump /proc/etx_proc -c proc file opend….. proc file read….. 0000000 h e l l o w o r l d 1 2 3 \n \0 \0 0000010 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 ```