使用proc文件系统

最新推荐文章于 2025-05-20 14:26:36 发布
最新推荐文章于 2025-05-20 14:26:36 发布
阅读量795 收藏 1
点赞数
分类专栏： # 嵌入式Linux相关知识汇总

以下是内核提供的几个重要的proc文件系统接口：

（1）read_proc

  1. int (*read_proc)(char *page, char **start, off_t offset, int count, int *eof, void *data); 

read_proc是proc文件输出信息接口，page是将要写入数据的缓冲区指针，start是数据将要写入的页面位置，offset是页面中的偏移量；count是写入的字节数，eof是一个整形数,当没有更多数据时，必须配置这个参数，data是驱动程序特定的数据指针，可用于内部使用。函数的返回值表示实际放入页面缓冲区的数据字节数。

（2）create_proc_entry

  1. struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,struct proc_dir_entry *parent); 

create_proc_entry用来创建proc目录。其中name为文件名称；mode为文件权限；parent为文件的父目录的指针，它为null时代表父目录为/proc。

（3）remove_proc_entry

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

remove_proc_entry用于删除上面函数创建的proc条目，参数name给出要删除的proc条目的名称，参数parent指定建立的proc条目所在的目录。

（4）proc_mkdir

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

该函数用于创建一个proc目录，参数name用于指定要创建的proc目录的名称，参数parent为该proc目录所在的目录。

在驱动程序中使用proc文件系统，就要了解proc_dir_entry结构：

  1. struct proc_dir_entry {  
  2.     unsigned int low_ino;  
  3.     unsigned short namelen;  
  4.     const char *name;  
  5.     mode_t mode;  
  6.     nlink_t nlink;  
  7.     uid_t uid; gid_t gid;               //进程ID  
  8.     loff_t size;  
  9.     const struct inode_operations *proc_iops;   //结点操作  
  10.     const struct file_operations *proc_fops;    //文件操作  
  11.     get_info_t *get_info;  
  12.     struct module *owner;               //拥有者  
  13.     struct proc_dir_entry *next, *parent, *subdir;  
  14.     void *data;  
  15.     read_proc_t *read_proc;         //读接口  
  16.     write_proc_t *write_proc;           //写接口  
  17.     atomic_t count;/* 引用计数*/  
  18.     int pde_users;  
  19.     spinlock_t pde_unload_lock;  
  20.     struct completion *pde_unload_completion;  
  21.     shadow_proc_t *shadow_proc;  
  22. };  

例1.9  proc文件系统驱动程序实例

