linux设备驱动模型一字符设备open系统调用流程

谁践踏了优雅 2022-01-09 07:29 332阅读 0赞

从前面 的例子可以看到，我们在操作一个调和时都 是通过open系统调用先去打开这个设备，不管是设备还是文件，我们要访问它都要称通过open函数来先打开， 这样才能调用其它的函数如read、write来操作它,即通知内核新建一个代表该文件的结构，并且返回该文件的描述符(一个整数)，该描述符在进程内唯一。

在linux系统进程中，分为内核空间和用户空间，当一个任务（进程）执行系统调用而陷入内核代码中执行时，我们就称进程处于内核运行态（内核态）。在内核态下，CPU可执行任何指令。当进程在执行用户自己的代码时，则称其处于用户运行态（用户态）。用户态不能访问内核空间，包括代码和数据。所有进程的内核空间（3G－4G）都是共享的。当我们在用户空间调用open之后，会产生一个软中断，然后通过系统调用进入内核空间。通过系统调用号，我们就可以跳转到该中断例程的入口地址。

这里分析一下open的调用流程.

open()的格式如下：

int open(const char \* pathname,int oflag, mode\_t mode )  
pathname:代表需要打开的文件的文件名；  
oflag：表示打开的标识，具体的内核支持如下标记位(include\\asm-generic\\fcntl.h)：

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  \#define O\_ACCMODE 00000003
2.  \#define O\_RDONLY 00000000 //只读打开
3.  \#define O\_WRONLY 00000001 //只写打开
4.  \#define O\_RDWR 00000002 //读写打开
5.  \#ifndef O\_CREAT
6.  \#define O\_CREAT 00000100 //文件不存在则创建，需要mode\_t
7.  \#endif
8.  \#ifndef O\_EXCL
9.  \#define O\_EXCL 00000200 //如果同时指定了O\_CREAT，而文件已经存在，则出错 
10. \#endif
11. \#ifndef O\_NOCTTY
12. \#define O\_NOCTTY 00000400 //如果pathname代表终端设备，则不将此设备分配作为此进程的控制终端
13. \#endif
14. \#ifndef O\_TRUNC
15. \#define O\_TRUNC 00001000 //如果此文件存在，而且为只读或只写成功打开，则将其长度截短为0 
16. \#endif
17. \#ifndef O\_APPEND
18. \#define O\_APPEND 00002000 //每次写时都加到文件的尾端
19. \#endif
20. \#ifndef O\_NONBLOCK
21. \#define O\_NONBLOCK 00004000 //如果pathname指的是一个FIFO、一个块特殊文件或一个字符特殊文件，则此选择项为此文件的本次打开操作和后续的I / O操作设置非阻塞
22. \#endif
23. \#ifndef O\_SYNC
24. \#define O\_SYNC 00010000 //使每次write都等到物理I/O操作完成
25. \#endif
26. \#ifndef FASYNC
27. \#define FASYNC 00020000 //兼容BSD的fcntl同步操作
28. \#endif
29. \#ifndef O\_DIRECT
30. \#define O\_DIRECT 00040000 //直接磁盘操作标识，每次读写都不使用内核提供的缓存，直接读写磁盘设备
31. \#endif
32. \#ifndef O\_LARGEFILE
33. \#define O\_LARGEFILE 00100000 // 大文件标识
34. \#endif
35. \#ifndef O\_DIRECTORY
36. \#define O\_DIRECTORY 00200000 //必须是目录
37. \#endif
38. \#ifndef O\_NOFOLLOW
39. \#define O\_NOFOLLOW 00400000 //不获取连接文件
40. \#endif
41. \#ifndef O\_NOATIME
42. \#define O\_NOATIME 01000000
43. \#endif
44. \#ifndef O\_CLOEXEC
45. \#define O\_CLOEXEC 02000000 /\* set close\_on\_exec \*/
46. \#endif
47. \#ifndef O\_NDELAY
48. \#define O\_NDELAY O\_NONBLOCK
49. \#endif

当新创建一个文件时，需要指定mode参数，以下说明的格式如宏定义名称<实际常数值>:  
描述如下(include\\linux\\stat.h)：

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  \#define S\_IRWXU 00700 //文件拥有者有读写执行权限
2.  \#define S\_IRUSR 00400 //文件拥有者仅有读权限 
3.  \#define S\_IWUSR 00200 //文件拥有者仅有写权限
4.  \#define S\_IXUSR 00100 //文件拥有者仅有执行权限
5.  
6.  \#define S\_IRWXG 00070 //组用户有读写执行权限
7.  \#define S\_IRGRP 00040 //组用户仅有读权限
8.  \#define S\_IWGRP 00020 //组用户仅有写权限
9.  \#define S\_IXGRP 00010 //组用户仅有执行权限
10. 
11. \#define S\_IRWXO 00007 //其他用户有读写执行权限
12. \#define S\_IROTH 00004 //其他用户仅有读权限
13. \#define S\_IWOTH 00002 //其他用户仅有写权限
14. \#define S\_IXOTH 00001 //其他用户仅有执行权限

系统调用号定义在arch/x86/include/asm/unistd\_32.h中：

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  \#define \_\_NR\_restart\_syscall 0
2.  \#define \_\_NR\_exit 1
3.  \#define \_\_NR\_fork 2
4.  \#define \_\_NR\_read 3
5.  \#define \_\_NR\_write 4
6.  \#define \_\_NR\_open 5
7.  \#define \_\_NR\_close 6
8.  \#define \_\_NR\_waitpid 7
9.  \#define \_\_NR\_creat 8
10. \#define \_\_NR\_link 9
11. \#define \_\_NR\_unlink 10
12. \#define \_\_NR\_execve 11
13. \#define \_\_NR\_chdir 12
14. \#define \_\_NR\_time 13
15. \#define \_\_NR\_mknod 14
16. \#define \_\_NR\_chmod 15

