深入理解Linux文件系统之文件系统挂载(下)

do_new_mount  //fs/namespace.c
->do_new_mount_fc
 ->     struct vfsmount *mnt;                      
    ->   struct mountpoint *mp;                     
 ->  struct super_block *sb = fc->root->d_sb;  //获得vfs的超级块 （之前已经构建好）
 >  mnt = vfs_create_mount(fc);   //为一个已配置的超级块 分配mount实例
    ->    mp = lock_mount(mountpoint);  //寻找挂载点 如果挂载目录是挂载点（已经有文件系统挂载其上），则将最后一次挂载的文件系统根目录作为挂载点    
 ->  do_add_mount(real_mount(mnt), mp, mountpoint, mnt_flags);  //关联挂载点 加入全局文件系统树
 

vfs_create_mount
    ->     mnt = alloc_vfsmnt(fc->source ?: "none");  //分配mount实例 
    ->     mnt->mnt.mnt_sb         = fc->root->d_sb;  //mount关联超级块 (使用vfsmount关联)
    ->    mnt->mnt.mnt_root       = dget(fc->root);   //mount关联根dentry (使用vfsmount关联)
    ->    mnt->mnt_mountpoint     = mnt->mnt.mnt_root; // mount关联挂载点 （临时指向根dentry，后面会指向真正的挂载点，以至于对用户可见）
    ->  mnt->mnt_parent         = mnt;  //父挂载指向自己 (临时指向 后面会设置)              
    ->     return &mnt->mnt;  //返回内嵌的vfsmount

//include/linux/path.h  描述一个路径
struct path { 
        struct vfsmount *mnt;
        struct dentry *dentry;
} __randomize_layout;

 //fs/mount.h       描述一个挂载点
struct mountpoint {       
        struct hlist_node m_hash; 
        struct dentry *m_dentry;  
        struct hlist_head m_list; 
        int m_count;              
};                                


static struct mountpoint *lock_mount(struct path *path)           
{                                                                 
        struct vfsmount *mnt;                                     
        struct dentry *dentry = path->dentry; //获得挂载目录的dentry                     
retry:                                                            
        inode_lock(dentry->d_inode);     //写方式申请 inode的读写信号量                        
        if (unlikely(cant_mount(dentry))) { //判断挂载目录能否被挂载
                inode_unlock(dentry->d_inode);                    
                return ERR_PTR(-ENOENT);                          
        }                                                         
        namespace_lock();  //写方式申请 命名空间读写信号量                                      
        mnt = lookup_mnt(path); //查找挂载在path上的第一个子mount    //！！！重点函数，后面分析 ！！！                               
        if (likely(!mnt)) { // mnt为空 说明没有文件系统挂载在这个path上  是我们要找的目标 
    
    //1.如果dentry之前是挂载点 则从mountpoint hash表 查找mountpoint （dentry计算hash）
    // 2. 如果dentry之前不是挂载点 分配mountpoint 加入mountpoint hash表（dentry计算hash）,设置dentry为挂载点
                struct mountpoint *mp = get_mountpoint(dentry); //！！！重点函数,后面会分析 ！！！
      
                if (IS_ERR(mp)) {                                 
                        namespace_unlock();                       
                        inode_unlock(dentry->d_inode);            
                        return mp;                                
                }                                                 
                return mp; //返回找到的挂载点实例 （这个挂载点的dentry之前没有被挂载）                                      
        }
        namespace_unlock(); //释放命名空间读写信号量
        inode_unlock(path->dentry->d_inode); //释放 inode的读写信号量 
        path_put(path);
        path->mnt = mnt; // path->mnt指向找到的vfsmount                                          
        dentry = path->dentry = dget(mnt->mnt_root); //path->dentry指向找到的vfsmount的根dentry！
        goto retry; //继续查找下一个挂载
}

static struct mountpoint *get_mountpoint(struct dentry *dentry)                      
{                                                                                    
        struct mountpoint *mp, *new = NULL;                                          
        int ret;                                                                     
                                                                                     
        if (d_mountpoint(dentry)) {  //dentry为挂载点 （当dentry为挂载点时 会设置dentry->d_flags 的DCACHE_MOUNTED标志）                                                
                /* might be worth a WARN_ON() */                                     
                if (d_unlinked(dentry))                                              
                        return ERR_PTR(-ENOENT);                                     
mountpoint:                                                                          
                read_seqlock_excl(&mount_lock);                                      
                mp = lookup_mountpoint(dentry); // 从mountpoint hash表 查找mountpoint （dentry计算hash）                                    
                read_sequnlock_excl(&mount_lock);                                    
                if (mp)                                                              
                        goto done;  //找到直接返回mountpoint实例                                               
        }                                                                            
                                                                                     
        if (!new)    //mountpoint哈希表中没有找到    则分配                                                             
                new = kmalloc(sizeof(struct mountpoint), GFP_KERNEL);             
        if (!new)                                                                    
                return ERR_PTR(-ENOMEM);                                             
                                                                                     
                                                                                     
        /* Exactly one processes may set d_mounted */                                
        ret = d_set_mounted(dentry);   //设置dentry为挂载点
   ->dentry->d_flags |= DCACHE_MOUNTED;  //设置挂载点标志很重要  路径名查找时发现为挂载点则会步进到相关文件系统的跟dentry
                                                                                     
