follow_dotdot函数

stuman

1. static __always_inline void follow_dotdot(struct nameidata *nd)
   
2. {
   
3. struct fs_struct *fs = current->fs;
   
4. while(1) {
   
5. struct vfsmount *parent;
   
6. struct dentry *old = nd->path.dentry;
   
7.                 read_lock(&fs->lock);
   
8. if (nd->path.dentry == fs->root.dentry &&
   
9.    nd->path.mnt == fs->root.mnt) {
   
10.                         read_unlock(&fs->lock);
    
11. break;
    
12. }
    
13.                 read_unlock(&fs->lock);
    
14. spin_lock(&dcache_lock);
    
15. 
    
16. 
    
17. if (nd->path.dentry != nd->path.mnt->mnt_root) {//第2种情况
    
18. nd->path.dentry = dget(nd->path.dentry->d_parent);
    
19. spin_unlock(&dcache_lock);
    
20. dput(old);
    
21. break;
    
22. }
    
23. spin_unlock(&dcache_lock);
    
24. spin_lock(&vfsmount_lock);
    
25. 
    
26. parent = nd->path.mnt->mnt_parent;
    
27. if (parent == nd->path.mnt) {
    
28. spin_unlock(&vfsmount_lock);
    
29. break;
    
30. }
    
31. mntget(parent);
    
32. nd->path.dentry = dget(nd->path.mnt->mnt_mountpoint);//第3种情况
    
33. spin_unlock(&vfsmount_lock);
    
34. dput(old);
    
35. mntput(nd->path.mnt);
    
36. nd->path.mnt = parent;
    
37. }
    
38. follow_mount(&nd->path.mnt, &nd->path.dentry);
    
39. }

复制代码

现在假设原文件系统中有一目录a，其下有目录b，此时有一软盘，其中仅有一个目录c。那么把软盘挂载到目录b下，此时就有路径：a/b/c,当处于目录c中时，输入命令cd .. 就会返回到挂载点b中，这个过程很简单，但是在函数follow_dotdot中的执行过程却很让人费解。

假设在函数follow_dotdot中执行的是第2种情况，那么代码：
nd->path.dentry = dget(nd->path.dentry->d_parent);
会把当前目录置为软盘的根目录，显然不是挂载点b，如果说这行代码将当前目录置为挂载点，但是又没有进行vfsmount结构的改变，这个时候vfsmount结构应该要改为目录a所在文件系统的相应结构。

假设在函数follow_dotdot中执行的是第3种情况，当前目录被改为了挂载点，也进行了vfsmount结构的改变，但是此处代码没有break，执行完后会从新返回while循环，就会又进入第2种情况，这样就又向上走了一层，这个结果显然也不对。那么真正的执行过程是怎么样的呢？

stuman

没人回答吗，请高手帮帮忙呀

humjb_1983

stuman 发表于 2013-12-11 13:24
现在假设原文件系统中有一目录a，其下有目录b，此时有一软盘，其中仅有一个目录c。那么把软盘挂载到目录b下 ...

第二种情况，并不是“把当前目录置为软盘的根目录”，而是置为“父目录”，这种情况应该是指/a/b/c/d时，从d目录执行cd ..切换到c目录的情况。
第三种情况，应该是在如下两个地方之一退出循环：
if (nd->path.dentry == fs->root.dentry &&

   nd->path.mnt == fs->root.mnt) {

或
if (parent == nd->path.mnt) {

这里有点绕，可以加点打印确认下~~

鸟菜小

"现在假设原文件系统中有一目录a，其下有目录b，此时有一软盘，其中仅有一个目录c。那么把软盘挂载到目录b下，此时就有路径：a/b/c,当处于目录c中时，输入命令cd .. 就会返回到挂载点b中，这个过程很简单， ..."
-----------------------------------------------------------------
1， mount了一个文件系统到a/b，看到了a/b/c， 说明了c不是被挂文件系统的根，而是根的一个子目录，这一点很重要。所以在c中执行cd .. 并不需要切换mnt. 执行的是你所说的第2种情况。也就是说, 在b目录下ls, 查看的是软盘的根目录里面有哪些子目录，显然c是一子目录。在c中cd ..只是回到根目录，还在原来的mnt上。

2，在b中cd ..，这就要跨mnt了。因为b是一个挂载点，在b的dentry上是呆不住的，要follow down到软盘根目录的dentry上。也就是说在表面看是呆b中，实际上是当前的dentry实际上是软盘根目录的dentry, 在b中cd .. 就会进入第三种情况，先拿到b真正的dentry, 然后再循环一次，拿到b的dentry后dget(nd->path.dentry->d_parent)就到了a.

humjb_1983

回复 4# 鸟菜小
这位帅哥的说法很在理~


   

stuman

回复 4# 鸟菜小

看了你的回答，还是不太懂
1.在c中cd..只是回到根目录，但是在终端中执行之后应该回到b目录，这是个挂载点，应该和根目录不一样
2.在b中cd..，按你的说法应该是先向下走（不是follow_dotdot），然后再向上走，此时进入第3种情况，当前目录置位挂在点，然后进入第2种情况，置为挂载点的父目录，也就是a目录。这样的话，我感觉很多余呀，b本身就是挂载点，为什么要先向下后向上，重新设置一下挂载点呢？


   

embeddedlwp

回复 6# stuman

v3.14-rc2

1. static void follow_dotdot(struct nameidata *nd)
   
2. {
   
3.         set_root(nd);
   
4. 
   
5.         while(1) {
   
6.                 struct dentry *old = nd->path.dentry;
   
7. 
   
8.                 if (nd->path.dentry == nd->root.dentry &&
   
9.                     nd->path.mnt == nd->root.mnt) {
   
10.                         break;
    
11.                 }
    
12.                 if (nd->path.dentry != nd->path.mnt->mnt_root) {
    
13.                         /* rare case of legitimate dget_parent()... */
    
14.                         nd->path.dentry = dget_parent(nd->path.dentry);
    
15.                         dput(old);
    
16.                         break;
    
17.                 }
    
18.                 if (!follow_up(&nd->path))
    
19.                         break;
    
20.         }
    
21.         follow_mount(&nd->path);
    
22.         nd->inode = nd->path.dentry->d_inode;
    
23. }
    

复制代码

我的理解是:
1. 在c中cd ..,  由于nd->path.dentry == nd->path.mnt->mnt_root，执行follow_up，到了/a/b这里，然后再..到了/a
2. 在b中cd .., 由于nd->path.dentry != nd->path.mnt->mnt_root，执行 nd->path.dentry = dget_parent(nd->path.dentry), 这样到了/a