sys_mknod()

最新推荐文章于 2025-03-25 16:08:51 发布
最新推荐文章于 2025-03-25 16:08:51 发布
阅读量2.1k 收藏 4
点赞数
分类专栏： 内核
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/nanaoxue/article/details/35786725
版权
上篇文章中讲到rootfs文件系统挂载后，会先创建”/dev”目录，之后会创建设备文件"/dev/console",本文就分析下该设备文件的建立过程，文中还会见到与字符设备密切相关的chrdev_open()函数
1.default_rootfs
noinitramfs.c-->default_rootfs() 
static int __init default_rootfs(void)
{
...

	err = sys_mknod((const char __user *) "/dev/console",
			S_IFCHR | S_IRUSR | S_IWUSR,
		new_encode_dev(MKDEV(5, 1)));
...
}


S_IFCHR表示要建立字符设备文件，S_IRUSR表示文件拥有者可以读该文件，S_IWUSR表示文件拥有者可以写该文件。第三个参数是设别号，这里是0x501。2.6内核的设备号采用新的计算方式。
2.sys_mknod 
SYSCALL_DEFINE3(mknod, const char __user *, filename, int, mode, unsigned, dev)
{
	return sys_mknodat(AT_FDCWD, filename, mode, dev);
}

SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, int, mode,
		unsigned, dev)
{
	int error;
	char *tmp;
	struct dentry *dentry;
	struct nameidata nd;


	if (S_ISDIR(mode))
		return -EPERM;

	
	error = user_path_parent(dfd, filename, &nd, &tmp);
	if (error)
		return error;

	dentry = lookup_create(&nd, 0);
	if (IS_ERR(dentry)) {
		error = PTR_ERR(dentry);
		goto out_unlock;
	}
	if (!IS_POSIXACL(nd.path.dentry->d_inode))
		mode &= ~current_umask();
	error = may_mknod(mode);
	if (error)
		goto out_dput;
	error = mnt_want_write(nd.path.mnt);
	if (error)
		goto out_dput;
	error = security_path_mknod(&nd.path, dentry, mode, dev);
	if (error)
		goto out_drop_write;
	switch (mode & S_IFMT) {
		case 0: case S_IFREG:
			error = vfs_create(nd.path.dentry->d_inode,dentry,mode,&nd);
			break;
		case S_IFCHR: case S_IFBLK:
			error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,
					new_decode_dev(dev));
			break;
		case S_IFIFO: case S_IFSOCK:
			error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,0);
			break;
	}
out_drop_write:
	mnt_drop_write(nd.path.mnt);
out_dput:
	dput(dentry);
out_unlock:
	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
	path_put(&nd.path);
	putname(tmp);

	return error;
}
比较sys_mknod()和sys_mkdir()的代码，会发现很相似。只不过sys_mkdir调用的是vfs_mkdir,而sys_mknod会调用vfs_create或者vfs_mknod.其实ramfs_mkdir也会调用ramfs_mknod，只不过参数不同而已。
另外创建目录”/dev”和创建设备文件”/dev/console”还有一个不同点，就是创建”/dev/console”时，因为”/dev”已经存在，所以user_path_parent()->do_path_lookup()->path_walk()->link_path_walk()->__link_path_walk()中的for循环会循环两次，而之前创建”/dev”时，只执行了一次，就退出循环了。
下面就分析下这两个不同点
不同点1.__link_path_walk 
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;
	
	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);
 		if (err)
			break;

		this.name = name;
		c = *(const unsigned char *)name;

		hash = init_name_hash();
		do {
			name++;
			hash = partial_name_hash(c, hash);
			c = *(const unsigned char *)name;
		} while (c && (c != '/'));
		this.len = name - (const char *) this.name;
		this.hash = end_name_hash(hash);
		/*第一次循环时，this.name=”dev/console”,this.len=3
		*第二次循环时，this.name=”console”,this.len=7
		*/
		
		/* remove trailing slashes? */
		/*第二次循环时，因为已查找完毕，会从此处跳走。第一次循环时会继续往下走*/
	    if (!c)
			goto last_component;
		while (*++name == '/');
		if (!*name)
		goto last_with_slashes;
		/*
		 * "." and ".." are special - ".." especially so because it has
		 * to be able to know about the current root directory and
		 * parent relationships.
		 */
		if (this.name[0] == '.') switch (this.len) {
			default:
				break;
			case 2:	
				if (this.name[1] != '.')
					break;
				follow_dotdot(nd);
				inode = nd->path.dentry->d_inode;
				/* fallthrough */
			case 1:
				continue;
		}
		/*
		 * See if the low-level filesystem might want
		 * to use its own hash..
		 */
		if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) {
			err = nd->path.dentry->d_op->d_hash(nd->path.dentry,
							    &this);
			if (err < 0)
				break;
		}
		/* This does the actual lookups.. */
		/*从dentry_hashtable表中查找”dev”目录的目录项，
		*因为之前已建立”dev”目录，并将其插入到了dentry_hashtable表中
		*所以可以找到”dev”的目录项。找到后，将其保存在path结构的next变量中，
		*do_lookup的具体代码，这里不再分析
		*/
		err = do_lookup(nd, &this, &next);
		if (err)
			break;

		err = -ENOENT;
		/*获取”dev”目录对应的inode结构*/
		inode = next.dentry->d_inode;
		if (!inode)
			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;
		} else
		/*将path结构的next变量中的内容赋给nameidata结构的nd变量
                 *即把起始目录改为”dev”目录，第二次循环时的父目录就是”dev”目录.
                 *这样，就实现每循环一次，目录就深入一次。
		 */
			path_to_nameidata(&next, nd);
		err = -ENOTDIR; 
		if (!inode->i_op->lookup)
			break;
		/*第一次循环结束*/
		continue;
		/* here ends the main loop */

