浅析proc文件系统的创建和create_proc_read_entry函数的具体实现-优快云博客

本文解析了sysfs文件系统的加载流程，详细介绍了kern_mount如何确保sysfs不论被mount多少次都只产生一个超级块，以及sysfs_fill_super如何初始化根目录。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

浅析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) ; }