详解Linux调用驱动open函数过程

最新推荐文章于 2024-08-01 23:19:08 发布
最新推荐文章于 2024-08-01 23:19:08 发布
阅读量6.1k 收藏 19
点赞数 2
分类专栏： Linux 文章标签： VFS文件系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/owhfg/article/details/86639048
版权

先叙述一下大概流程,再补充流程细节，本博客主要以VFS文件系统为核心来介绍,对于实际文件系统ext2或sysfs文件系统，超出本博客范围

*Linux 打开一个文件,需要两个步骤

  • (1) 找到文件
  • (2) 打开文件

C库调用open函数的系统入口时sys_open函数.

asmlinkage long sys_open(const char __user *filename, int flags, int mode)
{
	long ret;

	// 判断是否为32位系统
	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;
}

long do_sys_open(int dfd, const char __user *filename, int flags, int mode)
{
	// 将文件路径及名字复制到内核空间
	char *tmp = getname(filename);
	int fd = PTR_ERR(tmp);

	if (!IS_ERR(tmp)) {
		//从位图里获得一个未使用的文件描述符,如果位图已满就扩充位图
		fd = get_unused_fd_flags(flags);
		if (fd >= 0) {
			//实际打开函数
			struct file *f = do_filp_open(dfd, tmp, flags, mode);
			if (IS_ERR(f)) {
				put_unused_fd(fd);
				fd = PTR_ERR(f);
			} else {
				fsnotify_open(f->f_path.dentry);
				fd_install(fd, f);
			}
		}
		putname(tmp);
	}
	return fd;
}

struct file *do_filp_open(int dfd, const char *pathname,
		int open_flag, int mode)
{
	……
	/*
	 * The simplest case - just a plain lookup.
	 */
	if (!(flag & O_CREAT)) {
		// 此函数实现的是找到文件
		error = path_lookup_open(dfd, pathname, lookup_flags(flag),
					 &nd, flag);
		if (error)
			return ERR_PTR(error);
		goto ok;
	}

	……
ok:
		// 此函数实现的是打开文件
	filp = nameidata_to_filp(&nd, open_flag);
	……
}

// 寻找文件的过程如下

 path_lookup_open
    	->__path_lookup_intent_open
    		->do_path_lookup
    			->path_walk
    				->link_path_walk
    					->__link_path_walk
    						->do_lookup
    							->real_lookup
    								->result = dir->i_op->lookup(dir, dentry, nd);	//底层文件系统相关的lookup函数

static struct dentry *ext2_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
{
	……
	if (ino) {
		inode = ext2_iget(dir->i_sb, ino);
		if (IS_ERR(inode))
			return ERR_CAST(inode);
	}
	……
}

			

