精华内容
下载资源
问答
  • proc函数

    2015-09-15 08:37:52
    1、创建目录 struct proc_dir_entry *proc_mkdir(const char *name, struct ... 类似于mkdir()函数,name是目录名,如“example_dir”,parent是要创建的目录的父目录名(若parent = NULL则创建在/proc目录下)。

    1、创建目录

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

    类似于mkdir()函数,name是目录名,如“example_dir”,parent是要创建的目录的父目录名(若parent = NULL则创建在/proc目录下)。

     


    2.创建proc文件:

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

    create_proc_entry函数用于创建一个一般的proc文件,其中name是文件名,比如“hello”,mode是文件模式,parent是要创建的proc文件的父目录(若parent = NULL则创建在/proc目录下)。

     

     


    3.删除proc文件/目录:

    void remove_dir_entry(const char *name, struct proc_dir_entry *parent);

    参数同proc_mkdir()函数类似

     

    4.创建可读写的proc文件

    proc文件实际上是一个叫做proc_dir entry的struct(定义在proc_fs.h),该struct中有int read_proc和int write_proc两个元素,要实现proc的文件的读写就要给这两个元素赋值。但这里不是简单地将一个整数赋值过去就行了,需要实现两个回调函数。

    读回调函数原型:int mod_read( char *page, char **start, off_t off, int count, int *eof, void *data );

    在用户或应用程序访问该proc文件时,就会调用这个函数,实现这个函数时只需将想要让用户看到的内容放入page即可。

    写回调函数原型:int mod_write( struct file *filp, const char __user *buff, unsigned long len, void *data );

    在用户或应用程序试图写入该proc文件时,就会调用这个函数,实现这个函数时需要接收用户写入的数据(buff参数)。

     

    5. 创建proc文件时赋给它mod_read函数。

    struct proc_dir_entry *create_proc_read_entry(const char *name, mode_t mode, struct proc_dir_entry *base, read_proc_t * proc_read, void * data)

    name : 要创建的文件名;
    mode : 文件掩码,为 0 则按照系统默认的掩码创建文件。
    base : 指定该文件所在的目录,如果为 NULL,则文件被创建在 /proc 根目录下。
    read_proc : 实现该文件的 read_proc 函数。也就是说,当我们读取 "name" 这个文件时(如 cat /proc/myproc_name) ,读取请求会通过这个函数发送到驱动模块,然后在函数里处理的数据会写到 myproc_name 文件中。
    data : 内核忽略此参数,但会把它当作参数传递给 read_proc 这个自定义函数。

    阅读(810) | 评论(0) | 转发(0) |
    评论热议
    展开全文
  • jpeg 编码器和解码器不使用块 proc 函数。将图像读入 8x8 块并使用量化表应用 DCT 变换和量化。然后分离 DC 和 AC 系数,我应用 DPCM 作为 DC 系数,运行长度编码用于 AC系数。编码数据由解码器解码,我实现了编码的...
  • tcl 中的proc 函数

    2021-03-04 17:02:00
    proc get_area {args} { parse_proc_arguments -args $args opt set pattern "" if {[info exists opt(-pattern) ]} { set pattern $opt(-pattern) } set area 0 foreach_in_collection c [get_flat_cell *$...
    proc get_area {args} {
      parse_proc_arguments -args $args opt
      set pattern ""
      if {[info exists opt(-pattern) ]} {
        set pattern $opt(-pattern)
      } 
      set area 0
      foreach_in_collection c [get_flat_cell *${pattern}*] {
        set area [expr [get_attribute $c area] + $area]
      }
      puts "Pattarn \"${pattern}\" cell area is: $area"
      return $area
    }
    define_proc_attributes get_area  \
      -info "get_area for specified pattern" \
      -define_args {
        {-pattern   "instance name pattern"  AString string required } \
      }
    
    • 其中在define_proc_attributes 中默认可选项都是 array 项,在函数主题中处理Opt ,先通过parse_proc_arguments -args $args opt 传递进来。

    然后访问参量 set pattern $opt(-pattern)

    • define_proc_attributes get_area  \
        -info "get_area for specified pattern" \  #cmd -help 打印出命令描述
        -define_args {
          {-pattern   "instance name pattern"  AString string required } \# 
        }
       

     

     

    展开全文
  • 使用proc函数的实例

    千次阅读 2011-11-12 20:36:16
    这个例子使用了内核模块,在/proc目录下创建一个名叫procfs_example的目录,并且在该目录下创建三个普通文件和一个软连接。一个文件名叫foo,只读,内容为foo = 'foo';一个文件名叫bar只读,内容为bar = 'bar';一...
     这个例子使用了内核模块,在/proc目录下创建一个名叫procfs_example的目录,并且在该目录下创建三个普通文件和一个软连接。一个文件名叫foo,只读,内容为foo = 'foo';一个文件名叫bar只读,内容为bar = 'bar';一个叫jiffies,只读,它会动态地显示jiffies的值。软连接名叫jiffies_too,它是对文件jiffies的软连接。
    
    以下是实验内容:
    lzel@lzel-desktop:~/works/proc$ ls
    Makefile  procfs_example.c
    lzel@lzel-desktop:~/works/proc$ cat procfs_example.c
    #include <linux/module.h>
    #include <linux/kernel.h>
    #include <linux/init.h>
    #include <linux/proc_fs.h>
    #include <linux/jiffies.h>
    #include <asm/uaccess.h>

    #define MODULE_VERS "1.0"
    #define MODULE_NAME "procfs_example"
    #define FOOBAR_LEN 8

    struct fb_data_t {
            char name[FOOBAR_LEN+1];
            char value[FOOBAR_LEN+1];
    };
    static struct proc_dir_entry *example_dir,*foo_file,*bar_file,*jiffies_file,*symlink;
    struct fb_data_t foo_data,bar_data;

    static int proc_read_jiffies (char *page,char **stat,off_t off,int count,int *eof,void *data)
    {
            int len;

            len = sprintf(page,"jiffies = %ld\n",jiffies);
            return len;
    }
    static int proc_read_foobar(char *page,char **stat,off_t off,int count,int *eof,void *data)
    {
            int len;
            struct fb_data_t *fb_data = (struct fb_data_t*)data;
            len = sprintf(page,"%s = '%s'\n",fb_data-&gt;name,fb_data-&gt;value);
            return len;
    }
    static int proc_write_foobar (struct file *file,const char *buffer,unsigned long count,void *data)
    {
            int len;
            struct fb_data_t *fb_data = (struct fb_data_t *)data;
        if (count  &gt; FOOBAR_LEN)
            len = FOOBAR_LEN;
        else
            len = count;
        if (copy_from_user(fb_data-&gt;value,buffer,len))
            return -EFAULT;
        fb_data-&gt;value[len] = '\n';
        return len;
    }
    static int __init init_procfs_example (void)
    {
        int rv = 0;
       
        example_dir = proc_mkdir (MODULE_NAME,NULL);
        if (example_dir == NULL)
        {
            rv = -ENOMEM;
            goto out;
        }
        example_dir-&gt;owner = THIS_MODULE;
        jiffies_file = create_proc_read_entry ("jiffies",0444,example_dir,proc_read_jiffies,NULL);
        if (jiffies_file == NULL)
        {
            rv = -ENOMEM;
            goto no_jiffies;
        }
        jiffies_file-&gt;owner = THIS_MODULE;
        foo_file = create_proc_entry ("foo",0644,example_dir);
        if (foo_file == NULL)
        {
            rv = -ENOMEM;
            goto no_foo;
        }
        strcpy(foo_data.name,"foo");
        strcpy(foo_data.value,"foo");
        foo_file-&gt;data = &foo_data;
        foo_file-&gt;read_proc = proc_read_foobar;
        foo_file-&gt;write_proc = proc_write_foobar;
        foo_file-&gt;owner = THIS_MODULE;
       
        bar_file = create_proc_entry ("bar",0644,example_dir);
        if (bar_file == NULL)
        {
            rv = -ENOMEM;
            goto no_bar;
        }
        strcpy(bar_data.name,"bar");
        strcpy(bar_data.value,"bar");
        bar_file-&gt;data = &bar_data;
        bar_file-&gt;read_proc = proc_read_foobar;
        bar_file-&gt;write_proc = proc_write_foobar;
        bar_file-&gt;owner = THIS_MODULE;
       
        symlink = proc_symlink ("jiffies_too",example_dir,"jiffies");
        if (symlink == NULL)
        {
            rv = -ENOMEM;
            goto no_symlink;
        }
        symlink-&gt;owner = THIS_MODULE;
       
        printk(KERN_INFO"%s %s initialised\n",MODULE_NAME,MODULE_VERS);
        return 0;
        no_symlink:
            remove_proc_entry("bar",example_dir);
        no_bar:
            remove_proc_entry ("foo",example_dir);
        no_foo:
            remove_proc_entry ("jiffies",example_dir);
        no_jiffies:
            remove_proc_entry (MODULE_NAME,NULL);
        out:
            return rv;
    }
    static void __exit cleanup_procfs_example (void)
    {
        remove_proc_entry("jiffies_too",example_dir);
        remove_proc_entry("bar",example_dir);
        remove_proc_entry("foo",example_dir);
        remove_proc_entry("jiffies",example_dir);
        remove_proc_entry(MODULE_NAME,NULL);
       
        printk(KERN_INFO"%s %s removed\n",MODULE_NAME,MODULE_VERS);
    }   
    module_init(init_procfs_example);
    module_exit(cleanup_procfs_example);
    MODULE_LICENSE("Dual BSD/GPL");
    MODULE_AUTHOR("lzel");
    MODULE_DESCRIPTION("procfs examples");
    lzel@lzel-desktop:~/works/proc$ cat Makefile
    TARGET=procfs_example
    KERNEL=`uname -r`
    KDIR = /usr/src/linux-headers-$(KERNEL)
    PWD = `pwd`
    obj-m:=$(TARGET).o
    default:
        make -C $(KDIR) M=$(PWD) modules
    clean:
        make -C $(KDIR) M=$(PWD) clean
    lzel@lzel-desktop:~/works/proc$ sudo make
    [sudo] password for lzel:
    make -C /usr/src/linux-headers-`uname -r` M=`pwd` modules
    make[1]: 正在进入目录 `/usr/src/linux-headers-2.6.24-21-generic'
      CC [M]  /home/lzel/works/proc/procfs_example.o
      Building modules, stage 2.
      MODPOST 1 modules
      CC      /home/lzel/works/proc/procfs_example.mod.o
      LD [M]  /home/lzel/works/proc/procfs_example.ko
    make[1]:正在离开目录 `/usr/src/linux-headers-2.6.24-21-generic'
    lzel@lzel-desktop:~/works/proc$ ls
    procfs_example.c   procfs_example.ko     procfs_example.mod.o  procfs_example.o
    Makefile  Module.symvers   procfs_example.mod.c       
    lzel@lzel-desktop:~/works/proc$ sudo insmod procfs_example.ko
    lzel@lzel-desktop:~/works/proc$ lsmod |head
    Module                  Size  Used by
    procfs_example          4024  0
    ipv6                  267780  10
    af_packet              23812  2
    rfcomm                 41744  2
    l2cap                  25728  13 rfcomm
    bluetooth              61156  4 rfcomm,l2cap
    ppdev                  10372  0
    cpufreq_conservative     8712  0
    cpufreq_ondemand        9740  0
    lzel@lzel-desktop:~/works/proc$ dmesg |tail
    [   72.183969] Bluetooth: RFCOMM socket layer initialized
    [   72.184566] Bluetooth: RFCOMM TTY layer initialized
    [   72.184593] Bluetooth: RFCOMM ver 1.8
    [   75.149946] NET: Registered protocol family 17
    [   83.211043] NET: Registered protocol family 10
    [   83.222138] lo: Disabled Privacy Extensions
    [   94.443153] eth1: no IPv6 routers present
    [ 4620.210470] procfs_example 1.0 initialised //初始化完成
    lzel@lzel-desktop:~/works/proc$
    现在到/proc中去看看,是不是如我们所设想的一样呢。
    lzel@lzel-desktop:~/works/proc$ ls /proc/|grep procfs_example
    procfs_example //果然有procfs_example目录,这样就让我们进入到这个目录去验证其他的文件
    lzel@lzel-desktop:~/works/proc$ cd /proc/procfs_example/
    lzel@lzel-desktop:/proc/procfs_example$ ll //确实有三个普通文件和一个软连接
    总用量 0
    -rw-r--r-- 1 root root 0 2008-10-11 20:23 bar
    -rw-r--r-- 1 root root 0 2008-10-11 20:23 foo
    -r--r--r-- 1 root root 0 2008-10-11 20:23 jiffies
    lrwxrwxrwx 1 root root 7 2008-10-11 20:23 jiffies_too -&gt; jiffies
    lzel@lzel-desktop:/proc/procfs_example$ cat bar //查看bar
    bar = 'bar'
    lzel@lzel-desktop:/proc/procfs_example$ cat foo //查看foo
    foo = 'foo'
    lzel@lzel-desktop:/proc/procfs_example$ cat jiffies //查看jiffies
    jiffies = 1153731
    lzel@lzel-desktop:/proc/procfs_example$ cat jiffies_too //查看软连接
    jiffies = 1158238
    lzel@lzel-desktop:/proc/procfs_example$
    细心的读者也许看到了,两个jiffies的值是不同的。因为 jiffies是内核中的一个全局变量,用来记录自系统启动以来产生的节拍数。它自从开机以来就一刻不停的增长着。所以可以用 jiffies/tick_rate 来计算计算运行了多长时间。jiffies定义在文件<linux/jiffies.h>中:

    extern unsigned long volatile jiffies;

    我们可以用一下命令动态地查看jiffies的变化情况:
    lzel@lzel-desktop:/proc/procfs_example$ watch cat jiffies
    或者
    lzel@lzel-desktop:/proc/procfs_example$ watch cat jiffies_too
    两者一样。
    展开全文
  • proc操作函数

    2010-03-26 23:14:00
    1、create_proc_entry 函数 在 /proc 文件系统中创建一个虚拟文件。这个函数可以接收一个文件名、一组权限和这个文件在 /proc 文件系统中出现的位置。create_proc_entry 的返回值是一个 proc_dir_entry 指针(或者为...

    1、create_proc_entry 函数
        在 /proc 文件系统中创建一个虚拟文件。这个函数可以接收一个文件名、一组权限和这个文件在 /proc 文件系统中出现的位置。create_proc_entry 的返回值是一个 proc_dir_entry 指针(或者为 NULL,说明在 create 时发生了错误)。然后就可以使用这个返回的指针来配置这个虚拟文件的其他参数,例如在对该文件执行读操作时应该调用的函数。函数原型为:
        struct proc_dir_entry *create_proc_entry( const char *name, mode_t mode, struct proc_dir_entry *parent );
    2、remove_proc_entry函数
        删除/proc文件系统中的一个虚拟文件。要使用这个函数,需要提供文件名字符串,以及这个文件在 /proc 文件系统中的位置(parent)。函数原型为:
        void remove_proc_entry( const char *name, struct proc_dir_entry *parent );
    3、parent 参数可以为 NULL(表示 /proc 根目录),也可以是很多其他值,这取决于我们希望将这个文件放到什么地方。下表列出了可以使用的其他一些父 proc_dir_entry,以及它们在这个文件系统中的位置。

    proc_dir_entry 快捷变量

    proc_dir_entry在文件系统中的位置
    proc_root_fs/proc
    proc_net/proc/net
    proc_bus/proc/bus
    proc_root_driver/proc/driver

    4、 回调函数

    我们可以使用 write_proc 函数向 /proc 中写入一项。这个函数的原型如下:

    int mod_write( struct file *filp, const char __user *buff,
                   unsigned long len, void *data );

    filp 参数实际上是一个打开文件结构(我们可以忽略这个参数)。buff 参数是传递给您的字符串数据。缓冲区地址实际上是一个用户空间的缓冲区,因此我们不能直接读取它。len 参数定义了在 buff 中有多少数据要被写入。data 参数是一个指向私有数据的指针。在这个模块中,我们声明了一个这种类型的函数来处理到达的数据。

    Linux 提供了一组 API 来在用户空间和内核空间之间移动数据。对于 write_proc 的情况来说,我们使用了 copy_from_user 函数来维护用户空间的数据。

    5、读回调函数

    我们可以使用 read_proc 函数从一个 /proc 项中读取数据(从内核空间到用户空间)。这个函数的原型如下:

    int mod_read( char *page, char **start, off_t off,
                  int count, int *eof, void *data );

    page 参数是这些数据写入到的位置,其中 count 定义了可以写入的最大字符数。在返回多页数据(通常一页是 4KB)时,我们需要使用 startoff 参数。当所有数据全部写入之后,就需要设置 eof(文件结束参数)。与 write 类似,data 表示的也是私有数据。此处提供的 page 缓冲区在内核空间中。因此,我们可以直接写入,而不用调用 copy_to_user

    6、其他有用的函数

    我们还可以使用 proc_mkdirsymlinks 以及 proc_symlink 在 /proc 文件系统中创建目录。对于只需要一个 read 函数的简单 /proc 项来说,可以使用 create_proc_read_entry,这会创建一个 /proc 项,并在一个调用中对 read_proc 函数进行初始化。这些函数的原型如下:

    清单:其他有用的 /proc 函数

            
    /* Create a directory in the proc filesystem */
    struct proc_dir_entry *proc_mkdir( const char *name,
                                         struct proc_dir_entry *parent );
    /* Create a symlink in the proc filesystem */
    struct proc_dir_entry *proc_symlink( const char *name,
                                           struct proc_dir_entry *parent,
                                           const char *dest );
    /* Create a proc_dir_entry with a read_proc_t in one call */
    struct proc_dir_entry *create_proc_read_entry( const char *name,
                                                      mode_t mode,
                                                      struct proc_dir_entry *base,
                                                      read_proc_t *read_proc,
                                                      void *data );
    /* Copy buffer to user-space from kernel-space */
    unsigned long copy_to_user( void __user *to,
                                  const void *from,
                                  unsigned long n );
    /* Copy buffer to kernel-space from user-space */
    unsigned long copy_from_user( void *to,
                                    const void __user *from,
                                    unsigned long n );
    /* Allocate a 'virtually' contiguous block of memory */
    void *vmalloc( unsigned long size );
    /* Free a vmalloc'd block of memory */
    void vfree( void *addr );
    /* Export a symbol to the kernel (make it visible to the kernel) */
    EXPORT_SYMBOL( symbol );
    /* Export all symbols in a file to the kernel (declare before module.h) */
    EXPORT_SYMTAB

    参考自:http://www.ibm.com/developerworks/cn/linux/l-proc.html

    展开全文
  • TCL proc函数调用

    千次阅读 2019-12-02 17:58:18
    TCL里的过程,等效于C语言里的函数(function) 一个标准的proc一般具有如下的特点 proc proc_name {argument} { ...... return return_value } 1 2 3 4 在使用的时候,直接输入过程名即可执行。 先来看一个下面...
  • 缺少 proc_open 函数 如果proc_open被禁用,系统的部分自动化功能将会受到影响,比如自动化安装、自动化任务、清缓存等,但是并不妨碍系统基础功能的运行。 缺少 proc_get_status 函数 如果proc_get_status被禁用...
  • 移植代码的时候遇到create_proc_read_entry函数,新的内核里已经没有这个函数了,只能找对应的替换。 proc_create_data函数就是可以替换掉它,本文主要讲解下如何使用proc_create_data,以及相关的参数配置。 ...
  • /proc相关函数

    2009-11-07 18:17:00
    create_proc_entry()创建一个文件proc_symlink() 创建符号链接proc_mknod() 创建设备文件proc_mkdir() 创建目录remove_proc_entry() 删除文件或目录
  • 在使用cat 命令读取proc 文件时,奇怪的发现读函数被执行了三次,这三次都是有原因的。 proc函数代码片断(直接读取内核模块的某个变量值) static int proc_read_addr(char *page, char **start, off_t ...
  • PROC FCMP创建函数

    2020-07-13 23:57:28
    使用数据步骤语法创建自定义函数 语法: OPTIONS CMPLIB=libref.table | (libref.table-1...libref.table-n) PROC FCMP OUTLIB=libref.table.package; FUNCTION function-name(arguments <$>)<$>&...
  • linux 内核 proc_create 函数 内幕初探.pdf
  • linux Proc 文件系统 内核对Proc 文件系统的函数
  • 创建proc文件,yong
  • lesson 10 :proc函数的使用 1. proc sum {arg1 arg2} { set x [expr $arg1+$arg2]; return $x } puts " The sum of 2 + 3 is: [sum 2 3]\n\n" //[语法] :proc procName { var1 var2 ... } {body}说明:1. ...
  • linux 内核 proc_create 函数 内幕初探

    千次阅读 2019-07-29 16:39:45
    一直以为PROC文件系统很是晦涩难懂,平时仅仅是使用它,不愿意去触碰内核中的具体实现。今天突发奇想,想看看里面究竟是怎么实现的,结果……真是大跌眼镜,没想到...该函数会创建一个PROC entry,用户可以通过对...
  • proc文件的读写函数

    千次阅读 2013-03-08 10:16:53
    每一个文件都有相应的文件操作表,最主要的就是读操作和写操作了, proc文件的读写函数得注意其对应的返回值,如果在读函数内一直返回一个正数,则上层会认为该文件还有数据需要读取,会一直无限的读下去。...
  • 前边说过目录项创建时一般都使用默认的读写函数,本节就来看看默认的文件操作函数的定义。前边已经引用过该定义,此处再次引用: static const struct file_operations proc_file_operations = {  .llseek = ...
  • create_proc_read_entry函数

    千次阅读 2017-01-15 00:00:25
    struct proc_dir_entry *create_proc_read_entry (const char *name, mode_t mode, struct proc_dir_entry *base, read_proc_t *read_proc, void *data); 说明: name : 要创建的文件名; mode : ...
  • proc目录是系统模拟出来的一个文件系统,本身并不存在于磁盘上,其中的文件都表示内核参数的信息,这些信息分两类,一类是可都可写的,这 类参数都在“/proc/sys”目录下,另一类是只读的,就是“/proc/sys”目录...
  • 汇编中与函数调用有关的几个伪指令
  • 一、头文件: .../*此函数只负责在proc中创建一个只读文件,即能在proc中看到这个文件。 * */ struct proc_dir_entry* create_proc_entry (const char *name,mode_t mode,struct proc_dir_entry *

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 157,209
精华内容 62,883
关键字:

proc函数