last_with_slashes:
		lookup_flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
last_component:
		/*第二次循环会跳到此处*/
		/* Clear LOOKUP_CONTINUE iff it was previously unset */
		nd->flags &= lookup_flags | ~LOOKUP_CONTINUE;
		/*因为设置了LOOKUP_PARENT，即只需要获取父目录的信息，所以
		*跳到 lookup_parent处
		*/
		if (lookup_flags & LOOKUP_PARENT)
			goto lookup_parent;
		if (this.name[0] == '.') switch (this.len) {
			default:
				break;
			case 2:	
				if (this.name[1] != '.')
					break;
				follow_dotdot(nd);
				inode = nd->path.dentry->d_inode;
				/* fallthrough */
			case 1:
				goto return_reval;
		}
		if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) {
			err = nd->path.dentry->d_op->d_hash(nd->path.dentry,
							    &this);
			if (err < 0)
				break;
		}
		err = do_lookup(nd, &this, &next);
		if (err)
			break;
		inode = next.dentry->d_inode;
		if (follow_on_final(inode, lookup_flags)) {
			err = do_follow_link(&next, nd);
			if (err)
				goto return_err;
			inode = nd->path.dentry->d_inode;
		} else
			path_to_nameidata(&next, nd);
		err = -ENOENT;
		if (!inode)
			break;
		if (lookup_flags & LOOKUP_DIRECTORY) {
			err = -ENOTDIR; 
			if (!inode->i_op->lookup)
				break;
		}
		goto return_base;
lookup_parent:
		/*将最后的”console”等信息存放在nd->last中*/
		nd->last = this;
		nd->last_type = LAST_NORM;
		if (this.name[0] != '.')
			goto return_base;
		if (this.len == 1)
			nd->last_type = LAST_DOT;
		else if (this.len == 2 && this.name[1] == '.')
			nd->last_type = LAST_DOTDOT;
		else
			goto return_base;
return_reval:
		/*
		 * We bypassed the ordinary revalidation routines.
		 * We may need to check the cached dentry for staleness.
		 */
		if (nd->path.dentry && nd->path.dentry->d_sb &&
		    (nd->path.dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)) {
			err = -ESTALE;
			/* Note: we do not d_invalidate() */
			if (!nd->path.dentry->d_op->d_revalidate(
					nd->path.dentry, nd))
				break;
		}
return_base:
		return 0;
out_dput:
		path_put_conditional(&next, nd);
		break;
	}
	path_put(&nd->path);
return_err:
	return err;
}
该函数循环两次，最后将父目录”dev”的信息存放在nd->path中，”console”等要创建的文件信息放在nd->last中。之后一路返回主函数，接着调用lookup_create()，查找是否存在所要创建的文件对应的dentry，没有则新建dentry结构，并初始化，具体见上篇文章。

