精华内容
下载资源
问答
  • 内核读写文件

    2008-10-10 09:28:00
    内核读写文件当然有用,比如打印的一些重要信息掉电后就看不到了,所以要存在flash里。直接调用flash驱动读写,还不如直接读写文件。应用程序可以直接用open, read, write, close文件操作,对应到内核的系统调用是...
    内核读写文件当然有用,比如打印的一些重要信息掉电后就看不到了,所以要存在flash里。直接调用flash驱动读写,还不如直接读写文件。应用程序可以直接用open, read, write, close文件操作,对应到内核的系统调用是sys_open, sys_read, sys_write, sys_close.在syscall里排号挺靠前的,第3,4,5,6
    SYSCALL(0, 0) /* 00 */
    SYSCALL(sys_exit, 1)
    SYSCALL(sys_ni_syscall, 0)
    SYSCALL(sys_read, 3)
    SYSCALL(sys_write, 3)
    SYSCALL(sys_open, 3) /* 05 */
    SYSCALL(sys_close, 1)

    一般没人直接调用sys_*函数,可能可以,我没试过。
    sys_open -> do_sys_open -> filp_open
    sys_close -> filp_close
    sys_read -> vfs_read -> file->f_op->read
    sys_write -> vfs_write -> file->f_op->write

    因为是内核空间,要读写用户空间数据需要在read/write前设置,用来表示buf是内核地址还是用户地址,0xc0000000以上还是以下。
    file->f_pos表示文件内读写位置,open时是0,read后可修改file->f_pos的值,再read/write

    tsfile = filp_open(tsdev->fileName, O_RDONLY, 0);
    set_fs(KERNEL_DS);
    err = tsfile->f_op->read(tsfile, tsbuf, TSBUFSIZE, &(tsfile->f_pos));
    set_fs(USER_DS);
    filp_close(tsfile, 0);
    展开全文
  • 内核读写文件

    2015-04-20 14:40:50
    在kernel中读写文件和在userspace下读取文件需要调用不同的interface。 全局变量: # define FILE_PATH "/data/xxxx.cfg" # define BUF_SIZE 128 char global_buf[BUF_SIZE]; struct file *fp; ...

    最近在安卓下实现一个new feature的时候,需要在驱动中读取sysfs中的一个文件的数据,经过计算后保存到另一个文件中。
    在kernel中读写文件和在userspace下读取文件需要调用不同的interface。

    全局变量:

    #define FILE_PATH "/data/xxxx.cfg"
    #define BUF_SIZE 128
    char global_buf[BUF_SIZE];
    struct file *fp;

    读函数:

    static int get_data_from_sysfs(const char *path, char *buf)
    {
    
        mm_segment_t fs;
    
        fp = filp_open(path, O_RDONLY, 0644);
        if (unlikely(IS_ERR(fp))) {
            pr_info("Fail to open file \"%s\"\n", path);
            return -1;
        }
    
        fp->f_pos = 0;
        fs = get_fs();
        set_fs(KERNEL_DS);
        fp->f_op->read(fp, buf, BUF_SIZE, &(fp->f_pos));
        set_fs(fs);
        filp_close(fp, NULL);
    
        return 0;
    }

    写函数

    static int update_data_to_sysfs(void)
    {
        mm_segment_t fs;
    
        sprintf(global_buf, "%u    %u    %u\n", aaa,
                bbb, ccc);
    
        fp = filp_open(FILE_PATH, O_RDWR | O_CREAT, 0644);
        fp->f_pos = 0;
        fs = get_fs();
        set_fs(KERNEL_DS);
        fp->f_op->write(fp, global_buf, sizeof(global_buf), &fp->f_pos);
        set_fs(fs);
    
        return 0;
    }

    函数原型中,fp->f_op->write和fp->f_op->read的第二个参数都是userspace下的数据,所以需要经过转换成内核态可用的,调用完成后在转换回用户态。

    展开全文
  • linux内核读写文件

    2014-06-30 11:04:48
    在VFS的支持下,用户态进程读写任何类型的文件系统都可以使用read和write着两个系统调用,但是在linux内核中没有这样的系统调用我们如何操作文件呢?我们知道read和write在进入内核态之后,实际执行的是sys_read 和...

    在VFS的支持下,用户态进程读写任何类型的文件系统都可以使用read和write着两个系统调用,但是在linux内核中没有这样的系统调用我们如何操作文件呢?我们知道read和write在进入内核态之后,实际执行的是sys_read 和sys_write,但是查看内核源代码,发现这些操作文件的函数都没有导出(使用EXPORT_SYMBOL导出),也就是说在内核模块中是不能使用的,那如何是好?

    通过查看sys_open的源码我们发现,其主要使用了do_filp_open()函数,该函数在fs/namei.c中,而在改文件中,filp_open函数也是调用了do_filp_open函数,并且接口和sys_open函数极为相似,调用参数也和sys_open一样,并且使用EXPORT_SYMBOL导出了,所以我们猜想该函数可以打开文件,功能和open一样。使用同样的查找方法,我们找出了一组在内核中操作文件的函数,如下:

    功能 函数原型
    打开文件 struct file *filp_open(const char *filename, int flags, int mode)
    读取文件 ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
    写文件 ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
    关闭文件 int filp_close(struct file *filp, fl_owner_t id)

    我们注意到在vfs_read和vfs_write函数中,其参数buf指向的用户空间的内存地址,如果我们直接使用内核空间的指针,则会返回-EFALUT。所以我们需要使用
    set_fs()和get_fs()宏来改变内核对内存地址检查的处理方式,所以在内核空间对文件的读写流程为:

    1. mm_segment_t fs = get_fs();
    2. set_fs(KERNEL_FS);
    3. //vfs_write();
    4. vfs_read();
    5. set_fs(fs);

    下面为一个在内核中对文件操作的例子:

    1. #include <linux/module.h>
    2. #include <linux/init.h>
    3. #include <linux/fs.h>
    4. #include <linux/uaccess.h>
    5. static char buf[] = "你好";
    6. static char buf1[10];
    7. int __init hello_init(void)
    8. {
    9.     struct file *fp;
    10.     mm_segment_t fs;
    11.     loff_t pos;
    12.     printk("hello enter\n");
    13.     fp = filp_open("/home/niutao/kernel_file", O_RDWR | O_CREAT, 0644);
    14.     if (IS_ERR(fp)) {
    15.         printk("create file error\n");
    16.         return -1;
    17.     }
    18.     fs = get_fs();
    19.     set_fs(KERNEL_DS);
    20.     pos = 0;
    21.     vfs_write(fp, buf, sizeof(buf), &pos);
    22.     pos = 0;
    23.     vfs_read(fp, buf1, sizeof(buf), &pos);
    24.     printk("read: %s\n", buf1);
    25.     filp_close(fp, NULL);
    26.     set_fs(fs);
    27.     return 0;
    28. }
    29. void __exit hello_exit(void)
    30. {
    31.     printk("hello exit\n");
    32. }
    33. module_init(hello_init);
    34. module_exit(hello_exit);
    35. MODULE_LICENSE("GPL");
    展开全文
  • Linux内核读写文件

    千次阅读 2010-08-27 10:24:00
    在用户态,读写文件可以通过read和write这两个系统调用来完成(C库函数实际上是对系统调用的封装)。 但是,在内核态没有这样的系统调用,我们又该如何读写文件呢?

    1. 序曲

    在用户态,读写文件可以通过readwrite这两个系统调用来完成(C库函数实际上是对系统调用的封装) 但是,在内核态没有这样的系统调用,我们又该如何读写文件呢?

    阅读linux内核源码,可以知道陷入内核执行的是实际执行的是sys_readsys_write这两个函数,但是这两个函数没有使用EXPORT_SYMBOL导出,也就是说其他模块不能使用。

    fs/open.c中系统调用具体实现如下(内核版本2.6.34.1)

    SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, int, mode)

    {

    long ret;

           if (force_o_largefile())

                  flags |= O_LARGEFILE;

     

           ret = do_sys_open(AT_FDCWD, filename, flags, mode);

           /* avoid REGPARM breakage on x86: */

           asmlinkage_protect(3, ret, filename, flags, mode);

           return ret;

    }

    跟踪do_sys_open()函数,就会发现它主要使用了do_filp_open()函数该函数在fs/namei.c中,而在该文件中,filp_open函数也是调用了do_filp_open函数,并且接口和sys_open函数极为相似,调用参数也和sys_open一样,并且使用EXPORT_SYMBOL导出了,所以我们猜想该函数可以打开文件,功能和open一样。

    使用同样的方法,找出了一组在内核操作文件的函数,如下:

    功能

    函数原型

    打开文件

    struct file *filp_open(const char *filename, int flags, int mode)

    读文件

    ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)

    写文件

    ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)

    关闭文件

    int filp_close(struct file *filp, fl_owner_t id)

     

    2. 内核空间与用户空间

    vfs_read和vfs_write函数中,其参数buf指向的用户空间的内存地址,如果我们直接使用内核空间的指针,则会返回-EFALUT。这是因为使用的缓冲区超过了用户空间的地址范围。一般系统调用会要求你使用的缓冲区不能在内核区。这个可以用set_fs()、get_fs()来解决。

    include/asm/uaccess.h中,有如下定义:

    #define MAKE_MM_SEG(s) ((mm_segment_t) { (s) })

    #define KERNEL_DS MAKE_MM_SEG(0xFFFFFFFF)

    #define USER_DS MAKE_MM_SEG(PAGE_OFFSET)

    #define get_ds() (KERNEL_DS)

    #define get_fs() (current->addr_limit)

    #define set_fs(x) (current->addr_limit = (x))

     

    如果使用,如下:

    mm_segment_t fs = get_fs();

    set_fs(KERNEL_FS);

    //vfs_write();

    vfs_read();

    set_fs(fs);

     

    详尽解释:系统调用本来是提供给用户空间的程序访问的,所以,对传递给它的参数(比如上面的buf),它默认会认为来自用户空间,在read或write()函数中,为了保护内核空间,一般会用get_fs()得到的值来和USER_DS进行比较,从而防止用户空间程序“蓄意”破坏内核空间;而现在要在内核空间使用系统调用,此时传递给read或write()的参数地址就是内核空间的地址了,在USER_DS之上(USER_DS ~ KERNEL_DS),如果不做任何其它处理,在write()函数中,会认为该地址超过了USER_DS范围,所以会认为是用户空间的“蓄意破坏”,从而不允许进一步的执行;为了解决这个问题; set_fs(KERNEL_DS);将其能访问的空间限制扩大到KERNEL_DS,这样就可以在内核顺利使用系统调用了!

     

     

    3. 完整的例子

    #include <linux/kernel.h>

    #include <linux/module.h>

    #include <linux/init.h>

    #include <linux/fs.h>

    #include <linux/string.h>

    #include <linux/mm.h> oracle

    #include <linux/syscalls.h> ssh

    #include <asm/unistd.h> linux

    #include <asm/uaccess.h>

    #define MY_FILE "/root/tmp.txt"

    char buf[128];

    struct file *file = NULL;

     

    static int __init init(void)

    {

      mm_segment_t old_fs;

      printk("Hello, I'm the module that intends to write messages to file/n");

      if(file == NULL)

          file = filp_open(MY_FILE, O_RDWR | O_APPEND | O_CREAT, 0644);

      if (IS_ERR(file)) {

      printk("error occured while opening file %s./n", MY_FILE);

      return 0;

      }

      sprintf(buf,"%s", "The Messages.");

      old_fs = get_fs();

      set_fs(KERNEL_DS);

      file->f_op->write(file, (char *)buf, sizeof(buf), &file->f_pos);

      set_fs(old_fs);

      return 0;

     }

     static void __exit exit(void)

     {

      if(file != NULL)

      filp_close(file, NULL); oracle

     }

     module_init(init);

     module_exit(exit);

    MODULE_LICENSE("GPL");

     

    注意:

    1. 一个是要记得编译的时候加上-D__KERNEL_SYSCALLS__

     

     

    展开全文
  • windows内核读写文件

    千次阅读 2014-06-19 13:45:54
    /////////////////////////////////////////////////////////////////////////////// /// /// Copyright (c) 2014 - /// /// Original filename: FileOperation.cpp /// Project : FileOperation /// Date
  • //先根据文件描述符fd得到对应的file对象 ssize_t ret = -EBADF; if (f.file) { loff_t pos = file_pos_read(f.file); //得到文件的当前位置 ret = vfs_read(f.file, buf, count, &pos); //调用vfs_read...
  • 在Linux的应用平台上,很多时候我们需要用到从SD卡读数据来使用,比如升级触摸屏固件,比如载入调试文本等,都需要用到Linux的文件系统来操作。通过举一个实例来说明VFS FILE操作细节,即在ADB中通过echo 到DEVICE_...
  • windows内核驱动条件下文件的创建、读、写等功能实现源码。适用于驱动调试和运行观察的日志打印输出,比Windbg和reaceview更方便。
  • 内核文件读写

    千次阅读 2020-09-25 17:33:29
    内核文件读写 一般情况下,不建议在内核态进行文件操作。 EXPORT_SYMBOL(filp_open); EXPORT_SYMBOL(filp_close); EXPORT_SYMBOL(kernel_read); EXPORT_SYMBOL(kernel_write); 函数原型 说明 struct...
  • 内核驱动读写文件

    千次阅读 2013-07-18 09:17:46
    有时候需要在linux内核读写文件数据--大多 是在需要调试的驱动程序--中读写文件数据。在kernel中操作文件没有标准库可 用,需要利用kernel的一些函数,这些函数主 要有: filp_open() filp_close(), vfs_read() ...
  • 因为最近需要在内核读写文件,然后自己再打开文件看其中的内容(vi)。,这个不同于fread,fwrite那种上层的文件读写操作,故网上搜集大家的知识帖,汇总了一份适合自己的文件读写函数,在此晒出: 首先需要#...
  • Linux内核读写文件

    千次阅读 2016-07-11 14:13:56
    Linux内核读写文件数据的方法     有时候需要在Linuxkernel--大多是在需要调试的驱动程序--中读写文件数据。在kernel中操作文件没有标准库可用,需要利用kernel的一些函数,这些函数主要有: filp_open() ...
  • 内核读写应用层文件
  • 内核读写文件

    千次阅读 2012-04-12 14:35:38
    之前以为在内核中不能创建文件,其实不是这样子的,只要文件系统跑起来之后就可以像在用户空间一样操作文件. 用户空间 内核 open() sys_open(), filp_open() close() sys_close(), filp_close() read()
  • 内核文件系统看文件读写过程

    千次阅读 2018-03-02 19:07:20
    阅读目录系统调用虚拟文件系统I/O 缓冲区Page CacheAddress Space文件读写基本流程回到顶部系统调用操作系统的主要功能是为管理硬件资源和为应用程序开发人员提供良好的环境,但是计算机系统的各种硬件资源是有限的...
  • linux内核读写文件

    千次阅读 2012-02-29 19:54:24
    分类: Linux驱动2011-08-05 23:11 570人阅读 评论(0) 收藏 举报 ...之前以为在内核中不能创建文件,其实不是这样子的,只要文件系统跑起来之后就可以像在用户空间一样操作文件.   用户空间 内核
  • 但是,在内核态没有这样的系统调用,我们又该如何读写文件呢? 阅读linux内核源码,可以知道陷入内核执行的是实际执行的是sys_read和sys_write这两个函数,但是这两个函数没有使用EXPORT_SYMBOL导出,也就是说其他...
  • 内核读写文件

    千次阅读 2010-10-22 21:47:00
    在用户态,可以使用open,close,read,write等系统调用来访问文件。那么内核中呢?使用filp->open等函数进行操作,但是这些操作又有些需要注意的地方。
  • 内核文件读写流程

    2011-08-19 13:52:42
    在应用层读写文件等操作将通过 INT 2E 切换到内核层。这个不用说大家都很熟悉流程。那么到了内核层又是如何处理的?就先拿 ZwReadFile,ZwWriteFile 说事。首先将文件句柄转换成 FILE_OBJECT 指针。这时 I/OMGR ...
  • 在linux驱动中如何打开其他设备驱动提供的接口进行读写,此文档详细讲解,我看它才弄出来的。
  • OpenCL读取内核cl文件

    千次阅读 2017-06-11 13:17:19
    普遍上的OpenCL编程都分为两个部分,一个为主机端代码,一个为设备端代码。 主机端代码的作用是:主要是负责设置...通常就是读取cl文件。 因为在创建程序对象program时,需要用到这个cl文件。创建程序对象就会把这
  • linux内核读取文件

    2010-10-19 15:38:00
    做CTP芯片驱动时,供应商需要我在驱动层做一个升级他们FW的接口,现贴出linux内核驱动中读取文件的代码struct file *srcf; char *buffer; int orgfsuid, orgfsgid, retval; mm_segment_t orgfs; buffer = ...
  • 可以使用filp->open配合struct file里的read/write来进行对文件读写操作。 直接上干货(内容自己悟!): 例1 : filp->f_op->read filp_open filp->f_op->write #include <linux/kernel.h> #include ...
  • 在VFS的支持下,用户态进程读写任何类型的文件系统都可以使用read和write着两个系统调用,但是在linux内核中没有这样的系统调用我们如何操作文件呢?我们知道read和write在进入内核态之后,实际执行的是sys_read 和...
  • Linux内核读写文件数据的方法

    千次阅读 2017-11-06 17:14:41
    Linux内核读写文件数据的方法     有时候需要在Linuxkernel--大多是在需要调试的驱动程序--中读写文件数据。在kernel中操作文件没有标准库可用,需要利用kernel的一些函数,这些函数主要有: filp_open()...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 327,575
精华内容 131,030
关键字:

内核读取文件