Linux虚拟文件系统（节点路径搜索）


前面（见  ）对linux虚拟文件系统的架构以及设计到的数据结构有了一个整体的认识，这里看看linux内核怎么根据给定的文件路径名在内存中找到和建立代表着目标文件或目录的dentry结构和inode结构。文件路径的搜索是文件系统中最基本也是最重要的一部分之一，后面我们会看到，文件的打开、关闭等等操作都将涉及到文件路径的搜索。下面我们看看linux内核中时怎么实现的。

一、搜索中所用数据结构

[cpp]
  1. /*这个数据结构是临时的，只在路径搜索的过程中返回搜索的结果。 
  2. */  
  3. struct nameidata {  
  4.     struct path path;/*将目录结构和mount结构封装在path结构中*/  
  5.     struct qstr last;  
  6.     struct path root;  
  7.     unsigned int    flags;/*对应搜索的标志*/  
  8.     int     last_type;  
  9.     unsigned    depth;  
  10.     char *saved_names[MAX_NESTED_LINKS + 1];  
  11.   
  12.     /* Intent data */  
  13.     union {  
  14.         struct open_intent open;  
  15.     } intent;  
  16. };  
[cpp]
  1. /*用来存放路径名中当前节点的杂凑值以及节点名的长度*/  
  2. struct qstr {  
  3.     unsigned int hash;  
  4.     unsigned int len;  
  5.     const unsigned char *name;  
  6. };  

二、搜索

[cpp]
  1. /*name指向在用户空间的路径名; 
  2. flag为一些标志位，nd为搜索返回值 
  3. */  
  4. int path_lookup(const char *name, unsigned int flags,  
  5.             struct nameidata *nd)  
  6. {  
  7.     return do_path_lookup(AT_FDCWD, name, flags, nd);  
  8. }  

实际工作都是由上面的do_path_lookup()函数实现的，在这里我们就他进行分析。

[cpp]
  1. /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */  
  2. static int do_path_lookup(int dfd, const char *name,  
  3.                 unsigned int flags, struct nameidata *nd)  
  4. {   /*找到搜索的起点，保存在nd中*/  
  5.     int retval = path_init(dfd, name, flags, nd);  
  6.     if (!retval)  
  7.             /*一旦找到了搜索的起点，从起点开始路径的搜索 
  8.         其中nd用来返回搜索结果*/  
  9.         retval = path_walk(name, nd);  
  10.     if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry &&  
  11.                 nd->path.dentry->d_inode))  
  12.         audit_inode(name, nd->path.dentry);  
  13.     if (nd->root.mnt) {  
  14.         path_put(&nd->root);  
  15.         nd->root.mnt = NULL;  
  16.     }  
  17.     return retval;  
  18. }  

2.1 初始化阶段

初始化阶段是由函数path_init()函数实现

