ext2文件系统源代码之namei.c

淡淡的烟草味﹌ 2022-07-29 09:20 69阅读 0赞

我们继续来看ext2文件系统源代码里的namei.c文件，这个文件的代码主要是文件名查找之类的操作函数，并不是很难。

/*
     * linux/fs/ext2/namei.c
     *
     * The only non-static object here is ext2_dir_inode_operations.
     *
     * 作者信息
     * Copyright (C) 1992, 1993, 1994, 1995
     * Remy Card (card@masi.ibp.fr)
     * Laboratoire MASI - Institut Blaise Pascal
     * Universite Pierre et Marie Curie (Paris VI)
     *
     *  from
     *
     *  linux/fs/minix/namei.c
     *
     *  Copyright (C) 1991, 1992  Linus Torvalds
     *
     *  Big-endian to little-endian byte-swapping/bitmaps by
     *        David S. Miller (davem@caip.rutgers.edu), 1995
     */
    
    
    #include <linux/pagemap.h>
    #include "ext2.h"
    #include "xattr.h"
    #include "acl.h"
    #include "xip.h"
    /*增加目录和文件的连接*/
    static inline int ext2_add_nondir(struct dentry *dentry, struct inode *inode)
    {
    	/*ext2_add_link函数我们之前讲过，就是把dentry目录和inode文件建立连接*/
    	int err = ext2_add_link(dentry, inode);
    	/*如果建立连接成功，填充dentry的一些数据*/
    	if (!err) {
    		d_instantiate(dentry, inode);
    		return 0;
    	}
    	/*建立连接失败，就减少inode的连接数目*/
    	inode_dec_link_count(inode);
    	iput(inode);
    	return err;
    }
    /*在dir目录里查找dentry文件，dir是想要查找的文件所在目录的inode，dentry是想找的文件dentry，nd是辅助查找结构体，里边存放查找结果*/
    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);
    	/*之前讲过的函数，在目录里根据文件名查找文件的inode，返回inode号码*/
    	ino = ext2_inode_by_name(dir, dentry);
    	inode = NULL;
    	/*找到啦！*/
    	if (ino) {
    		/*从inode的ino编号得到文件的inode结构体*/
    		inode = iget(dir->i_sb, ino);
    		/*如果返回失败，返回权限错误*/
    		if (!inode)
    			return ERR_PTR(-EACCES);
    	}
    	/*把inode和dentry连接起来*/
    	return d_splice_alias(inode, dentry);
    }
    /*获得dentry的父目录的dentry*/
    struct dentry *ext2_get_parent(struct dentry *child)
    {
    	unsigned long ino;
    	struct dentry *parent;
    	struct inode *inode;
    	/*dotdot存放父目录的dentry结构体*/
    	struct dentry dotdot;
    	/*dotdot代表..*/
    	dotdot.d_name.name = "..";
    	dotdot.d_name.len = 2;
    	/*使用我们之前讲过的ext2_inode_by_name函数，来得到父目录的inode号码*/
    	ino = ext2_inode_by_name(child->d_inode, &dotdot);
    	if (!ino)
    		return ERR_PTR(-ENOENT);
    	/*根据号码得到inode结构体*/
    	inode = iget(child->d_inode->i_sb, ino);
    	/*获取失败，返回权限错误*/
    	if (!inode)
    		return ERR_PTR(-EACCES);
    	/*调用dcache的d_alloc_anon函数，分配一个dentry结构体*/
    	parent = d_alloc_anon(inode);
    	/*失败返回没有内存*/
    	if (!parent) {
    		iput(inode);
    		parent = ERR_PTR(-ENOMEM);
    	}
    	/*分配成功，返回父目录的dentry结构体*/
    	return parent;
    } 
    
    
    /* ext2的创建新文件，在创建这个文件之前，我们已经创建好了dentry结构体，但是没有inode结构体 */
    static int ext2_create (struct inode * dir, struct dentry * dentry, int mode, struct nameidata *nd)
    {
    	/*创建inode结构体*/
    	struct inode * inode = ext2_new_inode (dir, mode);
    	int err = PTR_ERR(inode);
    	/*inode正确的话*/
    	if (!IS_ERR(inode)) {
    		/*inode的inode操作函数集合指向ext2_file_inode_operations*/
    		inode->i_op = &ext2_file_inode_operations;
    		/*ext2是使用片内执行的硬件，地址空间函数操作和文件操作函数不一样*/
    		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，使用另一套地址空间操作函数和文件操作函数*/
    			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;
    		}
    		/*修改过，就标记inode脏*/
    		mark_inode_dirty(inode);
    		/*建立dentry和inode的连接*/
    		err = ext2_add_nondir(dentry, inode);
    	}
    	return err;
    }
    /*ext2根据文件模式和设备号新建一个inode*/
    static int ext2_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t rdev)
    {
    	struct inode * inode;
    	int err;
    	/*判断设备号是不是合法*/
    	if (!new_valid_dev(rdev))
    		return -EINVAL;
    	/*新建inode结构体*/
    	inode = ext2_new_inode (dir, mode);
    	err = PTR_ERR(inode);
    	if (!IS_ERR(inode)) {
    		/*特殊设备的inode初始化，根据文件的类型不同设置不同的操作函数集合*/
    		init_special_inode(inode, inode->i_mode, rdev);
    		/*配置了文件属性才会有*/
    #ifdef CONFIG_EXT2_FS_XATTR
    		/*特殊文件的操作结构体集合*/
    		inode->i_op = &ext2_special_inode_operations;
    #endif
    		/*写后都要标记脏*/
    		mark_inode_dirty(inode);
    		/*建立目录和inode的连接*/
    		err = ext2_add_nondir(dentry, inode);
    	}
    	return err;
    }
    /*ext2建立软链接，dir是要建立的连接所在的目录，dentry是链接文件的dentry，symname是软连接文件爱你明*/
    static int ext2_symlink (struct inode * dir, struct dentry * dentry,
    	const char * symname)
    {
    	/*获得vfs层的超级块结构体*/
    	struct super_block * sb = dir->i_sb;
    	int err = -ENAMETOOLONG;
    	/*l存放连接名字长度*/
    	unsigned l = strlen(symname)+1;
    	struct inode * inode;
    	/*看看连接名字是不是太长*/
    	if (l > sb->s_blocksize)
    		goto out;
    	/*新建一个软链接文件，user，group和other都对他有读写执行权限*/
    	inode = ext2_new_inode (dir, S_IFLNK | S_IRWXUGO);
    	err = PTR_ERR(inode);
    	if (IS_ERR(inode))
    		goto out;
    	/*ext2文件系统里，ext2_inode_info结构体的i_data用来存放软链接的文件名，这叫做快速链接，如果放不下就放在块里，这叫做慢速链接*/
    	if (l > sizeof (EXT2_I(inode)->i_data)) {
    		/*慢连接的inode操作函数*/
    		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;
    		/*fs层的软链接与页的链接*/
    		err = page_symlink(inode, symname, l);
    		if (err)
    			goto out_fail;
    	} else {
    		/* 快速链接的inode函数操作集合设置 */
    		inode->i_op = &ext2_fast_symlink_inode_operations;
    		/*把链接的名字放在i_data里*/
    		memcpy((char*)(EXT2_I(inode)->i_data),symname,l);
    		/*i_size是文件大小，就是软链接名字长度*/
    		inode->i_size = l-1;
    	}
    	/*写过以后标记为脏*/
    	mark_inode_dirty(inode);
    	/*建立目录和软链接的连接*/
    	err = ext2_add_nondir(dentry, inode);
    out:
    	return err;
    
    
    out_fail:
    	/*失败后就会减少软链接的引用计数*/
    	inode_dec_link_count(inode);
    	iput (inode);
    	goto out;
    }
    /*建立目录的inode和dentry之间的硬连接，因为是硬连接，所以其实上是有两个dentr指向inode*/
    static int ext2_link (struct dentry * old_dentry, struct inode * dir,
    	struct dentry *dentry)
    {
    	/*获得原先的dentry的inode*/
    	struct inode *inode = old_dentry->d_inode;
    	/*如果已经超过了最大限制，返回错误*/
    	if (inode->i_nlink >= EXT2_LINK_MAX)
    		return -EMLINK;
    	/*修改时间*/
    	inode->i_ctime = CURRENT_TIME_SEC;
    	/*增加inode的链接计数*/
    	inode_inc_link_count(inode);
    	atomic_inc(&inode->i_count);
    	/*把新的dentry也指向inode*/
    	return ext2_add_nondir(dentry, inode);
    }
    /*新建一个目录，dir是新建的目录在的父目录，新建的额目录的dentry*/
    static int ext2_mkdir(struct inode * dir, struct dentry * dentry, int mode)
    {
    	struct inode * inode;
    	int err = -EMLINK;
    	/*子目录过多了*/
    	if (dir->i_nlink >= EXT2_LINK_MAX)
    		goto out;
    	/*增加dir的计数*/
    	inode_inc_link_count(dir);
    	/*新建一个目录的inode*/
    	inode = ext2_new_inode (dir, S_IFDIR | mode);
    	err = PTR_ERR(inode);
    	if (IS_ERR(inode))
    		goto out_dir;
    	/*为新建的目录inode设置操作函数*/
    	inode->i_op = &ext2_dir_inode_operations;
    	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;
    	/*目录的inode增加引用计数*/
    	inode_inc_link_count(inode);
    	/*新建的目录，肯定是空的，清空*/
    	err = ext2_make_empty(inode, dir);
    	if (err)
    		goto out_fail;
    	/*建立dentry和inode的链接*/
    	err = ext2_add_link(dentry, inode);
    	if (err)
    		goto out_fail;
    	/*用inode的一些数据填充dentry*/
    	d_instantiate(dentry, inode);
    out:
    	return err;
    
    
    out_fail:
    	inode_dec_link_count(inode);
    	inode_dec_link_count(inode);
    	iput(inode);
    out_dir:
    	inode_dec_link_count(dir);
    	goto out;
    }
    /*释放目录对于目录项的链接*/
    static int ext2_unlink(struct inode * dir, struct dentry *dentry)
    {
    	/*目录项的inode*/
    	struct inode * inode = dentry->d_inode;
    	struct ext2_dir_entry_2 * de;
    	struct page * page;
    	int err = -ENOENT;
    	/*在dir目录里寻找dentry目录项*/
    	de = ext2_find_entry (dir, dentry, &page);
    	if (!de)
    		goto out;
    	/*在目录项列表里删除这个目录项*/
    	err = ext2_delete_entry (de, page);
    	if (err)
    		goto out;
    	/*修改时间和减少这个被删除目录项的引用计数*/
    	inode->i_ctime = dir->i_ctime;
    	inode_dec_link_count(inode);
    	err = 0;
    out:
    	return err;
    }
    /*删除目录，dir是删除的目录的父目录，dentry是删除的目录的dentry*/
    static int ext2_rmdir (struct inode * dir, struct dentry *dentry)
    {
    	/*要删除目录的inode*/
    	struct inode * inode = dentry->d_inode;
    	int err = -ENOTEMPTY;
    
    
    	/*把要删除的目录清空*/
    	if (ext2_empty_dir(inode)) {
    		/*然后解除父目录对于子目录的链接*/
    		err = ext2_unlink(dir, dentry);
    		if (!err) {
    			/*把子目录文件大小置为0，减少引用计数*/
    			inode->i_size = 0;
    			inode_dec_link_count(inode);
    			inode_dec_link_count(dir);
    		}
    	}
    	return err;
    }
    /*重命名目录名字，old_dir是老的目录的父目录inode，old_dentry是老的目录的目录项结构体，new_dir是新的目录的父目录，new_dentry是新的目录项*/
    static int ext2_rename (struct inode * old_dir, struct dentry * old_dentry,
    	struct inode * new_dir,	struct dentry * new_dentry )
    {
    	/*新老目录的inode*/
    	struct inode * old_inode = old_dentry->d_inode;
    	struct inode * new_inode = new_dentry->d_inode;
    	struct page * dir_page = NULL;
    	struct ext2_dir_entry_2 * dir_de = NULL;
    	struct page * old_page;
    	struct ext2_dir_entry_2 * old_de;
    	int err = -ENOENT;
    	/*在老的目录里寻找老的目录项*/
    	old_de = ext2_find_entry (old_dir, old_dentry, &old_page);
    	if (!old_de)
    		goto out;
    	/*如果这个文件是一个目录的话，就先获得这个目录的父目录项*/
    	if (S_ISDIR(old_inode->i_mode)) {
    		err = -EIO;
    		/*得到这个目录项的父目录*/
    		dir_de = ext2_dotdot(old_inode, &dir_page);
    		if (!dir_de)
    			goto out_old;
    	}
    	/*如果这个新的目录项有inode*/
    	if (new_inode) {
    		struct page *new_page;
    		struct ext2_dir_entry_2 *new_de;
    
    
    		err = -ENOTEMPTY;
    		/*清空这新建的目录，如果没有成功，跳转到out_dir*/
    		if (dir_de && !ext2_empty_dir (new_inode))
    			goto out_dir;
    
    
    		err = -ENOENT;
    		/*在新目录里寻找新的目录项*/
    		new_de = ext2_find_entry (new_dir, new_dentry, &new_page);
    		if (!new_de)
    			goto out_dir;
    		/*增加原先的目录项的引用计数*/
    		inode_inc_link_count(old_inode);
    		/*设置新目录对新目录项的链接*/
    		ext2_set_link(new_dir, new_de, new_page, old_inode);
    		/*修改时间*/
    		new_inode->i_ctime = CURRENT_TIME_SEC;
    		/*释放原先的连接*/
    		if (dir_de)
    			drop_nlink(new_inode);
    		/*增加新的目录项引用计数*/
    		inode_dec_link_count(new_inode);
    	} else {
    		/*新的目录项还没有inode，说明是一个硬连接*/
    		if (dir_de) {
    			err = -EMLINK;
    			if (new_dir->i_nlink >= EXT2_LINK_MAX)
    				goto out_dir;
    		}
    		/*硬连接增加inode引用计数*/
    		inode_inc_link_count(old_inode);
    		/*建立新目录项和原先的inode连接*/
    		err = ext2_add_link(new_dentry, old_inode);
    		if (err) {
    			inode_dec_link_count(old_inode);
    			goto out_dir;
    		}
    		if (dir_de)
    			inode_inc_link_count(new_dir);
    	}
    
    
    	/*修改时间*/
    	old_inode->i_ctime = CURRENT_TIME_SEC;
    	/*在老的目录上删除老的目录项*/
    	ext2_delete_entry (old_de, old_page);
    	/*减少其引用计数*/
    	inode_dec_link_count(old_inode);
    	/**/
    	if (dir_de) {
    		/*把原先目录和新的文件连接起来*/
    		ext2_set_link(old_inode, dir_de, dir_page, new_dir);
    		/*减少原先的目录连接计数*/
    		inode_dec_link_count(old_dir);
    	}
    	return 0;
    
    
    
    
    out_dir:
    	/*操作失败，释放原先的目录结构体*/
    	if (dir_de) {
    		kunmap(dir_page);
    		page_cache_release(dir_page);
    	}
    out_old:
    	kunmap(old_page);
    	page_cache_release(old_page);
    out:
    	return err;
    }
    /*目录的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,
    };
    /*特殊文件的inode操作函数表*/
    const struct inode_operations ext2_special_inode_operations = {
    #ifdef CONFIG_EXT2_FS_XATTR
    	.setxattr	= generic_setxattr,
    	.getxattr	= generic_getxattr,
    	.listxattr	= ext2_listxattr,
    	.removexattr	= generic_removexattr,
    #endif
    	.setattr	= ext2_setattr,
    	.permission	= ext2_permission,
    };