struct inode *ext2_iget (struct super_block *sb, unsigned long ino)
{
	……
	if (S_ISREG(inode->i_mode)) {
		……
	} else if (S_ISDIR(inode->i_mode)) {
		……
	} else if (S_ISLNK(inode->i_mode)) {
		……
	} else {
		……
		if (raw_inode->i_block[0])
			init_special_inode(inode, inode->i_mode,
			   old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
		else 
			init_special_inode(inode, inode->i_mode,
			   new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
	}
	……
}

	

void init_special_inode(struct inode *inode, umode_t mode, dev_t rdev)
{
	inode->i_mode = mode;
	if (S_ISCHR(mode)) {
		inode->i_fop = &def_chr_fops;
		inode->i_rdev = rdev;
	} else if (S_ISBLK(mode)) {
		inode->i_fop = &def_blk_fops;
		inode->i_rdev = rdev;
	} else if (S_ISFIFO(mode))
		inode->i_fop = &def_fifo_fops;
	else if (S_ISSOCK(mode))
		inode->i_fop = &bad_sock_fops;
	else
		printk(KERN_DEBUG "init_special_inode: bogus i_mode (%o)\n",
		       mode);
}
  • 找到def_chr_fops结构,path_lookup_open函数也就得到设备文件对应文件系统的默认open函数.
    const struct file_operations def_chr_fops = {
    .open = chrdev_open,
    };

再看do_filp_open函数调用的另一个函数nameidata_to_filp

nameidata_to_filp
	->__dentry_open

static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt,
				int flags, struct file *f,
				int (*open)(struct inode *, struct file *))
{
	……
	f->f_op = fops_get(inode->i_fop);
	……
	if (!open && f->f_op)
		open = f->f_op->open;
	if (open) {
		error = open(inode, f);		// 此处调用底层文件系统默认open函数,即上述过程找到的open函数
		if (error)
			goto cleanup_all;
	}
	……
	
}

static int chrdev_open(struct inode *inode, struct file *filp)
{
	……
	// 在cdev_map设备库中按照主次设备号查找kobject结构
	kobj = kobj_lookup(cdev_map, inode->i_rdev, &idx);
	// 根据kobject实例得到对应的cdev结构地址
	// cdev结构包含驱动程序里定义的file_operation结构
	new = container_of(kobj, struct cdev, kobj);
	……
	if (filp->f_op->open) {
		lock_kernel();
		// 此处调用驱动程序定义的open函数
		ret = filp->f_op->open(inode,filp);
		unlock_kernel();
	}
	……
}

下面详细分析查找过程

以C函数open("/home/book/test.txt") Linux2.6.26源码为例

// nd是do_filp_open()函数声明的一个结构体实例

static int __path_lookup_intent_open(int dfd, const char *name,
		unsigned int lookup_flags, struct nameidata *nd,
		int open_flags, int create_mode)
{
	// 通过slab分配器,从filp_cachep缓存链表分配一个file结构,关于slab分配器,不属于本博客范围
	struct file *filp = get_empty_filp();
	int err;

	if (filp == NULL)
		return -ENFILE;
	nd->intent.open.file = filp;
	nd->intent.open.flags = open_flags;
	nd->intent.open.create_mode = create_mode;
	err = do_path_lookup(dfd, name, lookup_flags|LOOKUP_OPEN, nd);
	……
	return err;
}

static int do_path_lookup(int dfd, const char *name,
				unsigned int flags, struct nameidata *nd)
{
	int retval = 0;
	int fput_needed;
	struct file *file;
	struct fs_struct *fs = current->fs;

	nd->last_type = LAST_ROOT; /* if there are only slashes... */
	nd->flags = flags;
	nd->depth = 0;

	//例子/home/book/test会进入这个if分支.其他分支也类似,只是为了找到初始目录
	if (*name=='/') {
		read_lock(&fs->lock);
		if (fs->altroot.dentry && !(nd->flags & LOOKUP_NOALT)) {
			nd->path = fs->altroot;
			path_get(&fs->altroot);
			read_unlock(&fs->lock);
			if (__emul_lookup_dentry(name,nd))
				goto out; /* found in altroot */
			read_lock(&fs->lock);
		}
		nd->path = fs->root;	//设置路径为进程所在文件系统的挂载点,此处设置为'/',关于文件系统不属于本博客范围
		path_get(&fs->root);
		read_unlock(&fs->lock);
	} else if (dfd == AT_FDCWD) {
		……
	} else {
		……
	}

	retval = path_walk(name, nd);
	……
	return retval;


}

static int __link_path_walk(const char *name, struct nameidata *nd)
{
	struct path next;
	struct inode *inode;
	int err;
	unsigned int lookup_flags = nd->flags;

// 将路径里的前n个'/'去掉,也就是说open("//home/book/test.c", O_RDONLY)的语句内核也能正确解析
// 此时name指向"home/book/test.c"字符串
while (*name=='/')
	name++;
if (!*name)
	goto return_reval;

// 此处初始值为根目录'/'的inode实例
inode = nd->path.dentry->d_inode;
if (nd->depth)
	lookup_flags = LOOKUP_FOLLOW | (nd->flags & LOOKUP_CONTINUE);

/* At this point we know we have a real path component. */
for(;;) {
	unsigned long hash;
	struct qstr this;
	unsigned int c;

	nd->flags |= LOOKUP_CONTINUE;
	//这两句是验证进程权限,我也不是很清楚具体实现方式
	err = exec_permission_lite(inode, nd);
	if (err == -EAGAIN)
		err = vfs_permission(nd, MAY_EXEC);
	if (err)
		break;

	// this结构指向name所在的字符串,这个this和c++的this不一样.
	this.name = name;
	c = *(const unsigned char *)name;	//取name的第一个字符赋值给c.

	hash = init_name_hash();	//hash值初始化为0.
	//这个while循环是查找到下一个'/'字符所在位置,或查找到字符串尾的位置.
	do {
		name++;
		hash = partial_name_hash(c, hash);	//计算哈希值,我也不清楚具体实现方法.
		c = *(const unsigned char *)name;
	} while (c && (c != '/'));
	//计算一个路径的字符串长度,此处第一次为"home"的长度4,接下来为"book"的长度,然后是"test.c"的长度
	this.len = name - (const char *) this.name;
	this.hash = end_name_hash(hash);

	/* remove trailing slashes? */
	//判断寻找到哪一步了,因为处理过程大同小异,省略了last_component和last_with_slashes相应的代码段
	if (!c)	//寻找到最后一个组件,即"test.c"字符串
		goto last_component;
	while (*++name == '/');	//去掉组件后面的n个'/'字符,也就是open("/home/book/test.c",O_RDONLY)语句内核也能正确解析
	if (!*name)//最后组件是带'/'的
		goto last_with_slashes;

	
	……
	/* This does the actual lookups.. */
	/* 查找字符串this.name对应目录的dentry结构 */
	err = do_lookup(nd, &this, &next);
	if (err)
		break;

	err = -ENOENT;
	inode = next.dentry->d_inode;
	if (!inode)
		goto out_dput;
	err = -ENOTDIR; 
	if (!inode->i_op)
		goto out_dput;

	if (inode->i_op->follow_link) {
		err = do_follow_link(&next, nd);
		if (err)
			goto return_err;
		err = -ENOENT;
		inode = nd->path.dentry->d_inode;
		if (!inode)
			break;
		err = -ENOTDIR; 
		if (!inode->i_op)
			break;
	} else
		path_to_nameidata(&next, nd);	//将查找到的dentry关联到nd结构
	err = -ENOTDIR; 
	if (!inode->i_op->lookup)
		break;
	continue;
	/* here ends the main loop */
……
}
path_put(&nd->path);


……
}


static int do_lookup(struct nameidata *nd, struct qstr *name,
		     struct path *path)
{
	// nd->path是name的父目录
	struct vfsmount *mnt = nd->path.mnt;
	// 从父目录的dentry链表查找name对应的dentry结构,一般是查不到的,因为第一次打开并没有生成对应的结构
	struct dentry *dentry = __d_lookup(nd->path.dentry, name);