不同点2.vfs_mknod
因为设置了S_IFCHR，并分配了设备号，所以最后要调用vfs_mknod.创建设备文件对应的inode结构。
fs/ramfs/inode.c 
static int
ramfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
{
	struct inode * inode = ramfs_get_inode(dir->i_sb, mode, dev);
	int error = -ENOSPC;

	if (inode) {
		if (dir->i_mode & S_ISGID) {
			inode->i_gid = dir->i_gid;
			if (S_ISDIR(mode))
				inode->i_mode |= S_ISGID;
		}
		/*建立目录项和索引节点的关联*/
		d_instantiate(dentry, inode);
		dget(dentry);	/* Extra count - pin the dentry in core */
		error = 0;
		dir->i_mtime = dir->i_ctime = CURRENT_TIME;
	}
	return error;
}
struct inode *ramfs_get_inode(struct super_block *sb, int mode, dev_t dev)
{
	struct inode * inode = new_inode(sb);

	if (inode) {
		inode->i_mode = mode;
		inode->i_uid = current_fsuid();
		inode->i_gid = current_fsgid();
		inode->i_mapping->a_ops = &ramfs_aops;
		inode->i_mapping->backing_dev_info = &ramfs_backing_dev_info;
		mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER);
		mapping_set_unevictable(inode->i_mapping);
		inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
		switch (mode & S_IFMT) {
		default:
			init_special_inode(inode, mode, dev);
			break;
		case S_IFREG:
			inode->i_op = &ramfs_file_inode_operations;
			inode->i_fop = &ramfs_file_operations;
			break;
		case S_IFDIR:
			inode->i_op = &ramfs_dir_inode_operations;
			inode->i_fop = &simple_dir_operations;
			/* directory inodes start off with i_nlink == 2 (for "." entry) */
			inc_nlink(inode);
			break;
		case S_IFLNK:
			inode->i_op = &page_symlink_inode_operations;
			break;
		}
	}
	return inode;
}
这里需要讲解的就只有init_special_inode(),但也很简单。 
void init_special_inode(struct inode *inode, umode_t mode, dev_t rdev)
{
	/*设置mode，open时，会根据该mode判断是否是字符设备*/
	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) for"
				  " inode %s:%lu\n", mode, inode->i_sb->s_id,
				  inode->i_ino);
}
最后看下所设置的文件操作函数集里的具体内容， 
const struct file_operations def_chr_fops = {
	.open = chrdev_open,
};
可以找到chrdev_open函数。该函数以后编写和分析字符设备时，再详细分析下。
Linux 系统调用之 mknod
bgao86的博客
05-08 4523
继续上一篇的分析，我们在使用命令： mknod /dev/my_chr_dev0 c $major 0 创建设备文件的时候，内核做了哪些事呢？可以肯定的一点是，内核肯定创建了一个 inode 结构体，并加入到系统里面，要不然在打开设备文件的时候，会因为lookup_fast()函数找不到相应的 inode，从而使得打开失败。也许你会说，lookup_fast()函数失败了，还有lookup_slo...
Linux Kernel - mknod系统调用
lqp276的博客
12-07 1464
mknod简介mknod是用来创建特殊设备文件的系统调用, 在Linux Kernel - 探索Ram Disk 驱动(1) - 体验使用中, 我们通过在/dev/ram0的设备文件创建文件系统后, 访问我们挂载的Ram Disk设备. 与普通意义上的文件不同, 对一个设备的读写实质上会调用到设备驱动提供的读写函数, 进而和设备产生交互. lqp@lqp-ThinkPad-T540p:~$ ls
linux sys 创建设备,mknod利用udev、sys动态创建linux设备结点（转载）
weixin_28717611的博客
05-05 231
在Linux 2.6内核中，devfs被认为是过时的方法，并最终被抛弃，udev取代了它。Devfs的一个很重要的特点就是可以动态创建设备结点。那我们现在如何通过udev和sys文件系统动态创建设备结点呢？用udev在/dev/下动态生成设备文件，这样用户就不用手工调用mknod了。利用的kernel API：class_create : 创建classclass_destro...
linux 根文件系统，根设备，sys_open, sys_read, sys_write, sys_mount, sys_mknod
01-09
笔者语： 1. 内容涉及比较多，自己也没有分章节，因为觉得这些内容关联性很强，自己也懒的去弄了。 2. 本文涉及以下内容：     2.1 内核启动过程中，第一个文件系统为rootfs, 描述内核如何从rootfs切换到真正的根文件系统，           这其中包括了根设备的查找，还包括ramdisk, cpiok-initrd, image-initrd的描述。     2.2 内核如何关联文件dentry&inode。     2.3 内核与文件系统操作的几个相关的系统调用sys_open, sys_read, sys_write, sys_mount, sys_mknod。    
mknod命令与device_create函数的关系
最新发布
weixin_42369760的博客
03-25 549
mknod命令与函数在 Linux 设备管理中扮演不同角色，但共同作用于设备节点的创建。mknod()：在内核中动态创建设备对象，并触发用户空间（如udev）自动生成设备节点。：通过注册设备类（如在类下生成设备对象（如udev监测到 sysfs 变化后，根据规则创建设备节点（如：无需手动指定设备号，通过动态分配（）和 udev 自动化管理。
linux内核分析 轮换,Linux内核源代码情状分析-系统调用mknod
weixin_42309599的博客
04-30 267
Linux内核源代码情景分析-系统调用mknod普通文件可以用open或者create创建，FIFO文件可以用pipe创建，mknod主要用于设备文件的创建。在内核中，mknod是由sys_mknod实现的，代码如下：asmlinkage long sys_mknod(const char * filename, int mode, dev_t dev) //比如filename为/tmp/ser...
按照你说的做了，编译时驱动时报了sys_mknod函数找不到的错误，这是什么原因？
06-15
在Linux内核中，sys_mknod函数并不是一个公共的函数，它只在内核空间中使用。因此，在驱动中使用sys_mknod函数会报错找不到函数的错误。 如果想在驱动中创建设备节点，可以使用内核提供的函数device_create和class_...
sys_mkdir
03-29
sys_mkdir
Linux内核源代码情景分析-系统调用mknod
jltxgcy的专栏
05-05 2792
普通文件可以用open或者create创建，FIFO文件可以用pipe创建，mknod主要用于设备文件的创建。    在内核中，mknod是由sys_mknod实现的，代码如下：asmlinkage long sys_mknod(const char * filename, int mode, dev_t dev) //比如filename为/tmp/server_socket，dev是设备号 {
文件系统--mknod系统调用
new_abc的专栏
06-26 5453
在前面 介绍android的init进程的时候，我们看到其中有如下代码 mkdir("/dev", 0755); mkdir("/proc", 0755); mkdir("/sys", 0755); mount("tmpfs", "/dev", "tmpfs", 0, "mode=0755"); mkdir("/dev/pts",
mknod Permission denied
mzhan017的博客
09-14 735
bash-4.2$ mknod /var/log/pipe p mknod: ‘/var/log/pipe’: Permission denied bash-4.2$ mknod --help Usage: mknod [OPTION]… NAME TYPE [MAJOR MINOR] Create the special file NAME of the given TYPE. Mandatory arguments to long options are mandatory for short opti
Linux中mknod命令实现原理以及源码分析
assiduous_me的博客
05-21 7175
本篇文章以mknod创建字符设备文件进行讲解 字符设备驱动的Demo例子可参考该篇文章 Linux 编写简单驱动并测试 1. mknod 命令 mknod /dev/hello c 520 0 该命令主要通过制定要创建的设备文件名称/dev/hello，以及设备类型c字符设备，最后的520 0 表示为主设备号和次设备号。 当我们使用该命令创建好了/dev/hello设备文件，当我们在用户态对该文件进行open()、write()、read()时，就会调用到/dev/hello设备文件对应的设备驱动的fil
LINUX系统调用sys_mkdir()中所得的pathname参数不是全路径，要将其转为全路径的解决办法。
zonelight的专栏
07-19 1746
<br />asmlinkage long new_mkdir(const char __user *pathname,int mode) { /*创建一个nameidata结构体*/ struct nameidata nd; /*nd这里赋值完后里面就含有全路径的信息了*/ int ret = path_lookup(pathname,LOOKUP_DIRECTORY,&nd); /*打印出的是所创建的文件夹的名称，比如mydir*/
rootfs下目录的建立--sys_mkdir()
nanaoxue的专栏
06-29 2709
参考文章 http://blog.csdn.net/new_abc/article/details/7688880 http://blog.csdn.net/new_abc/article/details/7689137 http://blog.csdn.net/new_abc/article/details/7712715 a. rootfs注册和挂载后，会先建立几个目录，之后
mkdir系统调用
new_abc的专栏
07-04 6141
mkdir系统调用用来创建一个目录，对应的系统调用在fs/namei.c中 SYSCALL_DEFINE2(mkdir, const char __user *, pathname, int, mode) { return sys_mkdirat(AT_FDCWD, pathname, mode); }我里的AT_FDCWD我的理解是在进行路径查找初始化时如果路径不是绝对路径则设置为从当前
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值