浅析proc文件系统的创建和create_proc_read_entry函数的具体实现
浅析kern_mount加载sysfs的流程
因为sysfs是一个内存文件系统, 所以文件的物理存储关系就需要使用sd来维护, 因此sysfs_dirent即sd就类似于硬盘中的磁道.
sysfs文件系统是一个排它式的文件系统, 不论被mount多少次都只产生一个sb超级块,
如果尝试再次mount,即尝试再次调用sysfs_get_sb获取另一个sb超级块,那么将执行atomic_inc(old->s_active);增加
已被mount的引用计数,然后如果s已经执行了alloc_super,那么调用destroy_super将其销毁,然后返回这个已被mount了的
super_block超级块old,这样就实现了sysfs文件系统 不论被mount多少次都只产生一个sb超级块的效果 ,所以取名为get_sb_single[luther.gliethttp]
start_kernel
= > vfs_caches_init
= > mnt_init
= > sysfs_init
sysfs_mount = kern_mount( & sysfs_fs_type) ;
static struct file_system_type sysfs_fs_type = {
. name = "sysfs" ,
. get_sb = sysfs_get_sb,
. kill_sb = kill_anon_super,
} ;
# define kern_mount( type) kern_mount_data( type, NULL )
# define MS_KERNMOUNT ( 1< < 22) /* this is a kern_mount call */
struct vfsmount * kern_mount_data( struct file_system_type * type, void * data)
{
return vfs_kern_mount( type, MS_KERNMOUNT, type- > name, data) ;
}
struct vfsmount *
vfs_kern_mount( struct file_system_type * type, int flags, const char * name, void * data)
{
struct vfsmount * mnt;
char * secdata = NULL ;
int error ;
if ( ! type)
return ERR_PTR( - ENODEV) ;
error = - ENOMEM;
mnt = alloc_vfsmnt( name) ; //获取一个mnt结构体,并做一些初始化工作
if ( ! mnt)
goto out;
if ( data & & ! ( type- > fs_flags & FS_BINARY_MOUNTDATA) ) {
secdata = alloc_secdata( ) ;
if ( ! secdata)
goto out_mnt;
error = security_sb_copy_data( data, secdata) ;
if ( error )
goto out_free_secdata;
}
//调用文件系统控制结构体的get_sb()方法,获取文件系统的超级块,这里就是sysfs_get_sb.
error = type- > get_sb( type, flags, name, data, mnt) ;
if ( error < 0)
goto out_free_secdata;
BUG_ON( ! mnt- > mnt_sb) ;
error = security_sb_kern_mount( mnt- > mnt_sb, secdata) ;
if ( error )
goto out_sb;
mnt- > mnt_mountpoint = mnt- > mnt_root; //mount点就是sysfs的'/'根目录项
mnt- > mnt_parent = mnt; //指向自己
up_write( & mnt- > mnt_sb- > s_umount) ;
free_secdata( secdata) ;
return mnt; //成功完成mnt的创建和sb超级块等信息的填充[luther.gliethttp]
out_sb:
dput( mnt- > mnt_root) ;
up_write( & mnt- > mnt_sb- > s_umount) ;
deactivate_super( mnt- > mnt_sb) ;
out_free_secdata:
free_secdata( secdata) ;
out_mnt:
free_vfsmnt( mnt) ;
out:
return ERR_PTR( error ) ;
}
struct vfsmount * alloc_vfsmnt( const char * name)
{
struct vfsmount * mnt = kmem_cache_zalloc( mnt_cache, GFP_KERNEL) ; //从cache上摘一个slab空闲对象
if ( mnt) {
//成功获取mnt内存空间,初始化之[luther.gliethttp]
atomic_set( & mnt- > mnt_count, 1) ;
INIT_LIST_HEAD( & mnt- > mnt_hash) ;
INIT_LIST_HEAD( & mnt- > mnt_child) ;
INIT_LIST_HEAD( & mnt- > mnt_mounts) ;
INIT_LIST_HEAD( & mnt- > mnt_list) ;
INIT_LIST_HEAD( & mnt- > mnt_expire) ;
INIT_LIST_HEAD( & mnt- > mnt_share) ;
INIT_LIST_HEAD( & mnt- > mnt_slave_list) ;
INIT_LIST_HEAD( & mnt- > mnt_slave) ;
if ( name) {
int size = strlen ( name) + 1;
char * newname = kmalloc( size, GFP_KERNEL) ;
if ( newname) {
memcpy ( newname, name, size) ;
mnt- > mnt_devname = newname; //比如: "sysfs"
}
}
}
return mnt;
}
//sysfs文件系统是一个排它式的文件系统,不论被mount多少次都只产生一个sb超级块,
//如果尝试再次mount,即尝试再次调用sysfs_get_sb获取另一个sb超级块,那么将执行atomic_inc(old->s_active);增加
//已被mount的引用计数,然后如果s已经执行了alloc_super,那么调用destroy_super将其销毁,然后返回这个已被mount了的
//super_block超级块old, 这样就实现了sysfs文件系统 不论被mount多少次都只产生一个sb超级块的效果 ,所以取名为get_sb_single[luther.gliethttp]
static int sysfs_get_sb( struct file_system_type * fs_type,
int flags, const char * dev_name, void * data, struct vfsmount * mnt)
{
return get_sb_single( fs_type, flags, data, sysfs_fill_super, mnt) ;
}
int get_sb_single( struct file_system_type * fs_type,
int flags, void * data,
int ( * fill_super) ( struct super_block * , void * , int ) ,
struct vfsmount * mnt)
{
struct super_block * s;
int error ;
s = sget( fs_type, compare_single, set_anon_super, NULL ) ; //获取超级块,如果之前已经创建了sb,那么这里将不再创建,将返回上一次创建的sb,所以这表明sb超级块将只被生成1个 [luther.gliethttp]
if ( IS_ERR( s) )
return PTR_ERR( s) ;
if ( ! s- > s_root) {
//如果是第一次mount该sysfs文件系统,那么首先填充sb超级块
s- > s_flags = flags;
error = fill_super( s, data, flags & MS_SILENT ? 1 : 0) ; //这里对应sysfs_fill_super函数,细化sb超级块
if ( error ) {
up_write( & s- > s_umount) ;
deactivate_super( s) ;
return error ;
}
s- > s_flags | = MS_ACTIVE;
}
do_remount_sb( s, flags, data, 0) ; //asks filesystem to change mount options,在sysfs中sysfs_ops没有实现remount_fs
return simple_set_mnt( mnt, s) ; //将s超级块安装到mnt这个mount节点上
}
int simple_set_mnt( struct vfsmount * mnt, struct super_block * sb)
{
mnt- > mnt_sb = sb; //mnt的sb
mnt- > mnt_root = dget( sb- > s_root) ; //对应的根目录项
return 0;
}
static int compare_single( struct super_block * s, void * p)
{
return 1;
}
struct super_block * sget( struct file_system_type * type,
int ( * test ) ( struct super_block * , void * ) ,
int ( * set ) ( struct super_block * , void * ) ,
void * data)
{
struct super_block * s = NULL ;
struct super_block * old;
int err;
retry:
spin_lock( & sb_lock) ;
if ( test ) {
list_for_each_entry( old, & type- > fs_supers, s_instances) {
//sysfs文件系统是一个排它式的文件系统, 不论被mount多少次都只产生一个sb超级块,
//如果尝试再次mount,即尝试再次调用sysfs_get_sb获取另一个sb超级块,那么将执行atomic_inc(old->s_active);增加
//已被mount的引用计数,然后如果s已经执行了alloc_super,那么调用destroy_super将其销毁,然后返回这个已被mount了的
//super_block超级块old, 这样就实现了sysfs文件系统 不论被mount多少次都只产生一个sb超级块的效果 ,所以取名为get_sb_single[luther.gliethttp]
if ( ! test ( old, data) ) //compare_single一直返回1
continue ;
if ( ! grab_super( old) )
goto retry;
if ( s)
destroy_super( s) ;
return old;
}
}
if ( ! s) {
//没有找到
spin_unlock( & sb_lock) ;
s = alloc_super( type) ; //获取一个sb超级块的控制内存,同时做部分结构初始化
if ( ! s)
return ERR_PTR( - ENOMEM) ;
goto retry; //继续尝试一次,看看是否重复了
}
err = set ( s, data) ; //sysfs对应set_anon_super,获取一个sb超级块的设备号,major为0
if ( err) {
spin_unlock( & sb_lock) ;
destroy_super( s) ;
return ERR_PTR( err) ;
}
s- > s_type = type; //填充该sb超级块的type
strlcpy( s- > s_id, type- > name, sizeof ( s- > s_id) ) ; //该sb超级块的s_id为type->name,比如:"sysfs"
list_add_tail( & s- > s_list, & super_blocks) ; //将该超级块添加到全局超级块链表super_blocks上
list_add( & s- > s_instances, & type- > fs_supers) ; //sb超级块将自己添加到type->fs_supers管理链表上
spin_unlock( & sb_lock) ;
get_filesystem( type) ; //
return s;
}
//type->fs_supers链表上挂上了有效的sb超级块之后,才会执行到这里
static int grab_super( struct super_block * s) __releases( sb_lock)
{
s- > s_count+ + ; / / alloc_super 时将设置 s->s_count = S_BIAS;
spin_unlock( & sb_lock) ;
down_write( & s- > s_umount) ;
if ( s- > s_root) {
spin_lock( & sb_lock) ;
if ( s- > s_count > S_BIAS) {
atomic_inc( & s- > s_active) ;
s- > s_count- - ;
spin_unlock( & sb_lock) ;
return 1; //确实有一个有效的sb超级块对应的s_root目录项,那么返回1,然后由destroy_super将其销毁
}
spin_unlock( & sb_lock) ;
}
up_write( & s- > s_umount) ;
put_super( s) ;
yield( ) ;
return 0;
}
//获取一个sb超级块的控制内存,同时做部分结构初始化
static struct super_block * alloc_super( struct file_system_type * type)
{
struct super_block * s = kzalloc( sizeof ( struct super_block) , GFP_USER) ;
static struct super_operations default_op;
if ( s) {
if ( security_sb_alloc( s) ) {
kfree( s) ;
s = NULL ;
goto out;
}
INIT_LIST_HEAD( & s- > s_dirty) ;
INIT_LIST_HEAD( & s- > s_io) ;
INIT_LIST_HEAD( & s- > s_more_io) ;
INIT_LIST_HEAD( & s- > s_files) ;
INIT_LIST_HEAD( & s- > s_instances) ;
INIT_HLIST_HEAD( & s- > s_anon) ;
INIT_LIST_HEAD( & s- > s_inodes) ;
init_rwsem( & s- > s_umount) ;
mutex_init( & s- > s_lock) ;
lockdep_set_class( & s- > s_umount, & type- > s_umount_key) ;
/*
* The locking rules for s_lock are up to the
* filesystem. For example ext3fs has different
* lock ordering than usbfs:
*/
lockdep_set_class( & s- > s_lock, & type- > s_lock_key) ;
down_write( & s- > s_umount) ;
s- > s_count = S_BIAS;
atomic_set( & s- > s_active, 1) ;
mutex_init( & s- > s_vfs_rename_mutex) ;
mutex_init( & s- > s_dquot. dqio_mutex) ;
mutex_init( & s- > s_dquot. dqonoff_mutex) ;
init_rwsem( & s- > s_dquot. dqptr_sem) ;
init_waitqueue_head( & s- > s_wait_unfrozen) ;
s- > s_maxbytes = MAX_NON_LFS;
s- > dq_op = sb_dquot_ops;
s- > s_qcop = sb_quotactl_ops;
s- > s_op = & default_op;
s- > s_time_gran = 1000000000;
}
out:
return s;
}
int set_anon_super( struct super_block * s, void * data)
{
int dev;
int error ;
retry:
if ( idr_pre_get( & unnamed_dev_idr, GFP_ATOMIC) = = 0)
return - ENOMEM;
spin_lock( & unnamed_dev_lock) ;
error = idr_get_new( & unnamed_dev_idr, NULL , & dev) ; //从radix树中,递增式的获取一个唯一整数值到&dev
spin_unlock( & unnamed_dev_lock) ;
if ( error = = - EAGAIN)
/* We raced and lost with another CPU. */
goto retry;
else if ( error )
return - EAGAIN;
if ( ( dev & MAX_ID_MASK) = = ( 1 < < MINORBITS) ) {
spin_lock( & unnamed_dev_lock) ;
idr_remove( & unnamed_dev_idr, dev) ;
spin_unlock( & unnamed_dev_lock) ;
return - EMFILE;
}
s- > s_dev = MKDEV( 0, dev & MINORMASK) ; //生成major为0的超级块设备号
return 0;
}
//给申请的sb超级块填充细化数据
static int sysfs_fill_super( struct super_block * sb, void * data, int silent)
{
struct inode * inode;
struct dentry * root;
sb- > s_blocksize = PAGE_CACHE_SIZE; //块大小4k
sb- > s_blocksize_bits = PAGE_CACHE_SHIFT; //12
sb- > s_magic = SYSFS_MAGIC; //magic代号
sb- > s_op = & sysfs_ops; //超级块操作函数集
sb- > s_time_gran = 1;
sysfs_sb = sb; //保存
/* get root inode, initialize and unlock it */
inode = sysfs_get_inode( & sysfs_root) ; //生成sysfs_root中所定义要求的inode内存节点
if ( ! inode) {
pr_debug( "sysfs: could not get root inode/n" ) ;
return - ENOMEM;
}
/* instantiate and link root dentry */
root = d_alloc_root( inode) ; //将inode安装到'/'根目录项上
if ( ! root) {
pr_debug( "%s: could not get root dentry!/n" , __FUNCTION__ ) ;
iput( inode) ;
return - ENOMEM;
}
root- > d_fsdata = & sysfs_root; //根目录项的文件系统数据fsdata指向sysfs_root
sb- > s_root = root; //填充sb超级块对应的根目录项
return 0;
}
struct sysfs_dirent sysfs_root = {
. s_name = "" , //0空
. s_count = ATOMIC_INIT( 1) ,
. s_flags = SYSFS_DIR, //目录
. s_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO,
. s_ino = 1, //节点号搞为1
} ;
struct inode * sysfs_get_inode( struct sysfs_dirent * sd)
{
struct inode * inode;
inode = iget_locked( sysfs_sb, sd- > s_ino) ;
if ( inode & & ( inode- > i_state & I_NEW) )
sysfs_init_inode( sd, inode) ; //这是一个新创建的inode节点,那么调用sysfs对它进一步做符合sysfs要求的初始化[luther.gliethttp]
return inode;
}
//对新创建的inode节点,进行sysfs特性格式化[luther.gliethttp]
static void sysfs_init_inode( struct sysfs_dirent * sd, struct inode * inode)
{
struct bin_attribute * bin_attr;
inode- > i_blocks = 0;
inode- > i_mapping- > a_ops = & sysfs_aops;
inode- > i_mapping- > backing_dev_info = & sysfs_backing_dev_info;
inode- > i_op = & sysfs_inode_operations; //更改inode的方法集
/*
static const struct inode_operations sysfs_inode_operations ={
.setattr = sysfs_setattr,
};
*/
inode- > i_ino = sd- > s_ino; //inode的节点号要和sd->s_ino目录项节点号一致
//★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
自此
sysfs_fill_super= > sysfs_sb = sb; //保存
sysfs_create_dir
= > parent_sd = & sysfs_root;
sysfs_addrm_start
inode = ilookup5_nowait( sysfs_sb, parent_sd- > s_ino, sysfs_ilookup_test, parent_sd) ;
= > 就能够找到sysfs_root对应的inode节点了, 所以
start_kernel
= > vfs_caches_init
= > mnt_init
= > sysfs_init执行完之后, driver们也就能够在稍后的时候顺利使用sysfs文件系统进行文件创建了.
start_kernel
= > rest_init
= > kernel_thread( kernel_init, NULL , CLONE_FS | CLONE_SIGHAND) ;
kernel_init
= > do_basic_setup
= > driver_init会创建如下：
/ sys/ devices
/ sys/ bus
/ sys/ class
/ sys/ firmware
等sysfs目录和文件
然后do_basic_setup继续调用
= > do_initcalls
调用所有build in到kernel中的module_init驱动程序,
所以这时的驱动程序就可以自由使用sysfs以及上面创建的那些sysfs文件系统下的目录和文件了[ luther.gliethttp]
void __init driver_init( void )
{
/* These are the core pieces */
devices_init( ) ;
buses_init( ) ;
classes_init( ) ;
firmware_init( ) ;
hypervisor_init( ) ;
/* These are also core pieces, but must come after the
* core core pieces.
*/
platform_bus_init( ) ;
system_bus_init( ) ;
cpu_dev_init( ) ;
memory_dev_init( ) ;
}
//★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
lockdep_set_class( & inode- > i_mutex, & sysfs_inode_imutex_key) ;
if ( sd- > s_iattr) {
/* sysfs_dirent has non-default attributes
* get them for the new inode from persistent copy
* in sysfs_dirent
*/
set_inode_attr( inode, sd- > s_iattr) ;
} else
set_default_inode_attr( inode, sd- > s_mode) ; //设备inode默认attr属性们
/* initialize inode according to type */
switch ( sysfs_type( sd) ) { //根据sd目录项信息,来反向订制该inode节点的fops等操作函数集[luther.gliethttp]
case SYSFS_DIR:
inode- > i_op = & sysfs_dir_inode_operations;
inode- > i_fop = & sysfs_dir_operations; //dir目录的fops操作函数集
inode- > i_nlink = sysfs_count_nlink( sd) ;
break ;
case SYSFS_KOBJ_ATTR:
inode- > i_size = PAGE_SIZE;
inode- > i_fop = & sysfs_file_operations; //attr属性文件的fops操作函数集
break ;
case SYSFS_KOBJ_BIN_ATTR:
bin_attr = sd- > s_bin_attr. bin_attr; //bin_attr属性文件的fops操作函数集
inode- > i_size = bin_attr- > size;
inode- > i_fop = & bin_fops;
break ;
case SYSFS_KOBJ_LINK:
inode- > i_op = & sysfs_symlink_inode_operations; //link文件的fops操作函数集
break ;
default :
BUG( ) ;
}
unlock_new_inode( inode) ;
}
static inline void set_default_inode_attr( struct inode * inode, mode_t mode)
{
inode- > i_mode = mode;
inode- > i_uid = 0;
inode- > i_gid = 0;
inode- > i_atime = inode- > i_mtime = inode- > i_ctime = CURRENT_TIME;
}
struct inode * iget_locked( struct super_block * sb, unsigned long ino)
{
struct hlist_head * head = inode_hashtable + hash( sb, ino) ;
struct inode * inode;
inode = ifind_fast( sb, head, ino) ;
if ( inode) //第一次的话,肯定inode=NULL;
return inode;
/*
* get_new_inode_fast() will do the right thing, re-trying the search
* in case it had to block at any point.
*/
return get_new_inode_fast( sb, head, ino) ; //为root获取一个inode存储结构体,对于sysfs就是获取一个内存空间
//对于ext3和yaffs2文件系统就是申请flash或者硬盘上的物理空间了[luther.gliethttp].
}
static struct inode * get_new_inode_fast( struct super_block * sb, struct hlist_head * head,unsigned long ino)
{
struct inode * inode;
inode = alloc_inode( sb) ; //从sb超级块上获取一个新的inode
if ( inode) {
struct inode * old;
spin_lock( & inode_lock) ; //锁住
/* We released the lock, so.. */
old = find_inode_fast( sb, head, ino) ; //可能他人已经创建完成了,所以再查一遍
if ( ! old) {
//确实ino节点号仍然没有被创建,那么我们可以安全的将inode作为ino节点号对应的inode了[luther.gliethttp]
inode- > i_ino = ino; //节点对应的节点号
inodes_stat. nr_inodes+ + ;
list_add( & inode- > i_list, & inode_in_use) ; //挂到全局量inode_in_use链表上
list_add( & inode- > i_sb_list, & sb- > s_inodes) ; //挂到超级块的s_inodes链表上
hlist_add_head( & inode- > i_hash, head) ; //将inode添加到所有节点都挂接到的hash数组inode_hashtable中.
inode- > i_state = I_LOCK| I_NEW; //标记该inode为新建节点
spin_unlock( & inode_lock) ; //解锁
/* Return the locked inode with I_NEW set, the
* caller is responsible for filling in the contents
*/
return inode; //返回这个新生成的inode节点
}
/*
* Uhhuh, somebody else created the same inode under
* us. Use the old inode instead of the one we just
* allocated.
*/
//很不走运,该ino对应的inode节点别人已经在你上边某一步时,提前搞定了,所以我们需要把刚才申请的咚咚释放掉[luther.gliethttp]
__iget( old) ;
spin_unlock( & inode_lock) ;
destroy_inode( inode) ; //销毁前面申请的inode节点,因为别人已经成功添加了.
inode = old;
wait_on_inode( inode) ;
}
return inode; //inode=NULL
}
static const struct super_operations sysfs_ops = {
. statfs = simple_statfs,
. drop_inode = generic_delete_inode,
} ;
sb- > s_op = & sysfs_ops; //超级块操作函数集
static struct inode * alloc_inode( struct super_block * sb)
{
static const struct address_space_operations empty_aops;
static struct inode_operations empty_iops;
static const struct file_operations empty_fops;
struct inode * inode;
if ( sb- > s_op- > alloc_inode) //该sb超级块提供自定义,特殊的alloc_inode函数,对于sysfs没有提供专门的函数[luther.gliethttp]
inode = sb- > s_op- > alloc_inode( sb) ;
else
inode = ( struct inode * ) kmem_cache_alloc( inode_cachep, GFP_KERNEL) ; //所以从cache中获取一个空闲染色的slab对象
if ( inode) {
//细化inode的部分结单元
struct address_space * const mapping = & inode- > i_data;
inode- > i_sb = sb;
inode- > i_blkbits = sb- > s_blocksize_bits;
inode- > i_flags = 0;
atomic_set( & inode- > i_count, 1) ;
inode- > i_op = & empty_iops;
inode- > i_fop = & empty_fops;
inode- > i_nlink = 1;
atomic_set( & inode- > i_writecount, 0) ;
inode- > i_size = 0;
inode- > i_blocks = 0;
inode- > i_bytes = 0;
inode- > i_generation = 0;
# ifdef CONFIG_QUOTA
memset ( & inode- > i_dquot, 0, sizeof ( inode- > i_dquot) ) ;
# endif
inode- > i_pipe = NULL ;
inode- > i_bdev = NULL ;
inode- > i_cdev = NULL ;
inode- > i_rdev = 0;
inode- > dirtied_when = 0;
if ( security_inode_alloc( inode) ) {
if ( inode- > i_sb- > s_op- > destroy_inode)
inode- > i_sb- > s_op- > destroy_inode( inode) ;
else
kmem_cache_free( inode_cachep, ( inode) ) ;
return NULL ;
}
spin_lock_init( & inode- > i_lock) ;
lockdep_set_class( & inode- > i_lock, & sb- > s_type- > i_lock_key) ;
mutex_init( & inode- > i_mutex) ;
lockdep_set_class( & inode- > i_mutex, & sb- > s_type- > i_mutex_key) ;
init_rwsem( & inode- > i_alloc_sem) ;
lockdep_set_class( & inode- > i_alloc_sem, & sb- > s_type- > i_alloc_sem_key) ;
mapping- > a_ops = & empty_aops;
mapping- > host = inode;
mapping- > flags = 0;
mapping_set_gfp_mask( mapping, GFP_HIGHUSER_PAGECACHE) ;
mapping- > assoc_mapping = NULL ;
mapping- > backing_dev_info = & default_backing_dev_info;
/*
* If the block_device provides a backing_dev_info for client
* inodes then use that. Otherwise the inode share the bdev's
* backing_dev_info.
*/
if ( sb- > s_bdev) {
struct backing_dev_info * bdi;
bdi = sb- > s_bdev- > bd_inode_backing_dev_info;
if ( ! bdi)
bdi = sb- > s_bdev- > bd_inode- > i_mapping- > backing_dev_info;
mapping- > backing_dev_info = bdi;
}
inode- > i_private = NULL ;
inode- > i_mapping = mapping;
}
return inode;
}
struct dentry * d_alloc_root( struct inode * root_inode)
{
struct dentry * res = NULL ;
if ( root_inode) {
static const struct qstr name = { . name = "/" , . len = 1 } ;
res = d_alloc( NULL , & name) ; //申请一个根目录项,调用dentry = kmem_cache_alloc(dentry_cache, GFP_KERNEL);
if ( res) {
res- > d_sb = root_inode- > i_sb; //根目录项的超级块
res- > d_parent = res; //自己指向自己
d_instantiate( res, root_inode) ; //将inode安装到根目录项上
}
}
return res;
}
void d_instantiate( struct dentry * entry, struct inode * inode)
{
BUG_ON( ! list_empty( & entry- > d_alias) ) ;
spin_lock( & dcache_lock) ;
if ( inode)
list_add( & entry- > d_alias, & inode- > i_dentry) ; //将目录向链接到inode上,所以一个inode可以有多个目录项指向,
//这些目录项可以通过扫描inode->i_dentry链表获得
entry- > d_inode = inode; //目录项对应的所管理的inode节点
fsnotify_d_instantiate( entry, inode) ;
spin_unlock( & dcache_lock) ;
security_d_instantiate( entry, inode) ;
}