        /* Someone else set d_mounted? */                                            
        if (ret == -EBUSY)                                                           
                goto mountpoint;                                                     
                                                                                     
        /* The dentry is not available as a mountpoint? */                           
        mp = ERR_PTR(ret);                                                           
        if (ret)                                                                     
                goto done;                                                           
                                                              
        /* Add the new mountpoint to the hash table */        
        read_seqlock_excl(&mount_lock);                       
        new->m_dentry = dget(dentry);  //设置mountpoint实例  的m_dentry 指向dentry                       
        new->m_count = 1;                                      
        hlist_add_head(&new->m_hash, mp_hash(dentry));   // mountpoint实例添加到 mountpoint_hashtable     
        INIT_HLIST_HEAD(&new->m_list);  //初始化 挂载链表   mount实例会加入到这个链表                      
        read_sequnlock_excl(&mount_lock);                     
                                                              
        mp = new;   //指向挂载点                                          
        new = NULL;                                           
done:                                                         
        kfree(new);                                           
        return mp;  //返回挂载点                                           
}                                                             

//fs/namespace.c
lookup_mnt(const struct path *path)
->  struct mount *child_mnt;
 struct vfsmount *m;     
 child_mnt = __lookup_mnt(path->mnt, path->dentry);  //委托__lookup_mnt
 m = child_mnt ? &child_mnt->mnt : NULL; //返回mount实例的vfsmount实例 或NULL            
 return m;

->
struct mount *__lookup_mnt(struct vfsmount *mnt, struct dentry *dentry)        
{               
        struct hlist_head *head = m_hash(mnt, dentry);  // 根据 父vfsmount实例 和 挂载点的dentry查找  mount_hashtable的一个哈希表项
        struct mount *p;
        
        hlist_for_each_entry_rcu(p, head, mnt_hash)  //从哈希表项对应的链表中查找   遍历链表的每个节点
                if (&p->mnt_parent->mnt == mnt && p->mnt_mountpoint == dentry) //节点的mount实例的父mount为mnt 且mount实例的挂载点为 dentry
                        return p; //找到返回mount实例
        return NULL;  //没找到返回NULL
}

do_add_mount  //添加mount到全局的文件系统挂载树中
->struct mount *parent = real_mount(path->mnt); //获得父挂载点的挂载实例
->graft_tree(newmnt, parent, mp)
 -> mnt_set_mountpoint(dest_mnt, dest_mp, source_mnt)
  ->   child_mnt->mnt_mountpoint = mp->m_dentry;   //关联子mount到挂载点的dentry                 
    child_mnt->mnt_parent = mnt; //子mount->mnt_parent指向父mount
    child_mnt->mnt_mp = mp; //子mount->mnt_mp指向挂载点
    hlist_add_head(&child_mnt->mnt_mp_list, &mp->m_list); //mount添加到挂载点链表

 ->commit_tree //提交挂载树
  ->__attach_mnt(mnt, parent)
   ->  hlist_add_head_rcu(&mnt->mnt_hash,
       ¦  m_hash(&parent->mnt, mnt->mnt_mountpoint));  //添加到mount hash表 ，通过父挂载点的vfsmount和挂载点的dentry作为索引(如上面示例中的<(3)的vfsmount , (3)的根dentry>)
    list_add_tail(&mnt->mnt_child, &parent->mnt_mounts);  //添加到父mount链表

//fs/namei.c 查找一个路径分量
walk_component  
->step_into
 ->handle_mounts
  ->traverse_mounts
   ->flags = smp_load_acquire(&path->dentry->d_flags); //获得dentry标志
   ->__traverse_mounts(path, flags, jumped, count, lookup_flags); //查找挂载点  返回不再是挂载点的path
     -> {
     
       while (flags & DCACHE_MANAGED_DENTRY) {    //找到的dentry是挂载点 则继续查找 ，不是则退出循环
        ...
        if (flags & DCACHE_MOUNTED) {   // something's mounted on it..  是挂载点 和上面lock_mount分析逻辑类似 
         //不断的查找挂载点  直到最后查找到的dentry不是挂载点 退出循环
         struct vfsmount *mounted = lookup_mnt(path);  //查找第一个子mount          
         if (mounted) {          // ... in our namespace         
           dput(path->dentry);                            
           if (need_mntput)
             mntput(path->mnt);
           path->mnt = mounted; //path->mnt赋值子mount
           path->dentry = dget(mounted->mnt_root); //path->dentry 赋值子mount的根dentry （是挂载点就会步进到挂载点的跟dentry）
           // here we know it's positive
           flags = path->dentry->d_flags; //获得dentry标志
           need_mntput = true;
           continue; //继续查找
        }
        ...

       }
       
       //最终返回找到的path（它不再是挂载点），后面继续查找下一个路径
      }