	if (!dentry)
		goto need_lookup;
	if (dentry->d_op && dentry->d_op->d_revalidate)
		goto need_revalidate;


need_lookup:
	dentry = real_lookup(nd->path.dentry, name, nd);
	if (IS_ERR(dentry))
		goto fail;
	goto done;
}

static struct dentry * real_lookup(struct dentry * parent, struct qstr * name, struct nameidata *nd)
{
	struct dentry * result;
	struct inode *dir = parent->d_inode;

	……
	//这里用其他方式再查找一遍,还是查不到
	result = d_lookup(parent, name);
	if (!result) {
		//申请一个dentry结构.用name字符串初始化,并将该dentry结构关联到父目录的dentry链表
		//在对应文件系统的lookup函数中将新的dentry结构链接到dentry_hashtable数组.
		struct dentry * dentry = d_alloc(parent, name);
		result = ERR_PTR(-ENOMEM);
		if (dentry) {
			//调用父目录inode结构的lookup函数.
			result = dir->i_op->lookup(dir, dentry, nd);
			if (result)
				dput(dentry);
			else
				result = dentry;
		}
		mutex_unlock(&dir->i_mutex);
		return result;
	}
	……
	return result;
}

/* 根目录’/'是ext2文件系统的挂载点,所以调用的是ext2文件系统的lookup函数 */

//ext2文件系统的inode操作函数如下

const struct inode_operations ext2_dir_inode_operations = {
	.create		= ext2_create,
	.lookup		= ext2_lookup,
	.link		= ext2_link,
	.unlink		= ext2_unlink,
	.symlink	= ext2_symlink,
	.mkdir		= ext2_mkdir,
	.rmdir		= ext2_rmdir,
	.mknod		= ext2_mknod,
	.rename		= ext2_rename,
#ifdef CONFIG_EXT2_FS_XATTR
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
	.listxattr	= ext2_listxattr,
	.removexattr	= generic_removexattr,
#endif
	.setattr	= ext2_setattr,
	.permission	= ext2_permission,
};

// dir是父目录的inode结构,dentry是根据要查找的name定义的一个dentry结构

static struct dentry *ext2_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
{
	struct inode * inode;
	ino_t ino;
	
