【Linux】文件描述符 - fd

1. open 接口介绍

利用 man open 指令查察手册：

1. #include <sys/types.h>
2. #include <sys/stat.h>
3. #include <fcntl.h>
5. int open(const char *pathname, int flags);
6. int open(const char *pathname, int flags, mode_t mode);
8. pathname: 要打开或创建的目标文件
9. flags: 打开文件时，可以传入多个参数选项，用下面的一个或者多个常量进行“或”运算，构成flags。
10. 参数:
11.                 O_RDONLY: 只读打开
12.                 O_WRONLY: 只写打开
13.                 O_RDWR  : 读，写打开
14.                                   这三个常量，必须指定一个且只能指定一个
15.                 O_CREAT : 若文件不存在，则创建它。需要使用mode选项，来指明新文件的访问权限
16.                 O_APPEND: 追加写       
17. 返回值：
18.                 成功：新打开的文件描述符
19.                 失败：-1

复制代码

open 函数详细利用哪个，和详细应用场景有关。如：目标文件不存在，需要 open 创建，则第三个参数表示创建文件的默认权限；否则利用两个参数的 open。
write read close lseek ，类比 C 文件相关接口。
1.1 代码演示

操作文件，除了利用 C 语言的接口【Linux】回顾 C 文件接口，还可以采用体系接口来举行文件访问；
写文件：

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <sys/stat.h>
4. #include <fcntl.h>
5. #include <unistd.h>
6. #include <string.h>
8. int main()
9. {
10.     umask(0);
11.     int fd = open("myfile", O_WRONLY | O_CREAT, 0644);
12.     if (fd < 0)
13.     {
14.         perror("open");
15.         return 1;
16.     }
18.     int count = 5;
19.     const char* msg = "hello open!\n";
20.     int len = strlen(msg);
22.     while (count--)
23.     {
24.         write(fd, msg, len);
25.         // fd : 下面介绍
26.         // msg : 缓冲区首地址
27.         // len : 本次读取，期望写入多少个字节的数据
28.         // 返回值 : 实际写了多少字节数据
29.     }
31.     close(fd);
33.     return 0;
34. }

复制代码

读文件：

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <sys/stat.h>
4. #include <fcntl.h>
5. #include <unistd.h>
6. #include <string.h>
8. int main()
9. {
10.     int fd = open("myfile", O_RDONLY);
11.     if (fd < 0)
12.     {
13.         perror("open");
14.         return 1;
15.     }
16.    
17.     const char* msg = "hello open!\n";
18.     char buf[1024];
19.     while (1)
20.     {
21.         ssize_t s = read(fd, buf, strlen(msg)); // 类比write
22.         if (s > 0)
23.         {
24.             printf("%s", buf);
25.         }
26.         else
27.         {
28.             break;
29.         }
30.     }
32.     close(fd);
33.     return 0;
34. }

复制代码

1.2 open 函数返回值

在认识返回值之前，先来认识两个概念：体系调用 和 库函数 ：

• fopen fclose fread fwrite 都是 C 标准库当中的函数，我们称之为库函数（libc）；
  
• 而 open close read write lseek 都属于体系提供的接口，称之为体系调用接口；
  

• 体系调用接口与库函数的关系如上图；
  
• 以是，可以认为，f# 系列的函数，都是对体系调用的封装，方便二次开发。
  

2. 文件描述符 fd

• 文件描述符的本质，就是数组下标！！！
  

2.1 0 / 1 / 2

• Linux 历程默认情况下会有 3 个缺省打开的文件描述符，分别是标准输入 0，标准输出 1，标准错误 2；
  
• 0，1，2 对应的物理设备一样平常是：键盘，显示器，显示器；
  
• 以是输入输出也可以采用如下方式：
  

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <sys/stat.h>
4. #include <fcntl.h>
5. #include <string.h>
7. int main()
8. {
9.     char buf[1024];
10.     ssize_t s = read(0, buf, sizeof(buf));
11.     if (s > 0)
12.     {
13.         buf[s] = 0;
14.         write(1, buf, strlen(buf));
15.         write(2, buf, strlen(buf));
16.     }
17.     return 0;
18. }