当open系统调用产生时，就会进入下面这个函数（）：

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  SYSCALL\_DEFINE3(open, **const****char** \_\_user \*, filename, **int**, flags, **int**, mode) 
2.  \{ 
3.  **long** ret; 
4.  
5.  /\*检查是否应该不考虑用户层传递的标志、总是强行设置 
6.   O\_LARGEFILE标志。如果底层处理器的字长不是32位，就是这种 
7.   情况\*/
8.  **if** (force\_o\_largefile()) 
9.   flags |= O\_LARGEFILE; 
10. /\*实际工作\*/
11.  ret = do\_sys\_open(AT\_FDCWD, filename, flags, mode); 
12. /\* avoid REGPARM breakage on x86: \*/
13.  asmlinkage\_protect(3, ret, filename, flags, mode); 
14. **return** ret; 
15. \}

我们看下SYSCALL\_DEFINE3(open, const char \_\_user \*, filename, int, flags, int, mode) 展开是怎么样的

首先看下宏SYSCALL\_DEFINE3

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  \#define SYSCALL\_DEFINE3(name, ...) SYSCALL\_DEFINEx(3, \_\#\#name, \_\_VA\_ARGS\_\_)

再看下SYSCALL\_DEFINEx

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  \#define SYSCALL\_DEFINEx(x, sname, ...) \\
2.   \_\_SYSCALL\_DEFINEx(x, sname, \_\_VA\_ARGS\_\_)

再看下\_\_SYSCALL\_DEFINEx

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  \#define \_\_SYSCALL\_DEFINEx(x, name, ...) \\
2.   asmlinkage **long** sys\#\#name(\_\_SC\_DECL\#\#x(\_\_VA\_ARGS\_\_))

这里对对应\_\_SC\_DECL3

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  \#define \_\_SC\_DECL1(t1, a1) t1 a1
2.  \#define \_\_SC\_DECL2(t2, a2, ...) t2 a2, \_\_SC\_DECL1(\_\_VA\_ARGS\_\_)
3.  \#define \_\_SC\_DECL3(t3, a3, ...) t3 a3, \_\_SC\_DECL2(\_\_VA\_ARGS\_\_)

