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

  ...

1.     error = do_last(nd, &path, file, op, &opened, pathname);
   
2.     while (unlikely(error > 0)) { /* trailing symlink */
   
3.         struct path link = path;
   
4.         void *cookie;
   
5.         if (!(nd->flags & LOOKUP_FOLLOW)) {
   
6.             path_put_conditional(&path, nd);
   
7.             path_put(&nd->path);
   
8.             error = -ELOOP;
   
9.             break;
   
10.         }
    
11.         error = may_follow_link(&link, nd);
    
12.         if (unlikely(error))
    
13.             break;
    
14.         nd->flags |= LOOKUP_PARENT;
    
15.         nd->flags &= ~(LOOKUP_OPEN|LOOKUP_CREATE|LOOKUP_EXCL);
    
16.         error = follow_link(&link, nd, &cookie);
    
17.         if (unlikely(error))
    
18.             break;
    
19.         error = do_last(nd, &path, file, op, &opened, pathname);
    
20.         put_link(nd, &link, cookie);
    
21.     }

  ...

1. static inline int build_open_flags(int flags, umode_t mode, struct open_flags *op)
   
2. {

  ...

1.         op->mode = 0;
   

  ...

1.         acc_mode = MAY_OPEN | ACC_MODE(flags);

  ...

1.     op->intent = flags & O_PATH ? 0 : LOOKUP_OPEN;
   

  ...

1. }

1. static int do_last(struct nameidata *nd, struct path *path,
   
2.          struct file *file, const struct open_flags *op,
   
3.          int *opened, struct filename *name)
   
4. {

  ...

1.     nd->flags &= ~LOOKUP_PARENT;
   
2.     nd->flags |= op->intent;
   

  ...

1.     if (!(open_flag & O_CREAT)) {

  ...

1.         error = lookup_fast(nd, path, &inode);
   
2.         if (likely(!error))
   
3.             goto finish_lookup;

  ...

1.     }
   
2. 
   
3. retry_lookup:

  ...

  ...

1. retry_lookup:

  ...

1.     mutex_lock(&dir->d_inode->i_mutex);
   
2.     error = lookup_open(nd, path, file, op, got_write, opened);
   
3.     mutex_unlock(&dir->d_inode->i_mutex);
   

  ...

1.     error = follow_managed(path, nd->flags);

  ...

1.     inode = path->dentry->d_inode;

  ...

1. finish_lookup:

  ...

1.     if ((nd->flags & LOOKUP_RCU) || nd->path.mnt != path->mnt) {
   
2.         path_to_nameidata(path, nd);
   
3.     } else {
   
4.         save_parent.dentry = nd->path.dentry;
   
5.         save_parent.mnt = mntget(path->mnt);
   
6.         nd->path.dentry = path->dentry;
   
7. 
   
8.     }
   
9.     nd->inode = inode;

  ...

1. finish_open:
   
2.     error = complete_walk(nd);

  ...

1. static int complete_walk(struct nameidata *nd)
   
2. {
   
3.     struct dentry *dentry = nd->path.dentry;
   
4.     int status;
   
5. 
   
6.     if (nd->flags & LOOKUP_RCU) {
   
7.         nd->flags &= ~LOOKUP_RCU;

  ...

1.         rcu_read_unlock();
   
2.     }
   
3. 
   
4.     if (likely(!(nd->flags & LOOKUP_JUMPED)))
   
5.         return 0;
   

  ...

1. }

  ...

1. finish_open_created:
   
2.     error = may_open(&nd->path, acc_mode, open_flag);
   
3.     if (error)
   
4.         goto out;
   
5.     file->f_path.mnt = nd->path.mnt; 
   
6.     error = finish_open(file, nd->path.dentry, NULL, opened);
   
7.     if (error) {
   
8.         if (error == -EOPENSTALE)
   
9.             goto stale_open;
   
10.         goto out;
    
11.     }
    
12. opened:

  ...

1. out:
   
2.     if (got_write)
   
3.         mnt_drop_write(nd->path.mnt);
   
4.     path_put(&save_parent);
   
5.     terminate_walk(nd);
   
6.     return error;
   

  ...

1. }