复制代码

• 现在我们知道，文件描述符就是从 0 开始的小整数；
  
• 当我们打开文件时，操作体系在内存中要创建相应的数据结构来描述目标文件，于是就有了 file 结构体，表示一个已经打开的文件对象；
  
• 而历程实行 open 体系调用，就必须让历程和文件关联起来；
  
• 每个历程都有一个指针 *files ，指向一张表 files_struct ，该表最紧张的部门就是包含一个指针数组，每个元素都是一个指向打开文件的指针；
  
• 以是，本质上，文件描述符就是该数组的下标，只要拿着文件描述符，就可以找到对应的文件。
  

2.2 文件描述符的分配规则

直接看代码：

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <sys/stat.h>
4. #include <fcntl.h>
6. int main()
7. {
8.     int fd = open("myfile", O_RDONLY);
9.     if (fd < 0)
10.     {
11.         perror("open");
12.         return 1;
13.     }
14.     printf("fd: %d\n", fd);
16.     close(fd);
17.     return 0;
18. }

复制代码

输出发现是 fd: 3 ，
关闭 0 或者 2，再看：

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <sys/stat.h>
4. #include <fcntl.h>
6. int main()
7. {
8.     close(0);
9.     //close(2);
10.     int fd = open("myfile", O_RDONLY);
11.     if (fd < 0)
12.     {
13.         perror("open");
14.         return 1;
15.     }
16.     printf("fd: %d\n", fd);
18.     close(fd);
19.     return 0;
20. }

复制代码

发现结果是：fd: 0 或者 fd: 2 ，
可见，文件描述符的分配规则：在 files_struct 数组当中，找到当前没有被利用的最小的一个下标，作为新的文件描述符，会分配给最新打开的文件。
3. 重定向

那如果关闭 1 呢？看代码：

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <sys/stat.h>
4. #include <fcntl.h>
5. #include <stdlib.h>
7. int main()
8. {
9.     close(1);
10.     int fd = open("myfile", O_WRONLY | O_CREAT, 00644);
11.     if (fd < 0)
12.     {
13.         perror("open");
14.         return 1;
15.     }
16.     printf("fd: %d\n", fd);
17.     fflush(stdout);
19.     close(fd);
20.     exit(0);
21. }

复制代码

此时，我们发现，本来应该输出到显示器上的内容，输出到了文件 myfile 当中，其中 fd = 1。这种现象叫做输出重定向。
常见的重定向有：> ，>> ，< 。
那重定向的本质是什么呢？

3.1 dup2 体系调用函数

函数原型如下：

1. #include <unistd.h>
2. int dup2(int oldfd, int newfd);

复制代码

函数简介：

1. makes newfd be the copy of oldfd, closing newfd first if necessary, but note the following:
2. 将newfd设置为oldfd的副本，并在必要时先关闭newfd，但请注意以下事项:
4. *        If oldfd is not a valid file descriptor, then the call fails, and newfd is not closed.
5.         如果oldfd不是有效的文件描述符，则调用失败，newfd不会关闭。
7. *        If oldfd is a valid file descriptor, and newfd has the same value as oldfd, then dup2() does nothing, and returns newfd.
8.         如果oldfd是一个有效的文件描述符，并且newfd与oldfd具有相同的值，那么dup2()什么都不做，并返回newfd。

复制代码

示例代码：

1. #include <stdio.h>
2. #include <unistd.h>
3. #include <fcntl.h>
5. int main()
6. {
7.     int fd = open("./log", O_CREAT | O_RDWR, 0644);
8.     if (fd < 0)
9.     {
10.         perror("open");
11.         return 1;
12.     }
13.     close(1);
14.     dup2(fd, 1);
16.     int i = 0;
17.     for (i = 0; i < 5; i++)
18.     {
19.         char buf[1024] = { 0 };
20.         ssize_t read_size = read(0, buf, sizeof(buf) - 1);
21.         if (read_size < 0)
22.         {
23.             perror("read");
24.             break;
25.         }
26.         printf("%s", buf);
27.         fflush(stdout);
28.     }
29.     return 0;
30. }

