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