首先，linux内核的open函数是这么定义的SYSCALL_DEFINE3(open, ...)，可以查到的宏定义为
#define SYSCALL_DEFINE3(name, ...) SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)
#ifdef CONFIG_FTRACE_SYSCALLS
#define SYSCALL_DEFINEx(x, sname, ...) \
static const char *types_##sname[] = { \
__SC_STR_TDECL##x(__VA_ARGS__) \
}; \
static const char *args_##sname[] = { \
__SC_STR_ADECL##x(__VA_ARGS__) \
}; \
SYSCALL_METADATA(sname, x); \
__SYSCALL_DEFINEx(x, sname, __VA_ARGS__)
#else
#define SYSCALL_DEFINEx(x, sname, ...) \
__SYSCALL_DEFINEx(x, sname, __VA_ARGS__)
#endif
__SYSCALL_DEFINEx(3,_open,__VA_ARGS__)
#ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
#define SYSCALL_DEFINE(name) static inline long SYSC_##name
#define __SYSCALL_DEFINEx(x, name, ...) \
asmlinkage long sys##name(__SC_DECL##x(__VA_ARGS__)); \
static inline long SYSC##name(__SC_DECL##x(__VA_ARGS__)); \
asmlinkage long SyS##name(__SC_LONG##x(__VA_ARGS__)) \
{ \
__SC_TEST##x(__VA_ARGS__); \
return (long) SYSC##name(__SC_CAST##x(__VA_ARGS__)); \
} \
SYSCALL_ALIAS(sys##name, SyS##name); \
static inline long SYSC##name(__SC_DECL##x(__VA_ARGS__))
#else /* CONFIG_HAVE_SYSCALL_WRAPPERS */
#define SYSCALL_DEFINE(name) asmlinkage long sys_##name
#define __SYSCALL_DEFINEx(x, name, ...) \
asmlinkage long sys##name(__SC_DECL##x(__VA_ARGS__))
#endif /* CONFIG_HAVE_SYSCALL_WRAPPERS */asmlinkage long sys_open(__SC_DECL3(__VA_ARGS__))
(t3 a3,__SC_DECL2(__VA_ARGS__))
(t3 a3,t2 a2,t1 a1)
static inline long SYSC_open(t3 a3,t2 a2,t1 a1);
asmlinkage long SyS_open()
{
__SC_TEST(t3);
__SC_TEST(t2);
__SC_TEST(t1);
return (long) SYSC_open((t3) a3,(t2) a2,(t1) a1);
}do_sys_open(AT_FDCWD, filename, flags, mode)现在来看看里面具体的过程，现在假设当前带入的flags为O_CREAT和O_RDWR（不同的标志组合实在太多）
首先是由build_open_flags(flags, mode, &op);处理打开文件时所附带的标志。
别的不多说，就说一个在这个函数里进行的操作：
op->intent = flags & O_PATH ? 0 : LOOKUP_OPEN;
...
tmp = getname(filename);
...
fd = get_unused_fd_flags(flags);首先是从用户空间把文件名拷贝到内核空间，其中还对文件名长度接近PATH_MAX的情况做了特殊处理，保证能拷贝到小于等于PATH_MAX的文件名（之所以做特殊处理是因为当文件名远小于4096时，该函数做了一些优化）。取出文件名后，就需要从系统的fd集合中取出尚未被使用的fd(file descriptor)。即进入到了int __alloc_fd(struct files_struct *files,unsigned start, unsigned end, unsigned flags)函数。
fd = start;
if (fd < files->next_fd)
fd = files->next_fd;
if (fd < fdt->max_fds)
fd = find_next_zero_bit(fdt->open_fds, fdt->max_fds, fd);
...
if (start <= files->next_fd)
files->next_fd = fd + 1;fd分配成功后，就要真正进行打开文件的操作了：
struct file *f = do_filp_open(dfd, tmp, &op);struct file *filp;
filp = path_openat(dfd, pathname, &nd, op, flags | LOOKUP_RCU);file = get_empty_filp(); 上行代码从filp_cachep中获得一个空的已分配空间的file结构体。因为我的标志当中没有O_TMPFILE所以进入到error = path_init(dfd, pathname->name, flags, nd)
<span style="white-space:pre"> </span>nd->last_type = LAST_ROOT; /* if there are only slashes... */
nd->flags = flags | LOOKUP_JUMPED | LOOKUP_PARENT;
nd->depth = 0;
nd->base = NULL;如果给的路径名只是斜杠的话，那么就是打开根目录，进行相应的处理。这里不考虑这种情况。
if (*name=='/') {
...
}
else if (dfd == AT_FDCWD)
...
}
link_path_walk(name,nd){
for(;;){
may_lookup(nd);{//权限检查
inode_permisssion(nd->inode,MAY_EXEC|MAY_NOT_BLOCK);
}
type = LAST_NORM;
if(name[0] == '.'){
//如果碰上了".."或"."，那么type=LAST_DOTDOT或LAST_DOT
}
if(type == LAST_NORM){
struct dentry *parent = nd->path.dentry;
nd->flags &= ~LOOKUP_JUMPED;
}
nd->last.hash_len = hash_len;
nd->last.name = name;
nd->last_type = type;
name += hashlen_len(hash_len);
...//经过一番处理，walk刚刚得到的dentry
walk_component(truct nameidata *nd, struct path *path,int follow){
if (nd->last_type != LAST_NORM)
return handle_dots(nd, nd->last_type);
err = lookup_fast(nd, path, &inode);{
//首先在dentry_hashtable内部进行一次快速查找，从这次查找可以看出在该parent下其子dentry组成了一个hash_list
dentry = __d_lookup_rcu(parent, &nd->last, &seq);
path->mnt = mnt;
path->dentry = dentry;
return 0;
//当然刚才也可能出现在缓存的dentry_hashtable找不到的情况。
unlazy_walk(nd, dentry);//rcu to ref I think it's fast change to slow
...
return 1;//need_lookup
}
if (err){
err = lookup_slow(nd, path);
}
if (!inode || d_is_negative(path->dentry)) //当然也可能存在所要求的dentry不存在的情况：因为创建文件或恶意操作？
goto out_path_put;
...//follow link?
path_to_nameidata(path, nd);
nd->inode = inode;
return 0;
}
if (!d_can_lookup(nd->path.dentry)) { //如果该dentry不是目录
err = -ENOTDIR;
break;
}
}
terminate_walk(nd);//如果是RCU过程，释放RCU_LOCK
}做完这些操作后，进入do_last(nd, &path, file, op, &opened, pathname);其中opend=0。如函数名提示，开始进入函数的最后一部分了。
static int do_last(struct nameidata *nd, struct path *path,
struct file *file, const struct open_flags *op,
int *opened, struct filename *name){
if (nd->last_type != LAST_NORM) { //如果是.或..
error = handle_dots(nd, nd->last_type);
goto finish_open;
}
if (!(open_flag & O_CREAT)) { //处理非创建的情况
error = lookup_fast(nd, path, &inode);
}
else{
error = complete_walk(nd);
...
}
retry_lookup:
if (op->open_flag & (O_CREAT | O_TRUNC | O_WRONLY | O_RDWR)) {<span style="white-space:pre"> </span>//创建操作需要当前挂载的文件系统具有写权限
error = mnt_want_write(nd->path.mnt);
}
error = lookup_open(nd, path, file, op, got_write, opened);{
dentry = lookup_dcache(&nd->last, dir, nd->flags, &need_lookup);
if (!need_lookup && dentry->d_inode)
goto out_no_open;
if ((nd->flags & LOOKUP_OPEN) && dir_inode->i_op->atomic_open) {
return atomic_open(nd, dentry, path, file, op, got_write,
need_lookup, opened);{
if (((open_flag & (O_CREAT | O_TRUNC)) ||
(open_flag & O_ACCMODE) != O_RDONLY) && unlikely(!got_write))//看清楚这个逻辑判断操作，先或操作再且操作，主要是希望有写权限，但是可能没有got_write
}
}
}
}因为标志是O_CREAT，所以会进入else分支，然后接下来处理创建的一些工作。其中一般都会进入atomic_open部分。该函数的注释说如果返回0，代表此次创建成功，且file结构体成功关联到此次创建的文件，如果返回1，则此次只做了查找操作，具体的打开文件操作仍然要交给调用者。别的情况就返回错误。
最后一些权限检查后，基本就完成了open函数的操作。
这其中对元数据查询的最关键的部分应该是在link_path_walk
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