复制代码

• printf 是 C 库当中的 IO 函数，一样平常往 stdout 中输出，但是 stdout 底层访问文件的时间，找的照旧 fd:1 ；
  
• 但此时 fd:1 下标所表示的内容已经酿成了 log 的地址，不再是显示器文件的地址；
  
• 以是，输出的任何消息都会往文件中写入，进而完成输出重定向。
  

4. FILE 与 缓冲区

• 由于 IO 相关函数与体系调用接口对应，并且库函数封装体系调用，以是本质上，访问文件都是通过 fd 访问的。
  
• 以是 C 库当中的 FILE 结构体内部，必定封装了 fd。
  
• 缓冲区就是一块内存区域，其存在目的是为了提升利用者的效率（用空间换时间）。
  
• 我们这里说的缓冲区是语言层面的缓冲区，也就是 C 自带的缓冲区，跟内核中的缓冲区没有关系。
  
• 缓冲区刷新方式：
  
  
  
  • 无缓冲 - 无刷新；
    
  • 行缓冲 - 行刷新 ：写满一行才刷新，我们平常写代码经常会碰到缓冲区的问题；
    
  • 全缓冲 - 全部刷新：在普通文件中写入时，缓冲区被写满，才刷新！
    
  • 欺压刷新：利用各种方法让缓冲区欺压刷新，如：fflush() 函数；
    
  • 自动刷新：程序退出的时间会自动刷新。
    
  
  

来段代码研究一下：

1. #include <stdio.h>
2. #include <string.h>
4. int main()
5. {
6.     const char* msg0 = "hello printf\n";
7.     const char* msg1 = "hello fwrite\n";
8.     const char* msg2 = "hello write\n";
10.     printf("%s", msg0);
11.     fwrite(msg1, strlen(msg0), 1, stdout);
12.     write(1, msg2, strlen(msg2));
14.     fork();
16.     return 0;
17. }

复制代码

运行出结果：

1. hello printf
2. hello fwrite
3. hello write

复制代码

但如果对历程实现输出重定向呢？./a.out > file ，我们发现结果酿成了：

1. hello write
2. hello printf
3. hello fwrite
4. hello peintf
5. hello fwrite

复制代码

我们发现 printf 和 fwrite（库函数）都输出了 2 次，而 write 只输出了一次（体系调用）。
为什么呢？肯定和 fork 有关：

• 一样平常 C 库函数写入文件是全缓冲的，而写入显示器是行缓冲。
  
• printf fwrite 库函数会自带缓冲区（进度条例子可以阐明【Linux】编写第一个小程序：进度条），当发生重定向到普通文件时，数据的缓冲方式由行缓冲酿成了全缓冲。
  
• 而我们放在缓冲区中的数据，就不会被立即刷新，纵然是 fork 之后；
  
• 但是历程退出之后，会统一刷新，写入文件当中。
  
• 但是 fork 的时间，父子数据会发生写时拷贝，以是当你父历程准备刷新的时间，子历程也就有了同样的一份数据，随即产生两份数据。
  
• write 没有变革，阐明没有所谓的缓冲。
  

综上：printf fwrite 库函数会自带缓冲区，而 write 体系调用没有带缓冲区。别的，我们这里所说的缓冲区，都是用户级缓冲区。实在为了提升整机性能，OS 也会提供相关内核级缓冲区，不外不在我们讨论范围之内。那这个缓冲区谁提供呢？printf fwrite 是库函数，writre 是体系调用，库函数在体系调用的“上层”，是对体系调用的“封装”，但是 write 没有缓冲区，而 printf fwrite 有，足以阐明，该缓冲区是二次加上的，又由于是 C，以是由 C 标准库提供。

---

   END
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告