走马观花： Linux 系统调用 open 七日游（三）

  ...

1.     err = lookup_fast(nd, path, &inode);
   
2.     if (unlikely(err)) {
   
3.         if (err 0)
   
4.             goto out_err;
   
5. 
   
6.         err = lookup_slow(nd, path);
   
7.         if (err 0)
   
8.             goto out_err;
   
9. 
   
10.         inode = path->dentry->d_inode;
    
11.     }
    
12.     err = -ENOENT;
    
13.     if (!inode || d_is_negative(path->dentry))
    
14.         goto out_path_put;
    

  ...

1. static int lookup_fast(struct nameidata *nd,
   
2.          struct path *path, struct inode **inode)
   
3. {

  ...

1.     if (nd->flags & LOOKUP_RCU) {
   
2.         unsigned seq;
   
3.         dentry = __d_lookup_rcu(parent, &nd->last, &seq);
   
4.         if (!dentry)
   
5.             goto unlazy;
   

  ...

1.         *inode = dentry->d_inode;
   
2.         if (read_seqcount_retry(&dentry->d_seq, seq))
   
3.             return -ECHILD;
   

  ...

1.         if (__read_seqcount_retry(&parent->d_seq, nd->seq))
   
2.             return -ECHILD;
   
3.         nd->seq = seq;
   

  ...

1.         path->mnt = mnt;
   
2.         path->dentry = dentry;
   
3.         if (unlikely(!__follow_mount_rcu(nd, path, inode)))
   
4.             goto unlazy;
   
5.         if (unlikely(path->dentry->d_flags & DCACHE_NEED_AUTOMOUNT))
   
6.             goto unlazy;
   
7.         return 0;
   
8. unlazy:
   
9.         if (unlazy_walk(nd, dentry))
   
10.             return -ECHILD;
    
11.     } else {

  ...

  ...

1. unlazy:
   
2.         if (unlazy_walk(nd, dentry))
   
3.             return -ECHILD;
   
4.     } else {
   
5.         dentry = __d_lookup(parent, &nd->last);
   
6.     }
   
7. 
   
8.     if (unlikely(!dentry))
   
9.         goto need_lookup;
   

  ...

1.     path->mnt = mnt;
   
2.     path->dentry = dentry;
   
3.     err = follow_managed(path, nd->flags);
   
4.     if (unlikely(err 0)) {
   
5.         path_put_conditional(path, nd);
   
6.         return err;
   
7.     }
   
8.     if (err)
   
9.         nd->flags |= LOOKUP_JUMPED;
   
10.     *inode = path->dentry->d_inode;
    
11.     return 0;
    
12. 
    
13. need_lookup:
    
14.     return 1;
    
15. }

1. static int lookup_slow(struct nameidata *nd, struct path *path)
   
2. {

  ...

1.     mutex_lock(&parent->d_inode->i_mutex);
   
2.     dentry = __lookup_hash(&nd->last, parent, nd->flags);
   
3.     mutex_unlock(&parent->d_inode->i_mutex);

  ...

1. }

1. static struct dentry *__lookup_hash(struct qstr *name,
   
2.         struct dentry *base, unsigned int flags)
   
3. {
   
4.     bool need_lookup;
   
5.     struct dentry *dentry;
   
6. 
   
7.     dentry = lookup_dcache(name, base, flags, &need_lookup);
   
8.     if (!need_lookup)
   
9.         return dentry;
   
10. 
    
11.     return lookup_real(base->d_inode, dentry, flags);
    
12. }

  ...

1.     if (should_follow_link(path->dentry, follow)) {
   
2.         if (nd->flags & LOOKUP_RCU) {
   
3.             if (unlikely(unlazy_walk(nd, path->dentry))) {
   
4.                 err = -ECHILD;
   
5.                 goto out_err;
   
6.             }
   
7.         }
   
8.         BUG_ON(inode != path->dentry->d_inode);
   
9.         return 1;
   
10.     }
    
11.     path_to_nameidata(path, nd);
    
12.     nd->inode = inode;
    
13.     return 0;
    

  ...

1. }