精华内容
下载资源
问答
  • 内核操作文件的函数与用户空间不同,需要使用内核空间专用的一套函数,主要有filp_open()、filp_close()、vfs_read()、vsf_write()、set_fs()、get_fs()等,上述函数在头文件linux/fs和asm/uaccess.h中声明。...

    在内核中操作文件的函数与用户空间不同,需要使用内核空间专用的一套函数,主要有filp_open()、filp_close()、vfs_read()、vsf_write()、set_fs()、get_fs()等,上述函数在头文件linux/fs和asm/uaccess.h中声明。

     1.内核空间中的文件结构

    内核中对文件操作额文件结构struct file,是进行文件操作时经常使用的结构,结构的原型定义如下,其中的f_op是对文件进行操作的结构,f_pos为文件当前的指针为止:

                                      

    struct file_operations结构中定义的为一些内核文件操作的函数,结构的原型定义如下,例如其read()成员函数从文件中读取数据,write()成员函数向文件中写入数据。

                    

    2.内核空间的文件建立操作 

    内核中打开文件不能调用用户空间的库函数,而且内核空间和用户空间打开文件的函数不同,内核空间打开文件的函数为filp_open()(注意不是file_open()),其原型如下:

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

        

    filp_open用于打开路径filename下的文件,返回一个指向结构struct file的指针,后面的函数使用这个指针对文件进行操作,返回值需要使用IS_ERR()函数来检验其有效性。

    参数说明如下:

    • filename:要打开或者创建的文件名称,包含路劲部分。在内核中使用打开文件的函数容易出现打开文件时机不对的错误,例如当调用此函数时,文件驱动没有加载,或者打开的文件没有挂载到系统中。
    • open_mode:设置文件的打开方式,这个值与用户空间的open对应的参数类似,可以取值O_CREAT、O_RDWR、O_RDONLY等值。
    • mode:这个参数只有在创建文件的时候使用,用于设置创建文件的读写权限,不创建文件的其他情况可以忽略,设为0。 
    #define DBGPRINT printk
    
    //内核程序使用file_open来打开文件
    struct file *SIPFW_OpenFile(const char *filename, int flags, int mode)
    {
    	struct file *f = NULL;
    
    	DBGPRINT("==>SIPFW_OpenFile\n");
    
    /*  */
    
    	f = filp_open(filename, flags, 0);
    	if (!f || IS_ERR(f))
    	{
    		f = NULL;
    	}
    
    	DBGPRINT("<==SIPFW_OpenFile\n");
    	return f;
    }

     3.内核空间文件读写操作

    Linux内核中对文件进行读写操作的函数为vfs_read()函数和vfs_write()函数,这两个函数的原型如下。函数的基本含义与用户空间是基本一致的。

    //读文件
    ssize_t vfs_read(struct file *filp, char __user *buffer, size_t len, loff_t *pos);
    //写文件
    ssize_t vfs_write(struct file *filp, const char __user *buffer, size_t len, loff_t *pos);

    这两个函数的参数含义如下所述。

    • filp:文件指针,由filp_open()函数返回。
    • buffer:缓冲区,从文件中读出的数据放到这个缓冲区,向文件中写入数据也在这个缓冲区。
    • len:从文件中读出或者写入文件的数据长度。
    • pos:为文件指针的位置,即从什么地方开始对文件数据进行操作。

    注意:vfs_read()和vfs_write()这两个函数的第二个参数,在buffer前面都有一个__user修饰符,这要求buffer指针应该指向用户的空间地址。如果在内核中使用上述的两个函数直接进行文件操作,将内核空间的指针传入的时候,函数会返回失败EFAULT。但在Linux内核中,一般不容易生成用户空间的指针,或者不方便独立使用用户空间内存。为了使这两个函数能够正常工作,必须使得这两个函数能够处理内核空间的地址。

    使用set_fs()函数可以指定上述两个函数对缓冲区地址的处理方式,原型如下:

    void set_fs(mm_segment_t fs);

    这个函数改变内核对内存检查的处理方式,将内存地址的检查方式设置为用户指定的方式。参数fs取的值有两个:USER_DS和KERNEL_DS。分别代表用户空间和内核空间。

    在默认情况下,内核对地址的检查方式为USER_DS,即按照用户空间进行地址检查并进行用户地址空间到内核地址空间的变换。如果函数中要使用内核地址空间,需要使用set_fs(KERNEL_DS)函数进行设置。与set_fs()函数对应,get_fs()函数获得当前的设置,在使用set_fs()之前先调用get_fs()函数获得之前的设置,对文件进行操作后,使用set_fs()函数还原之前的设置。

    内核空间文件续写的框架为:

    mm_segmen_t old_fs;
    old_fs = get_fs();
    set_fs(KERNEL_DS);
    ...
    set_fs(old_fs)

    注意:使用vfs_read()和vfs_write()的时候,要注意最后的参数loff_t *pos,pos所指向的值必须要进行初始化,表明从文件的什么为止进行读写。使用此参数可以对续写文件的位置进行设定,这可以完成用户空间中lseek()函数的功能。

    下面是一个使用内核空间的文件读函数从文件中读取数据的例子:

    ssize_t ReadFile(struct file *filp, char __user *buffer, size_t len, loff_t *pos)
    {
        ssize_t count = 0;
        oldfs = get_fs();
    
        set_fs(KERNEL_DS);
    
        count = file->f_op->read(filp, buf, len, &file->f_pos);
    
        set_fs(oldfs);
    
        return count;
    }

    这里我想废一些话,因为是在下面的实例程序中遇到的问题:

    查阅的文章连接:(http://blog.chinaunix.net/uid-15141543-id-2775960.html

                       

    上面的代码实现很简单,在做了一些条件判断以后 ,如果该文件索引节点inode定义了文件的读实现方法的话,就调用此方法. Linux下特殊文件读往往是用此方法, 一些伪文件系统如:proc,sysfs等,读写文件也是用此方法 . 而如果没有定义此方法就会调用通用文件模型的读写方法(在下面的示例中就是碰到了没有定义此方法的情况,也就是说f->f_op->read == NULL, 所以最后直接调用了vfs_read方法进行了文件的读取操作).它最终就是读内存,或者需要从存储介质中去读数据. 

    4.内核空间的文件关闭操作

    内核中的文件如果不在使用,需要将文件进行关闭,释放其中的资源。Linux内核中关闭文件的函数为filp_close(),其原型如下:

    int filp_close(struct file *filp, fl_owner_t id);

    函数用于关闭之前打开的文件,函数的第一个参数为filp_open()返回的指针,第二个参数是POSIX线程ID。Linux内核中使用文件指针可以传入NULL,或者使用current->files传入当前模块额文件指针。

    void CloseFile(void)
    {
        if (myfile)
            filp_close(myfiles, current->files);
    }

    5.实例

    文件:

    源码:

    main_file.c

    //kernel
    #include <linux/module.h>
    #include <linux/kernel.h>
    #include <linux/init.h>
    #include <linux/types.h>
    #include <linux/netdevice.h>
    #include <linux/skbuff.h>
    #include <linux/netfilter_ipv4.h>
    #include <linux/inet.h>
    #include <linux/in.h>
    #include <linux/ip.h>
    #include <linux/netlink.h>
    #include <linux/spinlock.h>
    #include <net/sock.h>
    #include <linux/tcp.h>
    #include <linux/udp.h>
    #include <linux/icmp.h>
    #include <linux/igmp.h>
    #include <linux/ctype.h>
    #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>
    //user
    
    
    
    #define DBGPRINT printk
    
    //内核程序使用file_open来打开文件
    struct file *SIPFW_OpenFile(const char *filename, int flags, int mode)
    {
    	struct file *f = NULL;
    
    	DBGPRINT("==>SIPFW_OpenFile\n");
    
    	f = filp_open(filename, flags, 0);
    	if (!f || IS_ERR(f))
    	{
    		f = NULL;
    	}
    
    	DBGPRINT("<==SIPFW_OpenFile\n");
    	return f;
    }
    
    ssize_t SIPFW_ReadLine(struct file *f, char *buf, size_t len)
    {
    #define EOF (-1)
    
    	ssize_t count = -1;
    	mm_segment_t oldfs;
    	struct inode *inode;
    
    	//DBGPRINT("==>SIPFW_ReadLine\n");
    
    	if (!f || IS_ERR(f) || !buf || len <= 0) 
    	{
    		goto out_error;
    	}
    
    	if (!f || !f->f_inode)
    	{
    		goto out_error;
    	}
    
    	inode = f->f_inode;
    
    	if (!(f->f_mode & FMODE_READ))
    	{
    		goto out_error;
    	}
    
    	if (f->f_op /*&& f->f_op->read*/) 
    	{
    		oldfs = get_fs();
    		set_fs(KERNEL_DS);
    		count = 0;
    
    		if (vfs_read(f, buf, 1, &f->f_pos) <= 0)
    		{
    			DBGPRINT("file read failure\n");
    			goto out;
    		}
    
    		if (*buf == EOF)
    		{
    			DBGPRINT("file EOF\n");
    			goto out;
    		}
    
    		count = 1;
    		while (*buf != EOF && *buf != '\0' && *buf != '\n' && *buf != '\r' 
    				&& count < len  && f->f_pos <= inode->i_size)
    		{
    			buf 	+= 1;
    			count 	+= 1;
    
    			if (vfs_read(f, buf, 1, &f->f_pos) <= 0) 
    			{
    				count -= 1;
    				break;
    			}
    		}
    	} 
    	else
    	{
    		DBGPRINT("goto out_error\n");
    		goto out_error;
    	}
    
    	if (*buf == '\r'|| *buf =='\n' ||*buf == EOF ) 
    	{
    		*buf = '\0';
    		count -= 1;
    	} 
    	else
    	{
    		buf += 1;
    		*buf = '\0';
    	}
    	
    out:
    	set_fs(oldfs);
    out_error:
    	//DBGPRINT("<==SIPFW_ReadLine %d\n", count);
    	return count;
    }
    
    // ssize_t SIPFW_WriteLine(struct file *f, char *buf, size_t len)
    // {
    // 	ssize_t count = -1;
    // 	mm_segment_t oldfs;
    // 	struct inode *inode;
    // 	DBGPRINT("==>SIPFW_WriteLine\n");
    
    // 	if (!f || IS_ERR(f) || !buf || len <= 0) 
    // 	{
    // 		goto out_error;
    // 	}
    
    // 	if (!f || !f->f_dentry || !f->f_dentry->d_inode)
    // 	{
    // 		goto out_error;
    // 	}
    
    // 	inode = f->f_dentry->d_inode;
    
    // 	if (!(f->f_mode & FMODE_WRITE) || !(f->f_mode & FMODE_READ) )
    // 	{
    // 		goto out_error;
    // 	}
    
    // 	if (f->f_op && f->f_op->read && f->f_op->write) 
    // 	{
    // 		//f->f_pos = f->f_count;
    // 		oldfs = get_fs();
    // 		set_fs(KERNEL_DS);
    // 		count = 0;
    
    // 		count = f->f_op->write(f, buf, len, &f->f_pos) ;
    
    // 		if (count == -1)
    // 		{
    // 			goto out;
    // 		}		
    // 	} 
    // 	else	
    // 	{
    // 		goto out_error;
    // 	}
    
    // out:
    // 	set_fs(oldfs);
    // out_error:
    // 	DBGPRINT("<==SIPFW_WriteLine\n");
    // 	return count;
    // }
    
    void SIPFW_CloseFile(struct file *f)
    {
    	DBGPRINT("==>SIPFW_CloseFile\n");
    	if(!f)
    		return;
    	
    	filp_close(f, current->files);
    	DBGPRINT("<==SIPFW_CloseFile\n");
    }
    
    int SIPFW_HandleConf(void)
    {
    	int retval = 0,count;
    	int l = 0;
    	char *pos = NULL;
    	struct file *f = NULL;
    	char line[256] = { 0 };
    	DBGPRINT("==>SIPFW_HandleConf\n");
    
    	//	提前建一个/etc/sipfw.conf文件吧
    	f = SIPFW_OpenFile("/etc/sipfw.conf", O_RDWR, 0);
    	if(f == NULL)
    	{
    		retval = -1;
    		DBGPRINT("SIPFW_OpenFile called failure\n");
    		goto EXITSIPFW_HandleConf;
    	}
    
    	while((count = SIPFW_ReadLine(f, line, 256)) > 0)
    	{
    		pos = line;
    		
    		DBGPRINT("line = %d, data: %s\n", l, line);\
    		l++;
    
    		memset(line, 0, sizeof(line));
    	}
    
    	SIPFW_CloseFile(f);	
    
    EXITSIPFW_HandleConf:
    	DBGPRINT("<==SIPFW_HandleConf\n");
    
    	return retval;
    }
    
    
    static int __init SIPFW_Init(void)
    {
    	int ret = -1;
    	DBGPRINT("==>SIPFW_Init\n");
    	
    	ret = SIPFW_HandleConf();
    	
    	DBGPRINT("<==SIPFW_Init\n");
    
    	return ret;
    }
    
    static void __exit SIPFW_Exit(void)
    {
    	DBGPRINT("==>SIPFW_Exit\n");
    
    	DBGPRINT("<==SIPFW_Exit\n");
    }
    
    module_init(SIPFW_Init);
    module_exit(SIPFW_Exit);
    MODULE_LICENSE("GPL/BSD");
    

     Makefile:

    MODULE_NAME :=main_file
    obj-m :=$(MODULE_NAME).o
    
    KERNELDIR = /lib/modules/$(shell uname -r)/build
    PWD := $(shell pwd)
    
    all:
    	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
    
    clean:
    	$(MAKE) -C $(KERNELDIR) M=$(PWD) clean

    测试中读取的文件:(/etc/sipfw.conf)

    运行:

    注:此项目运行环境:

     

    ok!希望有帮助!

    展开全文
  • Linux 内核文件操作

    千次阅读 2012-08-15 08:58:25
    在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);

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

    #include 
    #include
    #include
    #include
    static char buf[] = "你好";
    static char buf1[10];
     
    int __init hello_init(void)
    {
        struct file *fp;
        mm_segment_t fs;
        loff_t pos;
        printk("hello enter\n");
        fp = filp_open("/home/niutao/kernel_file", O_RDWR | O_CREAT, 0644);
        if (IS_ERR(fp)) {
            printk("create file error\n");
            return -1;
        }
        fs = get_fs();
        set_fs(KERNEL_DS);
        pos = 0;
        vfs_write(fp, buf, sizeof(buf), &pos);
        pos = 0;
        vfs_read(fp, buf1, sizeof(buf), &pos);
        printk("read: %s\n", buf1);
        filp_close(fp, NULL);
        set_fs(fs);
        return 0;
    }
    void __exit hello_exit(void)
    {
        printk("hello exit\n");
    }
     
    module_init(hello_init);
    module_exit(hello_exit);
     
    MODULE_LICENSE("GPL");

    以上内容转自:http://www.ej38.com/showinfo/linux-192439.html


    另外有个问题,想要在内核态获取文件属性(目录文件、普通文件、uid、gid), 该用什么方法呢? 

    用户态的方法是使用 stat 系统调用,但是内核态这个系统调用是没有导出的,所以不能使用。

    不知道 sys_stat 和 vfs_stat 可以实现不,正在努力尝试中 ........



    收藏

    http://www.iteedu.com//os/linux/linuxprgm/linuxcfunctions/index.php


    展开全文
  • Linux内核与根文件系统的关系 开篇题外话:对于Linux初学者来说,这是一个很纠结的问题,但这也是一个很关键的问题!一语破天机: “尽管内核是 Linux 的核心,但文件却是用户与操作系统交互所采用的主要工具。这对 ...

    Linux内核与根文件系统的关系 开篇题外话:对于Linux初学者来说,这是一个很纠结的问题,但这也是一个很关键的问题!

    一语破天机: “尽管内核是 Linux 的核心,但文件却是用户与操作系统交互所采用的主要工具。这对 Linux 来说尤其如此,这是因为在 UNIX 传统中,它使用文件 I/O 机制管理硬件设备和数据文件。”

    一.什么是文件系统

    文件系统指文件存在的物理空间,linux系统中每个分区都是一个文件系统,都有自己的目录层次结构。

    Linux文件系统中的文件是数据的集合,文件系统不仅包含着文件中的数据而且还有文件系统的结构,所有Linux 用户和程序看到的文件、目录、软连接及文件保护信息等都存储在其中。这种机制有利于用户和操作系统的交互。

    每个实际文件系统从操作系统和系统服务中分离出来,它们之间通过一个接口层:虚拟文件系统或VFS来通讯。VFS使得Linux可以支持多个不同的文件系统,每个表示一个VFS 的通用接口。由于软件将Linux 文件系统的所有细节进行了转换,所以Linux核心的其它部分及系统中运行的程序将看到统一的文件系统。Linux 的虚拟文件系统允许用户同时能透明地安装许多不同的文件系统。

    在Linux文件系统中,EXT2文件系统、虚拟文件系统、/proc文件系统是三个具有代表性的文件系统。

    二.什么是根文件系统

    根文件系统首先是一种文件系统,该文件系统不仅具有普通文件系统的存储数据文件的功能,但是相对于普通的文件系统,它的特殊之处在于,它是内核启动时所挂载(mount)的第一个文件系统,内核代码的映像文件保存在根文件系统中,系统引导启动程序会在根文件系统挂载之后从中把一些初始化脚本(如rcS,inittab)和服务加载到内存中去运行。我们要明白文件系统和内核是完全独立的两个部分。在嵌入式中移植的内核下载到开发板上,是没有办法真正的启动Linux操作系统的,会出现无法加载文件系统的错误。

    那么根文件系统在系统启动中到底是什么时候挂载的呢?先将/dev/ram0挂载,而后执行/linuxrc.等其执行完后。切换根目录,再挂载具体的根文件系统.根文件系统执行完之后,也就是到了Start_kernel()函数的最后,执行init的进程,也就第一个用户进程。对系统进行各种初始化的操作。

    根文件系统之所以在前面加一个”根“,说明它是加载其它文件系统的”根“,既然是根的话,那么如果没有这个根,其它的文件系统也就没有办法进行加载的。它包含系统引导和使其他文件系统得以挂载(mount)所必要的文件。根文件系统包括Linux启动时所必须的目录和关键性的文件,例如Linux启动时都需要有init目录下的相关文件,在 Linux挂载分区时Linux一定会找/etc/fstab这个挂载文件等,根文件系统中还包括了许多的应用程序bin目录等,任何包括这些Linux 系统启动所必须的文件都可以成为根文件系统。Linux启动时,第一个必须挂载的是根文件系统;若系统不能从指定设备上挂载根文件系统,则系统会出错而退出启动。成功之后可以自动或手动挂载其他的文件系统。因此,一个系统中可以同时存在不同的文件系统。在 Linux 中将一个文件系统与一个存储设备关联起来的过程称为挂载(mount)。使用 mount 命令将一个文件系统附着到当前文件系统层次结构中(根)。在执行挂装时,要提供文件系统类型、文件系统和一个挂装点。根文件系统被挂载到根目录下“/”上后,在根目录下就有根文件系统的各个目录,文件:/bin /sbin /mnt等,再将其他分区挂接到/mnt目录上,/mnt目录下就有这个分区的各个目录,文件。

    三.什么是内核

    Linux内核就像人的心脏,灵魂,指挥中心。内核是一个操作系统的核心,它负责管理系统的进程,内存,设备驱动程序,文件和网络系统,决定着系统的性能和稳定性。内核以独占的方式执行最底层任务,保证系统正常运行。协调多个并发进程,管理进程使用的内存,使它们相互之间不产生冲突,满足进程访问磁盘的请求等.

    操作系统是一个用来和硬件打交道并为用户程序提供一个有限服务集的低级支撑软件。一个计算机系统是一个硬件和软件的共生体,它们互相依赖,不可分割。计算机的硬件,含有外围设备、处理器、内存、硬盘和其他的电子设备组成计算机的发动机。但是没有软件来操作和控制它,自身是不能工作的。完成这个控制工作的软件就称为操作系统,在Linux的术语中被称为“内核”,也可以称为“核心”。Linux内核的主要模块(或组件)分以下几个部分:存储管理、CPU和进程管理、文件系统、设备管理和驱动、网络通信,以及系统的初始化(引导)、系统调用等。

    四.内核与文件系统的关系

    技术上说Linux是一个内核。“内核”指的是一个提供硬件抽象层、磁盘及文件系统控制、多任务等功能的系统软件。一个内核不是一套完整的操作系统。一套基于Linux内核的完整操作系统叫作Linux操作系统,或是GNU/Linux。

    文件系统是kernel的一部分。文件系统实现了系统上存储介质和其他资源的交互。kernel tree中的fs目录都是关于文件系统的,可以说它是kernel的一个大子系统。

    嵌入式系统在flash中分配了存放内核、根文件系统的区域。bootloader加载了内核,内核启动,加载文件系统,进入Linux系统。

    整个嵌入式系统而言,可以分为三个部分1.uboot 2.kernel 3.文件系统。其中kernel中以VFS去支持各种文件系统,如yaffs,ext3,cramfs等等。yaffs/yaffs2是专为嵌入式系统使用NAND型闪存而设计的一种日志型文件系统。在内核中以VFS来屏蔽各种文件系统的接口不同,以VFS向kernel提供一个统一的接口。如打开一个文件时统一使用open,写时采用write,而不用去考虑是那种文件系统,也不用去考虑文件系统是如何将数据写入物理介质的。其中 kernel中的配置,只是让VFS支持这种接口。

    展开全文
  • Linux 内核文件操作

    2016-01-25 14:13:25
    正常思路是应用里读取文件内容,再通过ioctl、write等方式把文件buffer传送到内核内核里不推荐使用对文件IO直接操作,但是要使用还是可以的。

    正常思路是应用里读取文件内容,再通过ioctl、write等方式把文件buffer传送到内核,内核里不推荐使用对文件IO直接操作,但是要使用还是可以的。

    思路如下:

    一、filp_open打开获取句柄,判断指针

    二、切换到内核态

    三、读取/写入

    四、关闭,切换到原来状态

    filp_open打开错误返回的并不是NULL,要使用IS_ERR()判断指针是否错误。

    测试的时候我用echo update.bin>/dev/xx-device,一直返回错误。单从指针是判断不出错误码。需要从PTR_ERR()获取错误码,读到错误码一直为-2,对照linux错误表里解释为No such file or directiory,仔细看log,原来是echo 自动会内容最后加回车,所以没找到文件。


    以下附带个例子,希望对大家调试有帮助。

    static char* filp_sample(const char *path, int *len)
    {
    	mm_segment_t old;
    	struct file * fp = NULL;
    	char  *save;
    	int size;
    	struct kstat stat;
    	loff_t pos=0;
    	
    	fp = filp_open(real_path, O_RDONLY , 0);
    	if (IS_ERR(fp))
    	{
    		printk("open %s failed,errno:%d\n", path, (int)PTR_ERR(fp));
    		goto fail;
    	}
    	old = get_fs();
    	set_fs(KERNEL_DS);
    	
    	vfs_getattr(&fp->f_path, &stat);
    	size = stat.size;
    	*len = size;
    	save = kzalloc(size, GFP_KERNEL);
    	if (!save)
    	{
    		goto fail;
    	}
    
    	vfs_read(fp, save, size, &pos);
    	filp_close(fp, NULL);
    	set_fs(old);
    	return save;
    
    
    fail:
    	set_fs(old);
    	if (!IS_ERR(fp))
    		filp_close(fp, NULL);
    	return NULL;
    }




    展开全文
  • linux内核文件操作demo

    千次阅读 2018-04-15 10:00:43
    有时候调试过程中需要在内核里面对文件进行操作,但是应用层的系统调用都不可用,像open,read,write或者标准库的fopen,fread,fwrite函数,在linux内核其实可以用如下方式进行文件读写操作。下面是一个例子,我...
  • Linux内核文件操作函数整理

    千次阅读 2016-07-28 13:56:26
    1.判断文件是否存在 struct file *filp = NULL; filp = filp_open("/etc/passwd", O_RDONLY, 0); if (IS_ERR(filp)) { printk("Cannot open .........在Linux内核中,已知一个进程的pid和其打开文件文件描述符fd,
  • linux 内核模块文件操作

    千次阅读 2011-10-11 09:43:08
    这里介绍内核模块中对文件的读取,这个模块实现的方式是在每次插入模块的时候实现一次对文件的读和对另外一个文件的写,其他的方式读者可以自己实现,基本的流程和框架在本例子中已经体现: kernel_file.c ? ...
  • 1.filp_open()在kernel中可以打开文件,其原形如下: ...该函数返回strcut file*结构指针,供后继函数操作使用,该返回值用IS_ERR()来检验其有效性。 2. 读写文件(vfs_read/vfs_write)  kernel...
  • linux内核编程-内核态文件操作

    千次阅读 2018-04-01 21:39:30
    一、文件打开函数struct file *filp_open(const char *filename, int flags, umode_t mode)定义在:fs/open.c头文件:&lt;linux/fs.h&gt;详解:1.在用户态open函数是个变参函数,umode_t mode参数只有在O_...
  • 因为最近需要在内核中读写文件,然后自己再打开文件看其中的内容(vi)。,这个不同于fread,fwrite那种上层的文件读写操作,故网上搜集大家的知识帖,汇总了一份适合自己的文件读写函数,在此晒出: 首先需要#...
  • 鉴于此,《Linux内核精髓:精通Linux内核必会的75个绝技》选取了资源管理(CPU、内存、进程等)、文件系统、网络、虚拟化、省电、调试、概要分析、追踪、内核调整等Linux内核的核心主题进行了深入剖析和讲解,总结出...
  • LINUX内核目录文件说明

    万次阅读 2018-08-03 09:40:31
    内核空间和用户空间  在下载内核前,我们应该讨论一些重要的术语和事实。首先了解一下内核空间和用户空间 ... Linux内核是一个宏内核,这意味着整个操作系统都运行在内核预留的内存里。 内...
  • linux内核读写文件

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

    千次阅读 2016-04-26 10:31:18
    linux内核initrd文件自定义方法重新编译内核后,可能加入了自定义的模块,就有可能需要修改init文件,而init文件就在initrd中,这里记录下操作步骤,以防遗忘。1. cp /boot/initrd-3.2.img /tmp/mylinux/initrd-3.2...
  • Linux系统支持在不同进程间共享打开文件内核为所有的I/O创建了3种数据结构表示打开文件,它们之间的关系决定了在文件共享方面一个进程对另一个进程可能产生的影响。 每个进程在进程表中都有一个记录项,记录项中...
  • Linux内核文件系统

    千次阅读 2019-04-19 14:32:08
    Linux 内核文件系统 概述 文件系统这一词在不同上下文时有不同的含义: 指一种具体的文件格式。例如Linux文件系统是Ext2,MSDOS的文件系统是FAT16,而Windows NT的文件系统是NTFS或FAT32 指按特定格式进行了...
  • Linux内核态的文件操作

    千次阅读 2016-05-15 01:19:53
    在kernel中操作文件没有标准库可用,需要利用kernel的一些函数,这些函数主 要有: filp_open() filp_close(), vfs_read() vfs_write(),set_fs(),get_fs()等,这些函数在linux/fs.h和asm/uaccess.h头文件中声明。...
  • 介绍一下 Linux 内核文件 Cache 管理的机制。本文以 2.6 系列内核为基准,主要讲述工作原理、数据结构和算法。 2 操作系统和文件 Cache 管理 对于存储设备上的数据,操作系统向应用程序提供的逻辑概念就是"文件...
  • Linux 内核文件 Cache 管理机制介绍 文件 Cache 管理是 Linux 内核中一个很重要并且较难理解的组成部分。本文详细介绍了 Linux 内核文件 Cache 管理的各个方面,希望能够对开发者理解相关代码有所帮助。 ...
  • LINUX内核文件系统

    2009-05-26 22:58:00
    最近一直在思考LINUX内核文件系统之间的关系,下午在公交车上略微明白了些,恍然大悟。按我的理解,其实文件系统按照存在的位置可以分为两种:一种是位于内存的文件系统,另外一种位于硬盘等存储设备上。我指的是...
  • LINUX内核目录文件说明以及配置并编译内核的方法

    万次阅读 多人点赞 2017-06-09 10:28:26
    Linux内核是一个宏内核,这意味着整个操作系统都运行在内核预留的内存里。说的更清楚一些,内核是放在内存里的。内核所使用的空间是内核预留的。只有内核可以使用预留的内核空间。内核拥有这些内存空间,直到系统...
  • Linux内核proc文件系统实验

    热门讨论 2010-04-02 12:24:06
    Linux操作系统内核实验--proc文件系统实验: 问题A: 提取 1、cpu类型 2、内核版本 问题B: 1、启动以来经历的时间,以dd:hh:mm:ss报告 问题C: 1、cpu执行用户态、系统态、空闲态所用时间 2、多少次磁盘请求 3、多少...
  • Linux内核态下的文件操作

    千次阅读 2013-08-05 09:39:01
    在VFS的支持下,用户态进程读写任何类型的文件系统都可以使用read和write着两个系统调用,但是在linux内核中没有这样的系统调用我们如何操作文件呢?我们知道read和write在进入内核态之后,实际执行的是sys_read和...
  • Linux内核中进行文件的读写操作,在一般情况下 不推荐这样操作,但在不得已时,也是可以实现的. #includelinux/kernel.h> #include linux/module.h> #include linux/init.h> #include linux/fs.h> #...
  • #include linux/kernel.h> #include linux/module.h> #include linux/init.h> #include linux/fs.h> #include linux/string.h> #include linux/mm.h> #include linux/syscalls.h> #include
  • 实现Linux内核文件系统,首先Linux文件管理从用户的层面介绍了Linux管理文件的方式。Linux有一个树状结构来组织文件。树的顶端为根目录(/),节点为目录,而末端的叶子为包含数据的文件。当我们给出一个文件的完整...
  • Linux内核文件Cache

    2009-12-05 13:29:00
    文件 Cache 管理在 Linux 操作系统中的地位和作用2. Linux文件 Cache相关的数据结构3. Linux 中如何实现文件 Cache 的预读和替换4. Linux文件 Cache 相关 API 及其实现 参考地址: 1. ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,289
精华内容 5,315
关键字:

linux内核操作文件

linux 订阅