[cpp]
  1. /*path_init主要是初始化查询，设置nd结构指向查询开始处的文件，这里分两种情况： 
  2.     a，绝对路径(以／开始)，获得根目录的dentry。它存储在task_struct中fs指向的fs_struct结构中。 
  3.     b，相对路径，直接从当前进程task_struct结构中的获得指针fs，它指向的一个fs_struct， 
  4.     fs_struct中有一个指向“当前工作目录”的dentry。 
  5. */  
  6. static int path_init(int dfd, const char *name, unsigned int flags, struct nameidata *nd)  
  7. {  
  8.     int retval = 0;  
  9.     int fput_needed;  
  10.     struct file *file;  
  11.     /*在搜索的过程中，这个字段的值会随着路径名当前搜索结果而变； 
  12.     例如，如果成功找到目标文件，那么这个字段的值就变成了LAST_NORM 
  13.     而如果最后停留在了一个.上，则变成LAST_DOT(*/  
  14.     nd->last_type = LAST_ROOT; /* if there are only slashes... */  
  15.     nd->flags = flags;  
  16.     nd->depth = 0;  
  17.     nd->root.mnt = NULL;  
  18.   
  19.     if (*name=='/') {/*路径名以'/'开头*/  
  20.         set_root(nd);/*设置nd的root为当前进程fs的root*/  
  21.         nd->path = nd->root;/*保存根目录*/  
  22.         path_get(&nd->root);/*递增引用计数*/  
  23.     } else if (dfd == AT_FDCWD) {/*相对路径*/  
  24.         struct fs_struct *fs = current->fs;  
  25.         read_lock(&fs->lock);  
  26.         nd->path = fs->pwd;/*保存当前路径*/  
  27.         path_get(&fs->pwd);/*递增引用计数*/  
  28.         read_unlock(&fs->lock);  
  29.     } else {/*???*/  
  30.         struct dentry *dentry;  
  31.          /*fget_light在当前进程的struct files_struct中根据所谓的用户空间 
  32.         文件描述符fd来获取文件描述符。另外，根据当前fs_struct 
  33.         是否被多各进程共享来判断是否需要对文件描述符进行加 
  34.          锁，并将加锁结果存到一个int中返回 
  35.         */  
  36.         file = fget_light(dfd, &fput_needed);  
  37.         retval = -EBADF;  
  38.         if (!file)  
  39.             goto out_fail;  
  40.   
  41.         dentry = file->f_path.dentry;  
  42.   
  43.         retval = -ENOTDIR;  
  44.         if (!S_ISDIR(dentry->d_inode->i_mode))  
  45.             goto fput_fail;  
  46.         /*权限检查*/  
  47.         retval = file_permission(file, MAY_EXEC);  
  48.         if (retval)  
  49.             goto fput_fail;  
  50.         /*获得path*/  
  51.         nd->path = file->f_path;  
  52.         path_get(&file->f_path);  
  53.         /*解锁*/  
  54.         fput_light(file, fput_needed);  
  55.     }  
  56.     return 0;  
  57.   
  58. fput_fail:  
  59.     fput_light(file, fput_needed);  
  60. out_fail:  
  61.     return retval;  
  62. }  

2.2 实际搜索操作

[cpp]
  1. static int path_walk(const char *name, struct nameidata *nd)  
  2. {  
  3.     current->total_link_count = 0;  
  4.     return link_path_walk(name, nd);  
  5. }  
[cpp]
  1. /* 
  2.  * Wrapper to retry pathname resolution whenever the underlying 
  3.  * file system returns an ESTALE. 
  4.  * 
  5.  * Retry the whole path once, forcing real lookup requests 
  6.  * instead of relying on the dcache. 
  7.  */  
  8. static __always_inline int link_path_walk(const char *name, struct nameidata *nd)  
  9. {  
  10.     struct path save = nd->path;  
  11.     int result;  
  12.   
  13.     /* make sure the stuff we saved doesn't go away */  
  14.     path_get(&save);/*递增path的引用计数*/  
  15.     /*实际的工作*/  
  16.     result = __link_path_walk(name, nd);  
  17.     if (result == -ESTALE) {  
  18.         /* nd->path had been dropped */  
  19.         nd->path = save;  
  20.         path_get(&nd->path);  
  21.         nd->flags |= LOOKUP_REVAL;  
  22.         result = __link_path_walk(name, nd);  
  23.     }  
  24.   
  25.     path_put(&save);  
  26.   
  27.     return result;  
  28. }  