	if (dentry->d_name.len > EXT2_NAME_LEN)
		return ERR_PTR(-ENAMETOOLONG);

	// 在ext2文件系统中查找,dentry对应inode的编号
	ino = ext2_inode_by_name(dir, dentry);
	inode = NULL;
	if (ino) {
		inode = ext2_iget(dir->i_sb, ino);
		if (IS_ERR(inode))
			return ERR_CAST(inode);
	}
	//将inode和dentry进行关联
	return d_splice_alias(inode, dentry);
}

// 这个函数执行完,就查找到当前name对应的操作函数,再将dentry关联到nd结构,就可以用nd结构调用得到的函数。

struct inode *ext2_iget (struct super_block *sb, unsigned long ino)
{
	struct ext2_inode_info *ei;
	struct buffer_head * bh;
	struct ext2_inode *raw_inode;
	struct inode *inode;
	long ret = -EIO;
	int n;

	// 从ext2文件系统对应的超级块中查找ino编号相应的inode结构
	inode = iget_locked(sb, ino);

	//普通文件
	if (S_ISREG(inode->i_mode)) {
		inode->i_op = &ext2_file_inode_operations;	
		if (ext2_use_xip(inode->i_sb)) {
			inode->i_mapping->a_ops = &ext2_aops_xip;
			inode->i_fop = &ext2_xip_file_operations;
		} else if (test_opt(inode->i_sb, NOBH)) {
			inode->i_mapping->a_ops = &ext2_nobh_aops;
			inode->i_fop = &ext2_file_operations;
		} else {
			inode->i_mapping->a_ops = &ext2_aops;
			inode->i_fop = &ext2_file_operations;
		}
	} else if (S_ISDIR(inode->i_mode)) {	//目录文件
		inode->i_op = &ext2_dir_inode_operations;	//又将该结构赋值给当前inode,用于作为下级目录的父目录
		inode->i_fop = &ext2_dir_operations;
		if (test_opt(inode->i_sb, NOBH))
			inode->i_mapping->a_ops = &ext2_nobh_aops;
		else
			inode->i_mapping->a_ops = &ext2_aops;
	} else if (S_ISLNK(inode->i_mode)) {
		if (ext2_inode_is_fast_symlink(inode))
			inode->i_op = &ext2_fast_symlink_inode_operations;
		else {
			inode->i_op = &ext2_symlink_inode_operations;
			if (test_opt(inode->i_sb, NOBH))
				inode->i_mapping->a_ops = &ext2_nobh_aops;
			else
				inode->i_mapping->a_ops = &ext2_aops;
		}
	} else {
		inode->i_op = &ext2_special_inode_operations;
		if (raw_inode->i_block[0])
			init_special_inode(inode, inode->i_mode,
			   old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
		else 
			init_special_inode(inode, inode->i_mode,
			   new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
	}
}

//打开文件,就是通过nd结构得到相应的open函数,再调用open函数.

鸿都客
关注
专栏目录
linux系统调用open（）分析
weixin_45523086的博客
10-14 889
当打开一个文件时，需要进行系统调用，通过0x80中断进入内核空间，然后通过系统调用表（sys_call_table）进入系统调用的open主程序sys_open() static inline long open(const char * name, int mode, int flags) { return sys_open(name, mode, flags); } 现对系统调用open进行分析 入口函数sys_open() 需要用到定义系统调用的宏 SYSCALL_DEFIN
qt如和调用linux底层驱动_Linux的应用层到底层驱动的调用过程
weixin_39617252的博客
12-20 648
应用层如何内核.md1.从应用层打通内核：驱动首先来说是设备号的引入，我们通过 cat/proc/kallsyms |grep mydevice 可以查看设备号，当然我们也是可以自己创建设备号，这是源于我们在写内核模块的时候在程序中指定。设备号有了，他就可以标识我们具体的设备。那我们应用层如何操作那？其实我们应用层需要创建一个设备节点文件创建的方法是sudo mknod /dev/hello c ...
Linux的open函数的调用过程,linux open 系统调用过程
weixin_35695434的博客
05-05 712
linux中系统掉用内核部分会调用sys_***(open ,read, write ,close.......)sys_open是linux系统调用open的内核部部分的函数。asmlinkage long sys_open(const char __user *filename, int flags, int mode){if (force_o_largefile())flags |= O_L...
Linux内核(4)——Linux设备文件open函数从应用到内核全过程解析
最新发布
嵌入式Linux开发从业者，立志做一名优秀的博客输出者！
08-01 1140
用户调用glibc接口Open函数->调用到open_not_cancel_2宏定义->INLINE_SYSCALL宏定义->INTERNAL_SYSCALL_RAW宏定义->系统调用的scno映射到寄存器值，并执行swi软中断指令->此时进入内核态，触发syscall系统调用，执行内核的vevtor_swi函数->获取scno，并根据call.s组成的sys_call_table中找到对应的系统调用函数->执行函数，调用retq指令返回用户态。
【Linux操作系统】深入理解Linux系统编程中的open函数
热门推荐
Goforyouqp的博客
08-12 1万+
通过以上示例，我们可以看到open函数的灵活性和强大功能。它可以用于打开已存在的文件、创建新文件，以及以不同的方式（只读、只写、读写）打开文件。同时，我们还可以通过flags参数和mode参数来控制文件的属性和权限。
PyCharm：pip下载依赖包缓慢问题解决方法
璟矢
06-20 4077
理论是灰色的，实践之树长青???? ——恩格斯 前述 近期使用PyCharm IDE做课程作业时，通过pip下载python依赖包时出现下载失败、下载速度缓慢的问题，由于使用pip下载时是去python官网下载的，存在被墙的问题，所以一般我们都会使用清华、阿里云、中科大的镜像源去提升下载速度。 ⏰提醒：推荐使用python3以上版本，因为pip和python版本是一致的，部分依赖包的下载只能通过3以上版本才能下载！ step 1 在Preferences中选择要使用的依赖包 ——> 点击下
open、fopen与freopen
wsclinux的专栏
11-18 1510
Linux（C/C++）下的文件操作open、fopen与freopenopen是linux下的底层系统调用函数，fopen与freopen c/c++下的标准I/O库函数，带输入/输出缓冲。 linxu下的fopen是open的封装函数，fopen最终还是要调用底层的系统调用open。 所以在linux下如果需要对设备进行明确的控制，那最好使用底层系统调用（open），open对应的文件操作有
Linxu中的系统调用函数—open函数（详解）
01-09
open函数 //头文件： #include #include #include //功能：打开和创建文件（建立一个文件描述符，其他的函数可以通过文 件描述符对指定文件进行读取与写入的操作。） 原型 int open(const char*pathname,int ...
Linux设备驱动开发详解-基于最新的Linux4.0内核
04-08
对于字符设备，开发者需要实现open、read、write等系统调用的回调函数；块设备驱动则需关注块I/O操作，如request_queue的处理；而网络设备驱动则需要实现net_device结构体，包括初始化、接收和发送数据包的函数。 ...
《Linux 设备驱动开发详解》（宋宝华） 学习笔记.zip
02-10
《Linux 设备驱动开发详解》是宋宝华先生的一本经典著作，专注于讲解Linux系统下的设备驱动程序开发。这本书深入浅出地介绍了如何为各种硬件设备编写驱动程序，是嵌入式Linux开发者的重要参考资料。在学习这本书的...
Mybatis调用Oracle存储过程的方法图文详解
08-29
Mybatis调用Oracle存储过程的方法详解 Mybatis是一款流行的持久层框架，广泛应用于Java企业级应用开发中。 Oracle存储过程是一种高效的数据库操作方式，通过存储过程可以实现复杂的业务逻辑操作。那么，如何使用...
linux 中open()函数详解及简单实例
09-15
主要介绍了linux 中open()函数详解及简单实例的相关资料,需要的朋友可以参考下
Linux中open函数详解
tianmo2010的专栏
10-10 6038
open（打开文件）  相关函数  　　read，write，fcntl，close，link，stat，umask，unlink，fopen  头文件  　　#include  　　#include  　　#include  定义函数  　　int open( const char * pathname,int flags);  　　int open( const ch
open（）Linux系统调用函数
m0_65690223的博客
05-25 743
它首先使用 `open()` 函数打开源文件和目标文件，然后使用 `read()` 函数从源文件中读取数据到缓冲区中，再使用 `write()` 函数将缓冲区中的数据写入目标文件中。最后，使用 `close()` 函数关闭文件描述符，释放资源。- `open()`：打开文件并返回文件描述符。- `dup2()`：复制一个文件描述符，使其指向同一个文件。- `dup()`：复制一个文件描述符，使其指向同一个文件。- `write()`：向文件描述符中写入数据。- `read()`：从文件描述符中读取数据。
Linux open系统调用(三)
Blue summer的博客
03-01 669
注：本文分析基于3.10.0-693.el7内核版本，即CentOS 7.4 上回说到".“和”.."两个目录项，如果打开的文件目录是一个正常绝对路径呢，如，/home/test.txt，那这个时候就是普通目录的处理了。 static inline int walk_component(struct nameidata *nd, struct path *path, int follow) {...
Linux--系统调用接口：open
weixin_67916525的博客
07-19 271
mode:创建的pathname默认权限 ，必须写成8进制形式以0开头。注：以上标志位选项必须用|连接起来。
Linux open系统调用(二)
Blue summer的博客
10-23 1067
注：本文分析基于3.10.0-693.el7内核版本，即CentOS 7.4 上回说到根据用户给的路径，通过path_init函数设定起始目录nd->path，那接下来就要遍历目录了，我们从link_path_walk函数开始分析。 static int link_path_walk(const char *name, struct nameidata *nd) { struct path...
Linux文件编程常用函数详解——open（）函数
weixin_42031299的博客
05-31 1555
open（）函数介绍： 1.open( )函数需要包含的头文件： #include<sys/types.h> #include<sys/stat.h> #include<fcntl.h> 2.open()函数的形式： int open(const char* pathname, int oflag,.../*, mode_t mode * / ...
Linux open系统调用(一)
Blue summer的博客
10-16 3246
SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode) { //对于64位系统会添加O_LARGEFILE选项，以便能打开大文件 if (force_o_largefile()) flags |= O_LARGEFILE; return do_sys_open(AT_FDCWD, ...
Unix/Linux编程：Open函数详解
"Open函数是Unix/Linux系统中用于打开或创建文件的关键函数，广泛应用于C和C++编程。它定义在`<fcntl.h>`头文件中，有两个主要的重载形式，以及一个`creat`函数，后者仅在创建新文件时使用。在调用`open`函数时，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值