这们一步步展开SYSCALL\_DEFINE3(open, const char \_\_user \*, filename, int, flags, int, mode)代替进去，可以得到

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  SYSCALL\_DEFINE3(open, **const****char** \_\_user \*, filename, **int**, flags, **int**, mode) 
2.   = SYSCALL\_DEFINEx(3, \_\#\#name, \_\_VA\_ARGS\_\_) 
3.  =asmlinkage **long** sys\_open(\_\_SC\_DECL3(\_\_VA\_ARGS\_\_)) 
4.  =asmlinkage **long** sys\_open(**const****char** \_\_user\* filename, **int** flags, **int** mode)

这个才是真正的函数原型

在sys\_open里面继续调用do\_sys\_open完成 open操作

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **long** do\_sys\_open(**int** dfd, **const****char** \_\_user \*filename, **int** flags, **int** mode) 
2.  \{ 
3.  /\*从进程地址空间读取该文件的路径名\*/
4.  **char** \*tmp = getname(filename); 
5.  **int** fd = PTR\_ERR(tmp); 
6.  
7.  **if** (!IS\_ERR(tmp)) \{ 
8.  /\*在内核中，每个打开的文件由一个文件描述符表示 
9.   该描述符在特定于进程的数组中充当位置索引(数组是 
10.  task\_struct->files->fd\_arry)，该数组的元素包含了file结构，其中 
11.  包括每个打开文件的所有必要信息。因此，调用下面 
12.  函数查找一个未使用的文件描述符,返回的是上面 
13.  说的数组的下标\*/
14.  fd = get\_unused\_fd\_flags(flags); 
15. **if** (fd >= 0) \{ 
16. /\*fd获取成功则开始打开文件，此函数是主要完成打开功能的函数\*/
17. //如果分配fd成功，则创建一个file对象
18. **struct** file \*f = do\_filp\_open(dfd, tmp, flags, mode, 0); 
19. **if** (IS\_ERR(f)) \{ 
20.  put\_unused\_fd(fd); 
21.  fd = PTR\_ERR(f); 
22.  \} **else** \{ 
23. /\*文件如果打开成功，调用fsnotify\_open()函数，根据inode所指定的信息进行打开
24.  函数（参数为f）将该文件加入到文件监控的系统中。该系统是用来监控文件被打开，创建，
25.  读写，关闭，修改等操作的\*/
26.  fsnotify\_open(f->f\_path.dentry); 
27. /\*将文件指针安装在fd数组中
28.  将struct file \*f加入到fd索引位置处的数组中。如果后续过程中，有对该文件描述符的
29.  操作的话，就会通过查找该数组得到对应的文件结构，而后在进行相关操作。\*/
30.  fd\_install(fd, f); 
31.  \} 
32.  \} 
33.  putname(tmp); 
34.  \} 
35. **return** fd; 
36. \}

该函数主要分为如下几个步骤来完成打开文件的操作：  
1.将文件名参数从用户态拷贝至内核，调用函数get\_name()；  
2.从进程的文件表中找到一个空闲的文件表指针，调用了函数get\_unused\_fd\_flgas()；  
3.完成真正的打开操作，调用函数do\_filp\_open()；  
4.将打开的文件添加到进程的文件表数组中，调用函数fd\_install()；

getname函数主要的任务是将文件名filename从用户态拷贝至内核态

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **char** \* getname(**const****char** \_\_user \* filename) 
2.  \{ 
3.  **char** \*tmp, \*result; 
4.  
5.   result = ERR\_PTR(-ENOMEM); 
6.   tmp = \_\_getname(); //从内核缓存中分配空间； 
7.  **if** (tmp) \{ 
8.  //将文件名从用户态拷贝至内核态； 
9.  **int** retval = do\_getname(filename, tmp); 
10. 
11.  result = tmp; 
12. **if** (retval < 0) \{ //如果拷贝失败，则调用\_\_putname()释放\_\_getname()中申请的空间； 
13.  \_\_putname(tmp); 
14.  result = ERR\_PTR(retval); 
15.  \} 
16.  \} 
17.  audit\_getname(result); 
18. **return** result; 
19. \}

get\_unused\_fd\_flags实际调用的是alloc\_fd

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  \#define get\_unused\_fd\_flags(flags) alloc\_fd(0, (flags))

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  /\*
2.   \* allocate a file descriptor, mark it busy.
3.   \*/
4.  **int** alloc\_fd(unsigned start, unsigned flags) 
5.  \{ 
6.  **struct** files\_struct \*files = current->files;//获得当前进程的files\_struct 结构
7.   unsigned **int** fd; 
8.  **int** error; 
9.  **struct** fdtable \*fdt; 
10. 
11.  spin\_lock(&files->file\_lock); 
12. repeat: 
13.  fdt = files\_fdtable(files); 
14.  fd = start; 
15. **if** (fd < files->next\_fd) //从上一次打开的fd的下一个fd开始搜索空闲的fd 
16.  fd = files->next\_fd; 
17. 
18. **if** (fd < fdt->max\_fds)//寻找空闲的fd，返回值为空闲的fd 
19.  fd = find\_next\_zero\_bit(fdt->open\_fds->fds\_bits, 
20.  fdt->max\_fds, fd); 
21. //如果有必要，即打开的fd超过max\_fds,则需要expand当前进程的fd表； 
22. //返回值error<0表示出错，error=0表示无需expand，error=1表示进行了expand；
23.  error = expand\_files(files, fd); 
24. **if** (error < 0) 
25. **goto** out; 
26. 
27. /\*
28.  \* If we needed to expand the fs array we
29.  \* might have blocked - try again.
30.  \*/
31. //error=1表示进行了expand，那么此时需要重新去查找空闲的fd； 
32. **if** (error) 
33. **goto** repeat; 
34. 
35. //设置下一次查找的起始fd，即本次找到的空闲的fd的下一个fd，记录在files->next\_fd中； 
36. **if** (start <= files->next\_fd) 
37.  files->next\_fd = fd + 1; 
38. 
39.  FD\_SET(fd, fdt->open\_fds); 
40. **if** (flags & O\_CLOEXEC) 
41.  FD\_SET(fd, fdt->close\_on\_exec); 
42. **else**
43.  FD\_CLR(fd, fdt->close\_on\_exec); 
44.  error = fd; 
45. \#if 1
46. /\* Sanity check \*/
47. **if** (rcu\_dereference(fdt->fd\[fd\]) != NULL) \{ 
48.  printk(KERN\_WARNING "alloc\_fd: slot %d not NULL!\\n", fd); 
49.  rcu\_assign\_pointer(fdt->fd\[fd\], NULL); 
50.  \} 
51. \#endif
52. 
53. out: 
54.  spin\_unlock(&files->file\_lock); 
55. **return** error; 
56. \}

该函数为需要打开的文件在当前进程内分配一个空闲的文件描述符fd，该fd就是open()系统调用的返回值

do\_filp\_open函数的一个重要作用就是根据传递近来的权限进行分析，并且分析传递近来的路径名字，根据路径名逐个解析成dentry，并且通过dentry找到inode，inode就是记录着该文件相关的信息， 包括文件的创建时间和文件属性所有者等等信息，根据这些信息就可以找到对应的文件操作方法。在这个过程当中有一个临时的结构体用于保存在查找过程中的相关信息，就是

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **struct** nameidata \{ 
2.  **struct** path path;//当前目录的dentry数据结构
3.  **struct** qstr last;//这个结构体也是临时性的，主要用来保存当前目录的名称，杂凑值。
4.   unsigned **int** flags; 
5.  **int** last\_type; 
6.   unsigned depth;//连接文件的深度（可能一个连接文件跟到最后还是一个了连接文件）
7.  //用来保存连接文件的一些信息，下标表示连接文件的深度
8.  **char** \*saved\_names\[MAX\_NESTED\_LINKS + 1\]; 
9.  
10. /\* Intent data \*/
11. **union** \{ 
12. **struct** open\_intent open; 
13.  \} intent; 
14. \};

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **struct** file \*do\_filp\_open(**int** dfd, **const****char** \*pathname, 
2.  **int** open\_flag, **int** mode, **int** acc\_mode) 
3.  \{ 
4.  **struct** file \*filp; 
5.  **struct** nameidata nd; 
6.  **int** error; 
7.  **struct** path path; 
8.  **int** count = 0; 
9.  **int** flag = open\_to\_namei\_flags(open\_flag); /\*改变参数flag的值，具体做法是flag+1\*/
10. **int** force\_reval = 0; 
11. 
12. **if** (!(open\_flag & O\_CREAT)) 
13.  mode = 0; 
14. 
15. /\*
16.  \* O\_SYNC is implemented as \_\_O\_SYNC|O\_DSYNC. As many places only
17.  \* check for O\_DSYNC if the need any syncing at all we enforce it's
18.  \* always set instead of having to deal with possibly weird behaviour
19.  \* for malicious applications setting only \_\_O\_SYNC.
20.  \*/
21. **if** (open\_flag & \_\_O\_SYNC)/\*根据\_\_O\_SYNC标志来设置O\_DSYNC 标志，用以防止恶意破坏程序\*/
22.  open\_flag |= O\_DSYNC; 
23. 
24. **if** (!acc\_mode)/\*设置访问权限\*/
25.  acc\_mode = MAY\_OPEN | ACC\_MODE(open\_flag); 
26. 
27. /\* O\_TRUNC implies we need access checks for write permissions \*/
28. **if** (open\_flag & O\_TRUNC)/\*根据 O\_TRUNC标志设置写权限 \*/
29.  acc\_mode |= MAY\_WRITE; 
30. 
31. /\* Allow the LSM permission hook to distinguish append 
32.  access from general write access. \*/
33. **if** (open\_flag & O\_APPEND)/\* 设置O\_APPEND 标志\*/
34.  acc\_mode |= MAY\_APPEND; 
35. 
36. /\* find the parent \*/
37. reval: 
38.  error = path\_init(dfd, pathname, LOOKUP\_PARENT, &nd);//初始化nd
39. **if** (error) 
40. **return** ERR\_PTR(error); 
41. **if** (force\_reval) 
42.  nd.flags |= LOOKUP\_REVAL; 
43. 
44.  current->total\_link\_count = 0; 
45.  error = link\_path\_walk(pathname, &nd);//路径名解析函数，将一个路径名最终转化为一个dentry
46. **if** (error) \{ 
47.  filp = ERR\_PTR(error); 
48. **goto** out; 
49.  \} 
50. **if** (unlikely(!audit\_dummy\_context()) && (open\_flag & O\_CREAT)) 
51.  audit\_inode(pathname, nd.path.dentry); 
52. 
53. /\*
54.  \* We have the parent and last component.
55.  \*/
56. 
57.  error = -ENFILE; 
58.  filp = get\_empty\_filp();// 从进程文件表中获取一个未使用的文件结构指针，空则出错返回
59. **if** (filp == NULL) 
60. **goto** exit\_parent; 
61.  nd.intent.open.file = filp; 
62.  filp->f\_flags = open\_flag; 
63.  nd.intent.open.flags = flag; 
64.  nd.intent.open.create\_mode = mode; 
65.  nd.flags &= ~LOOKUP\_PARENT; 
66.  nd.flags |= LOOKUP\_OPEN; 
67. **if** (open\_flag & O\_CREAT) \{ 
68.  nd.flags |= LOOKUP\_CREATE; 
69. **if** (open\_flag & O\_EXCL) 
70.  nd.flags |= LOOKUP\_EXCL; 
71.  \} 
72. **if** (open\_flag & O\_DIRECTORY) 
73.  nd.flags |= LOOKUP\_DIRECTORY; 
74. **if** (!(open\_flag & O\_NOFOLLOW)) 
75.  nd.flags |= LOOKUP\_FOLLOW; 
76.  filp = do\_last(&nd, &path, open\_flag, acc\_mode, mode, pathname);//返回一个file结构
77. **while** (unlikely(!filp)) \{ /\* trailing symlink \*///符号链接 
78. **struct** path holder; 
79. **struct** inode \*inode = path.dentry->d\_inode; 
80. **void** \*cookie; 
81.  error = -ELOOP; 
82. /\* S\_ISDIR part is a temporary automount kludge \*/
83. **if** (!(nd.flags & LOOKUP\_FOLLOW) && !S\_ISDIR(inode->i\_mode)) 
84. **goto** exit\_dput; 
85. **if** (count++ == 32) 
86. **goto** exit\_dput; 
87. /\*
88.  \* This is subtle. Instead of calling do\_follow\_link() we do
89.  \* the thing by hands. The reason is that this way we have zero
90.  \* link\_count and path\_walk() (called from ->follow\_link)
91.  \* honoring LOOKUP\_PARENT. After that we have the parent and
92.  \* last component, i.e. we are in the same situation as after
93.  \* the first path\_walk(). Well, almost - if the last component
94.  \* is normal we get its copy stored in nd->last.name and we will
95.  \* have to putname() it when we are done. Procfs-like symlinks
96.  \* just set LAST\_BIND.
97.  \*/
98.  nd.flags |= LOOKUP\_PARENT; 
99.  error = security\_inode\_follow\_link(path.dentry, &nd); 
100. **if** (error) 
101. **goto** exit\_dput; 
102.  error = \_\_do\_follow\_link(&path, &nd, &cookie);//查找符号链接对应的目录中的最后一项
103. **if** (unlikely(error)) \{ 
104. /\* nd.path had been dropped \*/
105. **if** (!IS\_ERR(cookie) && inode->i\_op->put\_link) 
106.  inode->i\_op->put\_link(path.dentry, &nd, cookie); 
107.  path\_put(&path); 
108.  release\_open\_intent(&nd); 
109.  filp = ERR\_PTR(error); 
110. **goto** out; 
111.  \} 
112.  holder = path; 
113.  nd.flags &= ~LOOKUP\_PARENT; 
114.  filp = do\_last(&nd, &path, open\_flag, acc\_mode, mode, pathname); 
115. **if** (inode->i\_op->put\_link) 
116.  inode->i\_op->put\_link(holder.dentry, &nd, cookie); 
117.  path\_put(&holder); 
118.  \} 
119. out: 
120. **if** (nd.root.mnt) 
121.  path\_put(&nd.root); 
122. **if** (filp == ERR\_PTR(-ESTALE) && !force\_reval) \{ 
123.  force\_reval = 1; 
124. **goto** reval; 
125.  \} 
126. **return** filp;//成功，返回
127. 
128. exit\_dput: 
129.  path\_put\_conditional(&path, &nd); 
130. **if** (!IS\_ERR(nd.intent.open.file)) 
131.  release\_open\_intent(&nd); 
132. exit\_parent: 
133.  path\_put(&nd.path); 
134.  filp = ERR\_PTR(error); 
135. **goto** out; 
136. \}

当内核要访问一个文件的时候，第一步要做的是找到这个文件，而查找文件的过程在vfs里面是由link\_path\_walk函数来完成的,在path\_init的时候我们可以看到传进去的参数有一个LOOKUP\_PARENT，它的含义是查找最后一个分量名所在的目录。也就是当这个函数返回的时候，我们得到了一个路径名中最后一个分量所在的目录。

接着调用do\_last返回最后一个分量对应的file指针，我们关注一下这个函数

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **static****struct** file \*do\_last(**struct** nameidata \*nd, **struct** path \*path, 
2.  **int** open\_flag, **int** acc\_mode, 
3.  **int** mode, **const****char** \*pathname) 
4.  \{ 
5.  **struct** dentry \*dir = nd->path.dentry; 
6.  **struct** file \*filp; 
7.  **int** error = -EISDIR; 
8.  
9.  **switch** (nd->last\_type) \{ // 检查最后一段文件或目录名的属性情况
10. **case** LAST\_DOTDOT: 
11.  follow\_dotdot(nd); 
12.  dir = nd->path.dentry; 
13. **case** LAST\_DOT: 
14. **if** (nd->path.mnt->mnt\_sb->s\_type->fs\_flags & FS\_REVAL\_DOT) \{ 
15. **if** (!dir->d\_op->d\_revalidate(dir, nd)) \{ 
16.  error = -ESTALE; 
17. **goto** exit; 
18.  \} 
19.  \} 
20. /\* fallthrough \*/
21. **case** LAST\_ROOT: 
22. **if** (open\_flag & O\_CREAT) 
23. **goto** exit; 
24. /\* fallthrough \*/
25. **case** LAST\_BIND: 
26.  audit\_inode(pathname, dir); 
27. **goto** ok; 
28.  \} 
29. 
30. /\* trailing slashes? \*/
31. **if** (nd->last.name\[nd->last.len\]) \{ 
32. **if** (open\_flag & O\_CREAT) 
33. **goto** exit; 
34.  nd->flags |= LOOKUP\_DIRECTORY | LOOKUP\_FOLLOW; 
35.  \} 
36. 
37. /\* just plain open? \*/
38. **if** (!(open\_flag & O\_CREAT)) \{ //没有创建标志，即文件存在
39.  error = do\_lookup(nd, &nd->last, path);//找到路径中最后一项对应的目录项
40. **if** (error) 
41. **goto** exit; 
42.  error = -ENOENT; 
43. **if** (!path->dentry->d\_inode) 
44. **goto** exit\_dput; 
45. **if** (path->dentry->d\_inode->i\_op->follow\_link) 
46. **return** NULL; 
47.  error = -ENOTDIR; 
48. **if** (nd->flags & LOOKUP\_DIRECTORY) \{ 
49. **if** (!path->dentry->d\_inode->i\_op->lookup) 
50. **goto** exit\_dput; 
51.  \} 
52.  path\_to\_nameidata(path, nd);//赋值到nd结构
53.  audit\_inode(pathname, nd->path.dentry); 
54. **goto** ok; 
55.  \} 
56. 
57. /\* OK, it's O\_CREAT \*/
58. //文件不存在，需要创建
59.  mutex\_lock(&dir->d\_inode->i\_mutex); 
60. 
61.  path->dentry = lookup\_hash(nd);//获取最后路径名中最后一项对应的目录项
62.  path->mnt = nd->path.mnt; 
63. 
64.  error = PTR\_ERR(path->dentry); 
65. **if** (IS\_ERR(path->dentry)) \{ 
66.  mutex\_unlock(&dir->d\_inode->i\_mutex); 
67. **goto** exit; 
68.  \} 
69. 
70. **if** (IS\_ERR(nd->intent.open.file)) \{ 
71.  error = PTR\_ERR(nd->intent.open.file); 
72. **goto** exit\_mutex\_unlock; 
73.  \} 
74. 
75. /\* Negative dentry, just create the file \*/
76. **if** (!path->dentry->d\_inode) \{ //没有索引节点与目录项关联
77. /\*
78.  \* This write is needed to ensure that a
79.  \* ro->rw transition does not occur between
80.  \* the time when the file is created and when
81.  \* a permanent write count is taken through
82.  \* the 'struct file' in nameidata\_to\_filp().
83.  \*/
84.  error = mnt\_want\_write(nd->path.mnt); 
85. **if** (error) 
86. **goto** exit\_mutex\_unlock; 
87.  error = \_\_open\_namei\_create(nd, path, open\_flag, mode);//创建相应的索引节点
88. **if** (error) \{ 
89.  mnt\_drop\_write(nd->path.mnt); 
90. **goto** exit; 
91.  \} 
92.  filp = nameidata\_to\_filp(nd);/\*根据nameidata 得到相应的file结构\*/
93.  mnt\_drop\_write(nd->path.mnt); 
94. **if** (!IS\_ERR(filp)) \{ 
95.  error = ima\_file\_check(filp, acc\_mode); 
96. **if** (error) \{ 
97.  fput(filp); 
98.  filp = ERR\_PTR(error); 
99.  \} 
100.  \} 
101. **return** filp; 
102.  \} 
103. 
104. /\*
105.  \* It already exists.
106.  \*/
107.  mutex\_unlock(&dir->d\_inode->i\_mutex); 
108.  audit\_inode(pathname, path->dentry); 
109. 
110.  error = -EEXIST; 
111. **if** (open\_flag & O\_EXCL) 
112. **goto** exit\_dput; 
113. 
114. **if** (\_\_follow\_mount(path)) \{ 
115.  error = -ELOOP; 
116. **if** (open\_flag & O\_NOFOLLOW) 
117. **goto** exit\_dput; 
118.  \} 
119. 
120.  error = -ENOENT; 
121. **if** (!path->dentry->d\_inode) 
122. **goto** exit\_dput; 
123. 
124. **if** (path->dentry->d\_inode->i\_op->follow\_link) 
125. **return** NULL; 
126. 
127.  path\_to\_nameidata(path, nd); 
128.  error = -EISDIR; 
129. **if** (S\_ISDIR(path->dentry->d\_inode->i\_mode)) 
130. **goto** exit; 
131. ok: 
132.  filp = finish\_open(nd, open\_flag, acc\_mode);//完成文件打开操作
133. **return** filp; 
134. 
135. exit\_mutex\_unlock: 
136.  mutex\_unlock(&dir->d\_inode->i\_mutex); 
137. exit\_dput: 
138.  path\_put\_conditional(path, nd); 
139. exit: 
140. **if** (!IS\_ERR(nd->intent.open.file)) 
141.  release\_open\_intent(nd); 
142.  path\_put(&nd->path); 
143. **return** ERR\_PTR(error); 
144. \}

首先进行一些判断，然后看是否需要创建文件，如果需要创建的，则创建文件。如果文件存在的话，直接调用finish\_open完成文件打开，我们这里关注下打开文件的

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **static****struct** file \*finish\_open(**struct** nameidata \*nd, 
2.  **int** open\_flag, **int** acc\_mode) 
3.  \{ 
4.  **struct** file \*filp; 
5.  **int** will\_truncate; 
6.  **int** error; 
7.  
8.  /\*检测是否截断文件标志\*/
9.   will\_truncate = open\_will\_truncate(open\_flag, nd->path.dentry->d\_inode); 
10. **if** (will\_truncate) \{ /\*要截断的话就要获取写权限\*/
11.  error = mnt\_want\_write(nd->path.mnt); 
12. **if** (error) 
13. **goto** exit; 
14.  \} 
15. //may\_open执行权限检测、文件打开和truncate的操作
16.  error = may\_open(&nd->path, acc\_mode, open\_flag); 
17. **if** (error) \{ 
18. **if** (will\_truncate) 
19.  mnt\_drop\_write(nd->path.mnt); 
20. **goto** exit; 
21.  \} 
22.  filp = nameidata\_to\_filp(nd); /\*根据nameidata 得到相应的file结构\*/
23. **if** (!IS\_ERR(filp)) \{ 
24.  error = ima\_file\_check(filp, acc\_mode); 
25. **if** (error) \{ 
26.  fput(filp); 
27.  filp = ERR\_PTR(error); 
28.  \} 
29.  \} 
30. **if** (!IS\_ERR(filp)) \{ 
31. **if** (will\_truncate) \{ // //处理截断
32.  error = handle\_truncate(&nd->path); 
33. **if** (error) \{ 
34.  fput(filp); 
35.  filp = ERR\_PTR(error); 
36.  \} 
37.  \} 
38.  \} 
39. /\*
40.  \* It is now safe to drop the mnt write
41.  \* because the filp has had a write taken
42.  \* on its behalf.
43.  \*/
44. **if** (will\_truncate) //安全的放弃写权限
45.  mnt\_drop\_write(nd->path.mnt); 
46. **return** filp; 
47. 
48. exit: 
49. **if** (!IS\_ERR(nd->intent.open.file)) 
50.  release\_open\_intent(nd); 
51.  path\_put(&nd->path); 
52. **return** ERR\_PTR(error); 
53. \}

这里主要调用nameidata\_to\_filp得到相应的file结构

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **struct** file \*nameidata\_to\_filp(**struct** nameidata \*nd) 
2.  \{ 
3.  **const****struct** cred \*cred = current\_cred(); 
4.  **struct** file \*filp; 
5.  
6.  /\* Pick up the filp from the open intent \*/
7.   filp = nd->intent.open.file;/// 把相关 file结构的指针赋予 filp
8.  /\* Has the filesystem initialised the file for us? \*/
9.  **if** (filp->f\_path.dentry == NULL) 
10.  filp = \_\_dentry\_open(nd->path.dentry, nd->path.mnt, filp, 
11.  NULL, cred); 
12. **else**
13.  path\_put(&nd->path); 
14. **return** filp; 
15. \}

调用\_\_dentry\_open

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **static****struct** file \*\_\_dentry\_open(**struct** dentry \*dentry, **struct** vfsmount \*mnt, 
2.  **struct** file \*f, 
3.  **int** (\*open)(**struct** inode \*, **struct** file \*), 
4.  **const****struct** cred \*cred) 
5.  \{ 
6.  **struct** inode \*inode; 
7.  **int** error; 
8.  
9.   f->f\_mode = OPEN\_FMODE(f->f\_flags) | FMODE\_LSEEK |//初始化f\_mode
10.  FMODE\_PREAD | FMODE\_PWRITE; 
11.  inode = dentry->d\_inode; 
12. **if** (f->f\_mode & FMODE\_WRITE) \{ 
13.  error = \_\_get\_file\_write\_access(inode, mnt); 
14. **if** (error) 
15. **goto** cleanup\_file; 
16. **if** (!special\_file(inode->i\_mode)) 
17.  file\_take\_write(f); 
18.  \} 
19. 
20.  f->f\_mapping = inode->i\_mapping; 
21.  f->f\_path.dentry = dentry;//初始化目录项对象
22.  f->f\_path.mnt = mnt;//初始化文件系统对象
23.  f->f\_pos = 0; 
24.  f->f\_op = fops\_get(inode->i\_fop);//为文件操作建立起所有方法
25.  file\_move(f, &inode->i\_sb->s\_files);//把文件对象插入到文件系统超级块的s\_files字段所指向的打开文件的链表。
26. 
27.  error = security\_dentry\_open(f, cred); 
28. **if** (error) 
29. **goto** cleanup\_all; 
30. 
31. **if** (!open && f->f\_op)//传进来的open为NULL
32.  open = f->f\_op->open; 
33. **if** (open) \{ 
34.  error = open(inode, f); 
35. **if** (error) 
36. **goto** cleanup\_all; 
37.  \} 
38.  ima\_counts\_get(f); 
39. 
40.  f->f\_flags &= ~(O\_CREAT | O\_EXCL | O\_NOCTTY | O\_TRUNC);//初始化f\_f\_flags
41. 
42.  file\_ra\_state\_init(&f->f\_ra, f->f\_mapping->host->i\_mapping);//初始化预读的数据结构
43. 
44. /\* NB: we're sure to have correct a\_ops only after f\_op->open \*/
45. **if** (f->f\_flags & O\_DIRECT) \{ //检查直接IO操作是否可以作用于文件
46. **if** (!f->f\_mapping->a\_ops || 
47.  ((!f->f\_mapping->a\_ops->direct\_IO) && 
48.  (!f->f\_mapping->a\_ops->get\_xip\_mem))) \{ 
49.  fput(f); 
50.  f = ERR\_PTR(-EINVAL); 
51.  \} 
52.  \} 
53. 
54. **return** f; 
55. 
56. cleanup\_all: 
57.  fops\_put(f->f\_op); 
58. **if** (f->f\_mode & FMODE\_WRITE) \{ 
59.  put\_write\_access(inode); 
60. **if** (!special\_file(inode->i\_mode)) \{ 
61. /\*
62.  \* We don't consider this a real
63.  \* mnt\_want/drop\_write() pair
64.  \* because it all happenend right
65.  \* here, so just reset the state.
66.  \*/
67.  file\_reset\_write(f); 
68.  mnt\_drop\_write(mnt); 
69.  \} 
70.  \} 
71.  file\_kill(f); 
72.  f->f\_path.dentry = NULL; 
73.  f->f\_path.mnt = NULL; 
74. cleanup\_file: 
75.  put\_filp(f); 
76.  dput(dentry); 
77.  mntput(mnt); 
78. **return** ERR\_PTR(error); 
79. \}

这里主要是进行一些赋值操作

对应于这里，传进来的open指针为NULL，如果相应file\_operations结构存在的话就调用它的open函数

对于每个文件在创建 的时候会赋值对其进行操作的file\_operations结构，这个结构对于一类文件是一样的，例如 对应于字符设备是chrdev\_open

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **const****struct** file\_operations def\_chr\_fops = \{ 
2.   .open = chrdev\_open, 
3.  \};

但打开之后，我们可以重新获取它们的file\_operations结构，这个是在注册设备驱动的时候为该类设备赋予的，也就是我们在驱动里面实现的，而前面的缺省file\_operations就是为了完成这个转换的， def\_chr\_fops只起过渡作用，它的open方法要去寻找硬件驱动的支撑。

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **static****int** chrdev\_open(**struct** inode \*inode, **struct** file \*filp) 
2.  \{ 
3.  **struct** cdev \*p; 
4.  **struct** cdev \***new** = NULL; 
5.  **int** ret = 0; 
6.  
7.   spin\_lock(&cdev\_lock); 
8.   p = inode->i\_cdev; 
9.  **if** (!p) \{ /\* 很显然，第一次打开的时候是NULL \*/
10. **struct** kobject \*kobj; 
11. **int** idx; 
12.  spin\_unlock(&cdev\_lock); 
13.  kobj = kobj\_lookup(cdev\_map, inode->i\_rdev, &idx);/\* 找到和设备号i\_rdev对应的kobj，其实就是cdev了，因为cdev中包含kobj；idx保存的是次设备号，后面会分析kobj\_lookup()函数 \*/
14. **if** (!kobj) 
15. **return** \-ENXIO; 
16. **new** = container\_of(kobj, **struct** cdev, kobj);//得到cdev
17.  spin\_lock(&cdev\_lock); 
18. /\* Check i\_cdev again in case somebody beat us to it while
19.  we dropped the lock. \*/
20.  p = inode->i\_cdev; 
21. **if** (!p) \{ 
22.  inode->i\_cdev = p = **new**;/\* 把找到的cdev保存到inode的icdev中 \*/
23.  list\_add(&inode->i\_devices, &p->list); /\* inode加入到cdev的链表中 \*/
24. **new** = NULL; 
25.  \} **else****if** (!cdev\_get(p)) 
26.  ret = -ENXIO; 
27.  \} **else****if** (!cdev\_get(p)) 
28.  ret = -ENXIO; 
29.  spin\_unlock(&cdev\_lock); 
30.  cdev\_put(**new**); 
31. **if** (ret) 
32. **return** ret; 
33. 
34.  ret = -ENXIO; 
35. /\* 
36.  保存用户的fops，以后你再调用read, write, ioctl系统调用的时候就直接使用了，你懂的 
37.  \*/
38.  filp->f\_op = fops\_get(p->ops); 
39. **if** (!filp->f\_op) // 如果你没有注册fops
40. **goto** out\_cdev\_put; 
41. 
42. **if** (filp->f\_op->open) \{ //判断open函数是否存在
43.  ret = filp->f\_op->open(inode,filp);//\* 调用用户的open函数，我们前面写的驱动
44. **if** (ret) 
45. **goto** out\_cdev\_put; 
46.  \} 
47. 
48. **return** 0; 
49. 
50.  out\_cdev\_put: 
51.  cdev\_put(p); 
52. **return** ret; 
53. \}

在这个函数里，我们重新 对f\_op赋值了，这里的f\_op就是我们在写驱动时写的系统调用函数了。后面还调用了open方法

这里调用 kobj\_lookup找到前面我们在注册驱动添加设备时添加的相应的kobj

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **struct** kobject \*kobj\_lookup(**struct** kobj\_map \*domain, dev\_t dev, **int** \*index) 
2.  \{ 
3.  **struct** kobject \*kobj; 
4.  **struct** probe \*p; 
5.   unsigned **long** best = ~0UL; 
6.  
7.  retry: 
8.   mutex\_lock(domain->lock); 
9.  /\* 根据主设备号和设备号查找它的一亩三分地。因为要支持2^12次方也就是4096个主设备号，
10.  但只使用了前255个主设备号索引，所以这255个索引对应的probe结构都有一个单向
11.  链表保存着大于255的主设备号（被255整除后的索引相等） \*/
12. **for** (p = domain->probes\[MAJOR(dev) % 255\]; p; p = p->next) \{ 
13. **struct** kobject \*(\*probe)(dev\_t, **int** \*, **void** \*); 
14. **struct** module \*owner; 
15. **void** \*data; 
16. // 比较，看是否真找到了，因为有链表存在
17. **if** (p->dev > dev || p->dev + p->range - 1 < dev) 
18. **continue**; 
19. **if** (p->range - 1 >= best) 
20. **break**; 
21. **if** (!try\_module\_get(p->owner)) 
22. **continue**; 
23.  owner = p->owner; 
24.  data = p->data;//data就是cdev
25.  probe = p->get; 
26.  best = p->range - 1; 
27.  \*index = dev - p->dev;//得到次设备号
28. /\* 调用的lock就是exact\_lock()函数，增加对该字符设备驱动的引用，防止被卸载什么的 \*/
29. **if** (p->lock && p->lock(dev, data) < 0) \{ 
30.  module\_put(owner); 
31. **continue**; 
32.  \} 
33.  mutex\_unlock(domain->lock); 
34. /\*调用的probe就是exact\_match()函数，获取cdev的kobj指针 \*/
35.  kobj = probe(dev, index, data); 
36. /\* Currently ->owner protects \_only\_ ->probe() itself. \*/
37.  module\_put(owner); 
38. **if** (kobj) 
39. **return** kobj; 
40. **goto** retry; 
41.  \} 
42.  mutex\_unlock(domain->lock); 
43. **return** NULL; 
44. \}

到这里do\_filp\_open的流程就基本完成了，即返回了一个file结构

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **void** fd\_install(unsigned **int** fd, **struct** file \*file) 
2.  \{ 
3.  **struct** files\_struct \*files = current->files; 
4.  **struct** fdtable \*fdt; 
5.   spin\_lock(&files->file\_lock); 
6.   fdt = files\_fdtable(files);//获取fdtbale
7.   BUG\_ON(fdt->fd\[fd\] != NULL); 
8.   rcu\_assign\_pointer(fdt->fd\[fd\], file);//fd和file关系到fdtbale
9.   spin\_unlock(&files->file\_lock); 
10. \}

这样，我们的open系统调用就基本上完成了，我们得到一个fd，这个fd关联着一个file结构，这样以后，我们就可以通过这个fd结构操作相应的文件了。

[view plain]: http://blog.csdn.net/new_abc/article/details/7607731#

发表评论取消回复

表情：

评论列表（有 0 条评论，332人围观）

还没有评论，来说两句吧...

相关阅读

相关 Linux设备驱动程序——字符设备驱动编程

字符设备 Linux对设备的操作与对文件的操作是一样的，可以看到一个设备所对应的文件。我们平时用的read、write等函数也可以用于设备文件。字符设备： \-

迈不过友情╰/ 2022年06月04日 03:28/ 0 赞/ 394 阅读

相关 Linux字符设备驱动模型（一）

从事Linux开发也有几年时间了，期间也写了一些比较简单的驱动，但一直没有做系统的整理，今天终于想静下心来做一些整理，首先就从最基本的字符设备驱动开始。先贴出一个简单的字符设备

快来打我*/ 2022年04月18日 06:55/ 1 赞/ 626 阅读

相关 Linux字符设备驱动模型（二）

在[上一节][Link 1] 中讨论了字符设备的基本模型，本节在上一节的基础上继续完善，本节将增加`file_operations`中的`read`、`write`和`llse

淩亂°似流年/ 2022年04月17日 03:59/ 0 赞/ 333 阅读

相关 Linux设备模型－－驱动

linux中每个设备驱动由一个 struct device\_driver描述： 1. struct device\_driver \{ 2.

超、凢脫俗/ 2022年03月26日 17:36/ 0 赞/ 323 阅读

相关 Linux字符设备驱动基础（一）

Linux字符设备驱动基础（一） 1 Linux驱动分类 ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shado

素颜马尾好姑娘i/ 2022年01月21日 20:17/ 0 赞/ 349 阅读

相关 Linux字符设备驱动模型

<table> <thead> <tr> <th>版本</th> <th>颁布日期</th> <th>修订章节</th> </tr>

柔情只为你懂/ 2022年01月13日 12:47/ 0 赞/ 339 阅读

相关 Linux字符设备驱动——杂项设备驱动模型

文章目录杂项设备驱动模型杂项设备驱动的特征头文件核心结构杂项设备注册函数杂项设备注销

系统管理员/ 2022年01月13日 09:51/ 0 赞/ 530 阅读

相关 linux设备驱动模型一字符设备open系统调用流程

从前面的例子可以看到，我们在操作一个调和时都是通过open系统调用先去打开这个设备，不管是设备还是文件，我们要访问它都要称通过open函数来先打开，这样才能调用其它的函数

谁践踏了优雅/ 2022年01月09日 07:29/ 0 赞/ 333 阅读

相关 Linux字符设备驱动——经典标准字符模型

文章目录特征头文件注册函数注销函数设备号，设备驱动节点需要手动创建经典标准字符驱动模型驱动程序zx\_chr

矫情吗；*/ 2021年12月19日 19:45/ 0 赞/ 377 阅读

相关 Linux字符设备驱动——Linux2.6标准字符设备驱动模型

文章目录 Linux2.6标准字符设备特征 Linux2.6标准字符设备定义字符设备驱动结构体头文件设备号

你的名字/ 2021年12月12日 07:25/ 0 赞/ 486 阅读