[cpp]
  1. /* 
  2.  * Name resolution. 
  3.  * This is the basic name resolution function, turning a pathname into 
  4.  * the final dentry. We expect 'base' to be positive and a directory. 
  5.  * 
  6.  * Returns 0 and nd will have valid dentry and mnt on success. 
  7.  * Returns error and drops reference to input namei data on failure. 
  8.  */  
  9. static int __link_path_walk(const char *name, struct nameidata *nd)  
  10. {  
  11.     struct path next;  
  12.     struct inode *inode;  
  13.     int err;  
  14.     unsigned int lookup_flags = nd->flags;  
  15.     /*如果路径名以'/'开头，就把他跳过去，因为在这种情况下nd中 
  16.     path已经指向本进程的根目录了，注意，这里多个连续的'/'与一个 
  17.     ‘/’是等价的，如果路径名中仅仅包含有'/'字符的话，那么其 
  18.     目标就是根目录，所以任务完成，不然需要继续搜索*/  
  19.     while (*name=='/')  
  20.         name++;  
  21.     if (!*name)  
  22.         goto return_reval;  
  23.     /*作为path_walk起点的节点必定是一个目录，一定有相应的索引节点 
  24.     存在，所以指针inode一定是有效的，而不可能是空指针*/  
  25.     inode = nd->path.dentry->d_inode;  
  26.     /*进程的task_struct结构中有个计数器link_count.在搜索过程中有可能 
  27.     碰到一个节点(目录项)只是指向另一个节点的链接，此时就用这个计数器来对 
  28.     链的长度进行计数，这样，当链的长度达到某一个值时就可以终止搜索而失败 
  29.     返回，以防陷入循环。另一方面，当顺着符号链接进入另一个设备上的文件系统 
  30.     时，有可能会递归地调用path_walk。所以，进入path_walk后，如果发现这个 
  31.     计数器值非0，就表示正在顺着符号链接递归调用path_walk往前搜索过程中， 
  32.     此时不管怎样都把LOOKUP_FOLLOW标志位设成1.*/  
  33.     if (nd->depth)  
  34.         lookup_flags = LOOKUP_FOLLOW | (nd->flags & LOOKUP_CONTINUE);  
  35.   
  36.     /* At this point we know we have a real path component. */  
  37.     for(;;) {  
  38.         unsigned long hash;  
  39.           
  40.         struct qstr this;  
  41.         unsigned int c;  
  42.   
  43.         nd->flags |= LOOKUP_CONTINUE;  
  44.         /*检查当前进程对当前节点的访问权限，这里所检查的是相对路径中 
  45.         的各层目录(而不是目标文件)的访问权限。注意，对于中间节点所需 
  46.         的权限为执行权，即MAY_EXEC*/  
  47.              err = exec_permission_lite(inode);  
  48.         if (err)  
  49.             break;  
  50.   
  51.         this.name = name;  
  52.         c = *(const unsigned char *)name;  
  53.   
  54.         hash = init_name_hash();  
  55.         do {  
  56.             name++;  
  57.             hash = partial_name_hash(c, hash);  
  58.             c = *(const unsigned char *)name;  
  59.         } while (c && (c != '/'));/*路径名中的节点定以‘/’字符分开的，*/  
  60.         this.len = name - (const char *) this.name;  
  61.         this.hash = end_name_hash(hash);  
  62.   
  63.         /* remove trailing slashes? */  
  64.         if (!c)/*最后一个字符为'\0',就是说当前节点已经是路径名中的最后一节*/  
  65.             goto last_component;/*跳转*/  
  66.         /*循环跳过'/'*/  
  67.         while (*++name == '/');  
  68.         /*当前节点实际上已经是路径名的最后一个节点，只不过在此后面又多添加了 
  69.         若干个'/'字符，这种情况常常发生在用户界面上，特别是在shell的命令中 
  70.         当然这种情况要求最后的节点必须是个目录*/  
  71.         if (!*name)  
  72.             goto last_with_slashes;/*跳转*/  
  73.   
  74.             /*运行到这里，表示当前节点为中间节点，所以'/'字符后面还有其他字符*/  
  75.         /* 
  76.          * "." and ".." are special - ".." especially so because it has 
  77.          * to be able to know about the current root directory and 
  78.          * parent relationships. 
  79.          */  
  80.          /*以'.'开头表示这是个隐藏的文件，而对于代表着目录的节点则只有在两种 
  81.          情况下才是允许的。一种是节点名为'.',表示当前目录，另一种是'..',表示 
  82.          当前目录的父目录*/  
  83.         if (this.name[0] == '.') switch (this.len) {  
  84.             default:  
  85.                 break;  
  86.             case 2:   
  87.                 if (this.name[1] != '.')  
  88.                     break;  
  89.                 follow_dotdot(nd);/*为'..'，到父目录中去*/  
  90.                 inode = nd->path.dentry->d_inode;  
  91.                 /* fallthrough */  
  92.             /*2中没有break语句，也就是所继续执行1中的语句， 
  93.             将会跳到for语句的开头处理路径中的下一个节点*/  
  94.             case 1:  
  95.                 continue;  
  96.         }  
  97.         /* 
  98.          * See if the low-level filesystem might want 
  99.          * to use its own hash.. 
  100.          */  
  101.          /*特定文件系统提供他自己专用的杂凑函数，所以在这种情况下就通过这个 
  102.          函数再计算一遍当前节点的杂凑值*/  
  103.         if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) {  
  104.             err = nd->path.dentry->d_op->d_hash(nd->path.dentry,  
  105.                                 &this);  
  106.             if (err < 0)  
  107.                 break;  
  108.         }  
  109.         /* This does the actual lookups.. */  
  110.         /*实际的搜索工作*/  
  111.              err = do_lookup(nd, &this, &next);  
  112.         if (err)  
  113.             break;  
  114.   
  115.         err = -ENOENT;  
  116.         inode = next.dentry->d_inode;  
  117.         if (!inode)  
  118.             goto out_dput;  
  119.         /*涉及到具体文件系统的相关操作*/  
  120.         if (inode->i_op->follow_link) {  
  121.             err = do_follow_link(&next, nd);  
  122.             if (err)  
  123.                 goto return_err;  
  124.             err = -ENOENT;  
  125.             inode = nd->path.dentry->d_inode;  
  126.             if (!inode)  
  127.                 break;  
  128.         } else/*将path中的相关内容转化到nd中*/  
  129.             path_to_nameidata(&next, nd);  
  130.         err = -ENOTDIR;   
  131.         if (!inode->i_op->lookup)  
  132.             break;  
  133.         continue;  
  134.         /* here ends the main loop */  
  135.   
  136. last_with_slashes:  
  137.         lookup_flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;  
  138. last_component:  
  139.         /* Clear LOOKUP_CONTINUE iff it was previously unset */  
  140.         nd->flags &= lookup_flags | ~LOOKUP_CONTINUE;  
  141.         if (lookup_flags & LOOKUP_PARENT)/*要寻找的不是路径终点，而是他的上一层*/  
  142.             goto lookup_parent;  
  143.         if (this.name[0] == '.') switch (this.len) {  
  144.             default:  
  145.                 break;  
  146.             case 2:   
  147.                 if (this.name[1] != '.')  
  148.                     break;  
  149.                 follow_dotdot(nd);/*向上层移动*/  
  150.                 inode = nd->path.dentry->d_inode;  
  151.                 /* fallthrough */  
  152.             case 1:  
  153.                 goto return_reval;  
  154.         }  
  155.         /*具体文件系统的操作*/  
  156.         if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) {  
  157.             err = nd->path.dentry->d_op->d_hash(nd->path.dentry,  
  158.                                 &this);  
  159.             if (err < 0)  
  160.                 break;  
  161.         }/*顺次查找路径节点，下一个存放在next中*/  
  162.         err = do_lookup(nd, &this, &next);  
  163.         if (err)  
  164.             break;  
  165.         inode = next.dentry->d_inode;  
  166.         if ((lookup_flags & LOOKUP_FOLLOW)/*当终点为符号链接时*/  
  167.             && inode && inode->i_op->follow_link) {  
  168.             err = do_follow_link(&next, nd);  
  169.             if (err)  
  170.                 goto return_err;  
  171.             inode = nd->path.dentry->d_inode;  
  172.         } else  
  173.             /*path转化为nd*/  
  174.             path_to_nameidata(&next, nd);  
  175.         err = -ENOENT;  
  176.         if (!inode)  
  177.             break;  
  178.         if (lookup_flags & LOOKUP_DIRECTORY) {  
  179.             err = -ENOTDIR;   
  180.             if (!inode->i_op->lookup)  
  181.                 break;  
  182.         }  
  183.         goto return_base;  
  184. lookup_parent:  
  185.         nd->last = this;  
  186.         nd->last_type = LAST_NORM;/*根据终点节点名设置*/  
  187.         if (this.name[0] != '.')  
  188.             goto return_base;  
  189.         if (this.len == 1)  
  190.             nd->last_type = LAST_DOT;  
  191.         else if (this.len == 2 && this.name[1] == '.')  
  192.             nd->last_type = LAST_DOTDOT;  
  193.         else  
  194.             goto return_base;  
  195. return_reval:  
  196.         /* 
  197.          * We bypassed the ordinary revalidation routines. 
  198.          * We may need to check the cached dentry for staleness. 
  199.          */  
  200.         if (nd->path.dentry && nd->path.dentry->d_sb &&  
  201.             (nd->path.dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)) {  
  202.             err = -ESTALE;  
  203.             /* Note: we do not d_invalidate() */  
  204.             if (!nd->path.dentry->d_op->d_revalidate(  
  205.                     nd->path.dentry, nd))  
  206.                 break;  
  207.         }  
  208. return_base:  
  209.         return 0;  
  210. out_dput:  
  211.         path_put_conditional(&next, nd);  
  212.         break;  
  213.     }  
  214.     path_put(&nd->path);  
  215. return_err:  
  216.     return err;  
  217. }  
  • 1
  • 2
  • 下一页

相关内容