下面的例子演示了如何访问 proc 文件系统。代码见光盘\src\1drivermodel\1-9proc。核心代码如下所示：

  1. //结点操作  
  2. static struct inode_operations simple_inode_operations = {  
  3.     .permission = simple_permission,  
  4. };  
  5. int init_simple_module( void )  
  6. {  
  7.     int ret = 0;  
  8.     simple_buffer = (char *)vmalloc( MAX_simple_LENGTH );  
  9.     if (!simple_buffer)   
  10.     {  
  11.         ret = -ENOMEM;  
  12.     }   
  13.     else   
  14.     {  
  15.         memset( simple_buffer, 0, MAX_LENGTH );  
  16.         proc_entry = create_proc_entry( "demo", 0644, NULL );  
  17.         if (proc_entry == NULL)  
  18.         {  
  19.             ret = -ENOMEM;  
  20.             vfree(simple_buffer);  
  21.             printk(KERN_INFO "demo: Couldn't create proc entry\n");  
  22.         }   
  23.         else  
  24.         {  
  25.             proc_entry->proc_iops = &simple_inode_operations;//结点操作  
  26.             proc_entry->read_proc = simple_read;  
  27.             proc_entry->write_proc = simple_write;  
  28.             proc_entry->owner = THIS_MODULE;  
  29.             printk(KERN_INFO "demo: Module loaded.\n");  
  30.         }  
  31.     }  
  32.     return ret;  
  33. }  
  34. 以下是读写操作的框架：
    1. int simple_read( char *page, char **start, off_t off,int count, int *eof, void *data )  
    2. {  
    3.     int size = 0;  
    4.     struct task_struct *p;  
    5.     char state;  
    6.     size+=sprintf(page+size,  
    7.         "%5s%7s%7s%7s%7s%7s%7s  %s\n\n",  
    8.         "PID","UID","PRIO","POLICY",  
    9.         "STATE","UTIME","STIME","COMMAND");  
    10.     for_each_process(p)  
    11.     {  
    12.         switch((int)p->state)  
    13.         {  
    14.         case -1: state='Z'; break;  
    15.         case 0: state='R'; break;  
    16.         default: state='S'; break;  
    17.         }  
    18.         size+=sprintf(page+size,  
    19.             "%5d%7d%7d%7d%7c%7d%7d  %s\n",  
    20.             (int)p->pid,  
    21.             (int)p->uid,  
    22.             (int)p->rt_priority,  
    23.             (int)p->policy,  
    24.             state,  
    25.             (int)p->utime,  
    26.             (int)p->stime,  
    27.             p->comm);  
    28.     }  
    29.     return (size);  
    30. }  
    31. ssize_t simple_write( struct file *filp, const char __user *buff,unsigned long len, void *data )  
    32. {  
    33.     if(len>MAX_LENGTH)len=MAX_LENGTH;  
    34.     if (copy_from_user(simple_buffer, buff, len ))  
    35.     {  
    36.         return -EFAULT;  
    37.     }  
    38.     simple_buffer[len] = 0;  
    39.     printk(KERN_INFO "simple_write: %s\n",simple_buffer);  
    40.     return len;  
    41. }  
    proc文件的操作权限控制代码：
    1. static int simple_permission(struct inode *inode, int op, struct nameidata *foo)  
    2. {  
    3.     printk(KERN_INFO "simple_permission op %d\n",op);  
    4.     if(itype==op)  
    5.     {  
    6.         return -EACCES;  
    7.     }  
    8.     return 0;  
    9. }  
    运行结果如下：
    1. [root@urbetter /home]# insmod demo.ko   
    2. demo: Module loaded.  
    3. [root@urbetter /home]# cat /proc/demo  
    4. simple_permission op 36  
    5.   PID    UID   PRIO POLICY  STATE  UTIME  STIME  COMMAND  
    6.     1      0      0      0      S      1    398  init  
    7.     2      0      0      0      S      0      0  kthreadd  
    8.     3      0      0      0      S      0      0  ksoftirqd/0  
    9.     4      0     99      1      S      0      0  watchdog/0  
    10.     5      0      0      0      S      0      0  events/0  
    11.     6      0      0      0      S      0     41  khelper  
    12.   145      0      0      0      S      0      0  kblockd/0  
    13.   156      0      0      0      S      0      0  khubd  
    14.   159      0      0      0      S      0      0  kseriod  
    15.   163      0      0      0      S      0      4  kmmcd  
    16.   187      0      0      0      S      0      0  pdflush  
    17.   188      0      0      0      S      0      0  pdflush  
    18.   189      0      0      0      S      0      0  kswapd0  
    19.   236      0      0      0      S      0      0  aio/0  
    20.   244      0      0      0      S      0     18  nfsiod  
    21.   924      0      0      0      S      0      0  mtdblockd  
    22.   957      0      0      0      S      0      0  kpsmoused  
    23.  1011      0      0      0      S      0     78  rpciod/0  
    24.  1042      0      0      0      S      0      0  syslogd  
    25.  1045      0      0      0      S      1      7  inetd  
    26.  1079      0      0      0      S    707    468  qpe  
    27.  1088      0      0      0      S      2     13  sh  
    28.  1089      0      0      0      S      0      1  init  
    29.  1090      0      0      0      S      0      0  init  
    30.  1091      0      0      0      S      0      2  init  
    31.  1109      0      0      0      S     41     20  qss  
    32.  1110      0      0      0      S    141     42  quicklauncher  
    33.  1118      0      0      0      R      0      2  cat  
    34. [root@urbetter /home]# echo "fgj">/proc/demo  
    35. simple_permission op 34  
    36. simple_write: fgj  
    如果将itype配置为34，则屏蔽对/proc/demo的写操作。
    1. [root@urbetter /home]# insmod demo.ko itype=34 
    2. [root@urbetter /home]# echo "fgj">/proc/demo  
    3. simple_permission op 34  
    4. -/bin/sh: can't create /proc/demo: Permission denied  

​ 详解Linux内核通信-proc文件系统
m0_74282605的博客
11-17 1433
使用 /proc 文件系统来访问 Linux 内核的内容，这个虚拟文件系统在内核空间和用户空间之间打开了一个通信窗口：/proc 文件系统是一个虚拟文件系统，通过它可以使用一种新的方法在 Linux内核空间和用户间之间进行通信。在 /proc 文件系统中，我们可以将对虚拟文件的读写作为与内核中实体进行通信的一种手段，但是与普通文件不同的是，这些虚拟文件的内容都是动态创建的。本文对 /proc 虚拟文件系统进行了介绍，并展示了它的用法。最初开发 /proc 文件系统是为了提供有关系统中进程的信息。
proc源码解析（五）--proc的管理函数
若木的专栏
12-07 7808
    proc目录是系统模拟出来的一个文件系统，本身并不存在于磁盘上，其中的文件都表示内核参数的信息，这些信息分两类，一类是可都可写的，这 类参数都在“/proc/sys”目录下，另一类是只读的，就是“/proc/sys”目录之外的其他目录和文件，当然这只是一种惯例，实际在其他目录下建立可读写的/proc文件也是可以的。    Linux内核在2.4以后/proc目录文件的建立已经变得很容易
read_proc:c库读取/proc目录-开源
08-05
阅读 /proc 目录以获取有关作业、仅库的信息。 将其用于自己的程序。 使用现成的函数来获取作业的pid、ppid、name、status、uid，看看它们是否正在运行。
Linux学习笔记之proc文件使用篇
small_a_black的博客
09-06 1341
proc 这里要注意的是， “fflush(stdout)； “， 看到flush 和 sdout，大家就算不知道实现原理，应该也是可以猜到其中的含义了。 代码功能总体是比较简单的，最好的学习方法就是，自己修改其中的一些变量值，看下跑起来的效果就会有比较深的理解了。 Maekfile 为了使我们编写的小程序可以顺利执行，需要生成一个binary。这个时候就需要我们自己写一个简单的M...
read_proc的用法实例
热门推荐
刘末的专栏
07-27 1万+
说明 本测试程序主要参考了《linux设备驱动程序》第三版的第四章“调试技术”的‘/proc文件’一节。 并对一些关键函数进行了实例化。 以下是mod1.c #include #include #include #include   /* read_pr
使用 proc 文件系统来访问 Linux 内核的内容
09-28
使用 proc 文件系统来访问 Linux 内核的内容使用 proc 文件系统来访问 Linux 内核的内容使用 proc 文件系统来访问 Linux 内核的内容使用 proc 文件系统来访问 Linux 内核的内容使用 proc 文件系统来访问 Linux 内核...
嵌入式Linux系统编程 — 5.7 Linux系统中proc文件系统
几度春风里的博客
07-01 1482
proc文件系统，也称为进程信息文件系统（Process Information file system），是一种在 Linux 和其他类 Unix 系统中存在的虚拟文件系统。它被设计用来提供一种机制，允许用户空间访问内核空间的数据结构和信息。但是与普通文件不同的是， proc 文件系统是动态创建的，文件本身并不存在于磁盘当中、 只存在于内存当中,与 devfs 一样，都被称为虚拟文件系统。
【操作系统】实验二：观察Linux，使用proc文件系统
superiony的博客
12-12 1415
本文主要是介绍了操作系统实验二，即观察Linux，使用proc文件系统，属于操作系统专栏
uproc:用户空间proc文件系统
04-29
uproc是userspace / proc文件系统的缩写。 uproc允许您将程序的状态导出到目录结构中，就像linux内核的/ proc文件系统一样。 设计 uproc运行一个eventloop来处理读写请求，因此uproc应该在一个独立的线程中运行。 ...
Linux下Proc文件系统的编程剖析.pdf
09-06
Proc 文件系统的主要特点是它提供了一个标准的文件系统接口，使得用户程序可以使用标准的文件操作来访问 Proc 文件系统中的文件。 在 Proc 文件系统中，文件的读写操作是通过标准的文件系统接口来实现的。用户程序...
linux下proc文件的读写(部分转载)
08-23
linux下proc读写及创建，注意事项，及案例分析。
linux 内核模块 proc,无法理解Linux内核模块中read_proc的工作
weixin_42502295的博客
05-13 579
我正在此page审查内核模块示例程序中使用的read_proc如下：int fortune_read( char *page, char **start, off_t off,int count, int *eof, void *data ){int len;if (off > 0) {*eof = 1;return 0;}/* Wrap-around */if (next_fortune ...
/proc读取
LBO4031的专栏
12-18 977
读取/proc下文件数据方法有两种:       1.使用read_proc,此方法一次最多只能返回1 PAGE(页)内页大小的数据，不适合大数据量交换             创建:使用 create_proc_read_entry(NAEM, MASK, MODE, read_proc, void *for_read_proc_data);                     前面3
linux c语言编译 proc,c - Linux内核代码中的create_proc_entry（）和read_proc的替代方法 - 堆栈内存溢出...
weixin_39781326的博客
05-03 373
函数proc_create_data具有原型struct proc_dir_entry *proc_create_data(const char *, umode_t,struct proc_dir_entry *,const struct file_operations *,void *);第四个参数是文件操作的结构。为了指定如何从文件中读取数据，您需要设置该结构的.read字段：这是在proc...
read_proc的原理与使用
Rain的专栏
01-25 2157
这仅仅我个人认知，如有错误，欢迎指正。 要理解它的原理，首先要理解函数__proc_file_read，它位于fs/proc/generic.c中。在该文件中的注册部分提到三种用法。 1. 表示不使用start参数，这种情况下，要读取的内容应该在一个page之内，其中模块实现中的len表示整个读取到的数据总长度，即是多次进入proc读取到的数据； 2.Hack用法，offset实际上
linux内核编程入门之proc文件读写
我的博客
11-26 902
linux内核编程入门之proc文件读写
proc系统使用
WEINILUO的博客
11-11 1133
proc seq_file
掌握Linux系统状态：read_proc库实现/proc目录读取
最新发布
weixin_35750953的博客
05-20 907
Linux系统中的/proc目录包含了大量的运行时信息，其中目录提供特定进程的信息。get_pid()函数主要用于遍历/proc目录，以便找到当前活跃的进程ID。其遍历策略可以通过下面的伪代码进行说明：= NULL) {// 仅处理数字目录，这些目录代表进程ID// 这里可以加入其他进程过滤条件，例如排除系统进程在上述代码中，opendir()函数被用于打开/proc目录，接着使用readdir()函数读取目录项。
ldd3学习笔记——通过查询调试之/proc文件系统
weixin_41982689的博客
02-17 382
零、写在开头的话   在这里整理一些关于ldd3这本书的学习笔记，由于才开始学习，故此这里写下的是自己的理解，可能会有一些偏差，不过学习是积累的过程，后面学习有了新的发现再回过头来进行修改，也是可以的。   使用优快云博客来记录是因为可以有较好的格式，在代码的表现上比Word好太多了，并且可以得到保存和分类。话不多说，开始整理一些内容 一、通过查询方式调试   在ldd3中，查询调试方法的前一节...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值