🌠 作者：@阿亮joy.
🎆专栏：《学会Linux》
🎇 座右铭：每个优秀的人都有一段沉默的时光，那段时光是付出了很多努力却得不到结果的日子，我们把它叫做扎根
目录
- 👉重新谈论文件👈
- 👉回顾 C 语言的文件操作👈
- 👉文件操作的系统调用👈
- open
- write
- read
- 👉文件的深入理解👈
- 文件描述符
- 重定向
- 1. 输出重定向
- 2. 追加重定向
- 3. 输入重定向
- myshell 实现重定向
- Linux 下一切皆文件
- 👉总结👈
👉重新谈论文件👈
- 空文件也要占据磁盘空间。
- 文件等于文件内容加文件属性。
- 文件操作等于对文件内容的操作、对文件属性的操作或对文件内容和属性的操作。
- 标识一个文件，必须使用文件路径加文件名（具有唯一性）。
- 如果没有指明对应的文件路径，默认是在当前路径（进程的工作路径）进行文件访问。
- 当我们把 fopen、fclose、fread 和 fwrite 等接口写完之后，代码编译链接形成可执行程序之后，没运行可执行程序，文件对应的操作也没有被执行。故对文件的操作，本质是进程对文件的操作。
- 一个文件如果没有被打开，不可以进行文件访问。一个文件要被访问，就必须先被用户进程和操作系统打开。
- 并不是所有的磁盘文件都被打开了，磁盘文件可分为两种：被打开的文件和没有被打开的文件。所以，文件操作的本质是研究进程和被打开文件的关系。（注：文件系统里研究没有被打开的文件）
👉回顾 C 语言的文件操作👈
C 语言有文件操作，C++ 也有文件操作，任何一门语言都会有文件操作，而这些语言的操作接口都不一样！因为这些语言的文件操作接口都不一样，学习的成本是挺高的。那如何降低学习成本呢？我们知道：文件是在磁盘里的，磁盘是硬件。所有人想访问磁盘就不能绕过操作系统，那么开发者就必须使用操作系统提供的文件级别的系统调用接口。所以无论上层语言如何变化，库函数底层实现都必须调用系统调用接口。那么库函数可以千变万化，但是底层是不变的。那我们学习不变的东西，就可以降低学习成本了。
现在我们来回顾一下 C 语言的文件操作接口，再来学习文件操作的系统调用接口。
以 w 的方式打开文件
注：fprintf 函数可以将格式化的数据写到指定的流中。以 w 的方式打开文件，文件不存在会自动创建；如果文件存在，先清空文件的内容再进行写入。
#include <stdio.h>
#define FILE_NAME "log.txt"
int main()
{
// r(读,不存在则出错), w(写,不存在则创建), r+(读写,不存在则出错), w+(读写,不存在则创建)
// a(append,追加), a+(追加式写入)
FILE* fp = fopen(FILE_NAME, "w"); // 没有指明路径,默认在当前路径进行文件操作
if(fp == NULL)
{
perror("fopen");
return 1;
}
int cnt = 5;
while(cnt)
{
fprintf(fp,"%s:%d\n", "hello world", cnt--);
}
return 0;
}
以 r 的方式打开文件
#include <stdio.h>
#include <string.h>
#define FILE_NAME "log.txt"
int main()
{
// r(读,不存在则出错), w(写,不存在则创建), r+(读写,不存在则出错), w+(读写,不存在则创建)
// a(append,追加), a+(追加式写入)
FILE* fp = fopen(FILE_NAME, "r"); // 没有指明路径,默认在当前路径进行文件操作
if(fp == NULL)
{
perror("fopen");
return 1;
}
char buffer[64];
// 读取sizeof(buffer)-1个字符,为\0留一个位置
while(fgets(buffer, sizeof(buffer) - 1, fp) != NULL)
{
buffer[strlen(buffer) - 1] = '\0'; // 清除\n
puts(buffer);
}
return 0;
}
以 a 的方式打开文件
#include <stdio.h>
#define FILE_NAME "log.txt"
int main()
{
// r(读,不存在则出错), w(写,不存在则创建), r+(读写,不存在则出错), w+(读写,不存在则创建)
// a(append,追加), a+(追加式写入)
FILE* fp = fopen(FILE_NAME, "a"); // 没有指明路径,默认在当前路径进行文件操作
if(fp == NULL)
{
perror("fopen");
return 1;
}
int cnt = 5;
while(cnt)
{
fprintf(fp,"%s:%d\n", "hello world", cnt--);
}
return 0;
}
打开文件的方式
如上就是我们之前学的文件相关操作。还有 fseek、ftell 和 rewind 等函数，在 C 语言部分已经学习过，大家可以自行复习一下。
👉文件操作的系统调用👈
open
上面所使用的的 C 语言文件操作函数都是通过调用相应的系统调用接口的，fopen 函数对应的是系统调用 open，fwrite 等函数对应的是系统调用 write，fclose 函数对应的是系统调用 close。
系统调用 open 的参数和返回值
- 第一个参数：文件路径+文件名。只提供文件名，默认在当前路径进行文件操作。
- 第二个参数：打开文件的方式。该参数是通过宏来表示不同的打开方式，如：O_RDONLY 只读方式打开文件，O_WRONLY 只写方式打开文件等。通过按位或可以实现不同的文件打开方式，原因是这些宏都是通过比特位的不同来标记不同的选项，也就是说一个比特位就是一个选项。需要注意的是，比特位的位置不能重复。
- 第三个参数：创建文件的起始权限权限。为打开的文件设置不同的权限。使用 C 语言文件操作函数创建出来的文件默认权限是 664，文件的权限等于起始权限 & (~umask)，普通文件的起始权限是 666，目录文件的起始权限是 777。
- 成功打开文件时返回一个大于 0 的文件描述符，打开失败则返回 -1 并且设置错误码 errno。
O_RDONLY: 只读打开
O_WRONLY: 只写打开
O_RDWR : 读，写打开
这三个常量，必须指定一个且只能指定一个
O_CREAT : 若文件不存在，则创建它。需要使用mode选项，来指明新文件的访问权限
O_APPEND: 追加写
通过比特位来传递信息示例：
#include <stdio.h>
// 不同的标记位表示不同的选项
// 下面的每个宏对应的数值，只有一个比特位是1，彼此的位置不重叠
#define ONE (1<<0)
#define TWO (1<<1)
#define THREE (1<<2)
#define FOUR (1<<3)
void show(int flags)
{
if(flags & ONE) printf("ONE\n");
if(flags & TWO) printf("TWO\n");
if(flags & THREE) printf("THREE\n");
if(flags & FOUR) printf("FOUR\n");
}
int main()
{
show(ONE);
printf("--------------------\n");
show(TWO);
printf("--------------------\n");
show(ONE | TWO);
printf("--------------------\n");
show(ONE | TWO | THREE);
printf("--------------------\n");
show(ONE | TWO | THREE | FOUR);
return 0;
}
那么，系统调用 open 中的各种宏也是通过这种方式实现的。
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <assert.h>
#include <unistd.h>
#define FILE_NAME "log.txt"
int main()
{
int fd = open(FILE_NAME, O_WRONLY);
// assert(fd != -1);
if(fd < 0)
{
perror("open");
return 1;
}
close(fd); // close关闭文件,参数是对应的文件描述符
return 0;
}
宏 O_WRONLY 只是写，没有对应的文件就打开失败，并不是没有对应的文件就自动创建。如果想要没有对应文件就自动创建，想要按位或上 O_CREAT。
现在虽然没有出错，但是创建出来的文件的权限却是全乱的。如果想要创建出来的文件的权限是不乱的，就需要传入 open 的第三个参数。
如果我们不想要系统默认的权限掩码，可以通过 umask 函数来设置。
write
打印被打开文件的文件描述符
关于为什么被打开文件的文件描述符是 3，会在后面的内容里讲解，这也是埋下的一个小小的伏笔。
提示内容：在语言层面上，文件是分文本类文件和二进制类文件的；但再操作系统层面上，文件都是二进制的。
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <assert.h>
#include <unistd.h>
#define FILE_NAME "log.txt"
int main()
{
umask(0); // 将权限掩码设置为0,文件的最终权限等于起始权限&(~umask)
int fd = open(FILE_NAME, O_WRONLY | O_CREAT, 0666);
if(fd < 0)
{
perror("open");
return 1;
}
int cnt = 5;
char outBuffer[64];
while(cnt)
{
sprintf(outBuffer, "%s:%d\n", "hello world", cnt--);
// C语言规定以\0作为字符串的结尾, 但与文件没有任何的关系, 所以下面的strlen不需要+1
write(fd, outBuffer, strlen(outBuffer));
}
//printf("fd:%d\n", fd);
close(fd); // close关闭文件,参数是对应的文件描述符
return 0;
}
如果我们上面的代码改成下面的样子，再运行起来并查看文件会出现上面情况呢？
可以看到：write 是覆盖式写入的，并不是先清空文件里的内容再进行写入。但是 C 语言的写入不是这样子的呀，C 语言的文件操作函数是对系统调用的封装。如果我们也想要实现文件存在时，先清空文件的内容再进行写入的话，还需要给 open 多传入一个宏 O_TRUNC。
所以，C语言的fopen(FILE_NAME, "w")对应的系统调用就是open(FILE_NAME, O_WRONLY | O_CREAT | O_TRUNC, 0666)。如果想以追加的方式向文件写入的话，只需要再给 open 再传入一个宏 O_APPEND。注：O_APPEND 不要和 O_TRUNC 一起使用。
read
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <assert.h>
#include <unistd.h>
#define FILE_NAME "log.txt"
int main()
{
umask(0); // 将权限掩码设置为0,文件的最终权限等于起始权限&(~umask)
//int fd = open(FILE_NAME, O_WRONLY | O_CREAT | O_APPEND, 0666);
int fd = open(FILE_NAME, O_RDONLY);
if(fd < 0)
{
perror("open");
return 1;
}
char buffer[1024];
ssize_t num = read(fd, buffer, sizeof(buffer) - 1); // 减1的原因是给\0留一个位置
if(num > 0) buffer[num] = '\0';
printf("%s", buffer);
return 0;
}
库函数与系统调用的关系
👉文件的深入理解👈
文件描述符
在前面已经提到过：文件操作的本质就是进程和被打开文件的关系。进程是可以代开多个文件的，那么系统中一定会存在大量的被打开的文件的。这些被打开的文件，就要被操作系统管理起来。管理的本质是先描述再组织。操作系统为了管理对应的打开文件，必定要为文件创建对应的内核数据结构来表示文件，而这个内核数据结构就是struct file，其包含了文件的大部分属性。注：struct file和 C 语言的FILE不是一样的东西。
那接下来，我们就来学习进程是如何和被打开文件关联起来的！
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <assert.h>
#include <unistd.h>
// #的作用是将宏参数转化成字符串并与其他字符串连接起来
#define FILE_NAME(number) "log.txt"#number
int main()
{
umask(0); // 将权限掩码设置为0,文件的最终权限等于起始权限&(~umask)
int fd0 = open(FILE_NAME(0), O_WRONLY | O_CREAT | O_APPEND, 0666);
int fd1 = open(FILE_NAME(1), O_WRONLY | O_CREAT | O_APPEND, 0666);
int fd2 = open(FILE_NAME(2), O_WRONLY | O_CREAT | O_APPEND, 0666);
int fd3 = open(FILE_NAME(3), O_WRONLY | O_CREAT | O_APPEND, 0666);
int fd4 = open(FILE_NAME(4), O_WRONLY | O_CREAT | O_APPEND, 0666);
printf("fd0:%d\n", fd0);
printf("fd1:%d\n", fd1);
printf("fd2:%d\n", fd2);
printf("fd3:%d\n", fd3);
printf("fd4:%d\n", fd4);
close(fd0);
close(fd1);
close(fd2);
close(fd3);
close(fd4);
return 0;
}
看到上面连续的小整数，我想大家肯定能够想到数组的下标，那么我们可以猜测文件描述符可能与数组有关。那为什么是从 3 开始的呢？0、1、2 那哪去了？在学习 C 语言的时候，我们学到过 C 语言程序会默认打开三个流：stdin（标准输入流：键盘）、stdout（标准输出流：显示器）和 stderr（标准错误流：显示器）。这三个流的类型都是FILE*，而FILE是结构体。C 语言进行文件操作是使用的是FILE*，而操作系统使用的是文件描述符fd，那么结构体FILE中肯定包含文件描述符fd。所以 0、1、2 就被这三个流使用了。
写个程序来验证上面的说法
理解文件描述符的本质
文件描述符的本质是进程的文件描述符表的下表，也就是数组下标！！！进程与被打开文件的关系：进程通过文件描述符表指向对应的被打开的文件。
文件描述符的分配规则
按顺序从小到大查找文件描述符表，最小的且没有被占用的 fd 就会分配给被打开的文件。
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <assert.h>
int main()
{
umask(0);
int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
assert(fd != -1);
printf("fd:%d\n", fd);
close(fd);
return 0;
}
关闭 0
关闭 2
关闭 0 和 2
重定向
那如果我们只把 1 关掉会怎么样呢？
将程序运行起来，我们可以发现并没有向显示器上打印信息。原因也非常的简单，因为我们把标准输出（显示器）给关掉了。又因为 printf 函数是向 stdout 上打印的，stdout 的 文件描述符为 1，而当前 1 号文件描述符执行的是我们自己创建的文件，所以数据就被打印到了该文件中了。注：需要刷新 stdout 才能看到信息。
如果我们没有关掉 1，数据就会被打印到显示器上；而如果我们关掉了 1，数据就被打印到了文件里。那么这种现象就叫做重定向。常见的重定向：输出重定向>、追加重定向>>和输入重定向<。重定向的本质是：上层使用的 fd 不变，在内核中更改 fd 对于的struct file*的地址。
如果重定向先要关闭 1，才能进行重定向的话，这就有点挫了。系统为了支持我们更好地进行重定向，给我们提供了一个系统调用dup2。
请简述重定向的实现原理：
每个文件描述符都是一个内核中文件描述信息数组的下标，对应有一个文件的描述信息用于操作文件，而重定向就是在不改变所操作的文件描述符的情况下，通过改变描述符对应的文件描述信息进而实现改变所操作的文件。
1. 输出重定向
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <assert.h>
int main()
{
umask(0);
int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
assert(fd != -1);
dup2(fd, 1); // 将fd的内容拷贝到1中
printf("open fd:%d\n", fd); // printf -> stdout
fprintf(stdout, "open fd:%d\n", fd); // fprintf -> stdout
fflush(stdout); // 刷新缓冲区
close(fd);
return 0;
}
2. 追加重定向
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <assert.h>
#include <string.h>
int main()
{
umask(0);
int fd = open("log.txt", O_WRONLY | O_CREAT | O_APPEND, 0666);
assert(fd != -1);
dup2(fd, 1); // 将fd的内容拷贝到1中
printf("open fd:%d\n", fd); // printf -> stdout
fprintf(stdout, "open fd:%d\n", fd); // fprintf -> stdout
const char* msg = "It's Crazy Thursday. Give me 50 yuan\n";
write(1, msg, strlen(msg));
fflush(stdout); // 刷新缓冲区
close(fd);
return 0;
}
3. 输入重定向
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <assert.h>
#include <string.h>
int main()
{
int fd = open("log.txt", O_RDONLY);
assert(fd != -1);
dup2(fd, 0); // 将fd的内容拷贝到0中
char line[64];
while(1)
{
printf("< ");
// 读取结束退出while循环
if(fgets(line, sizeof(line) - 1, stdin) == NULL)
break;
printf("%s", line);
}
close(fd);
return 0;
}
myshell 实现重定向
- 因为命令是子进程执行的真正重定向的工作一定是子进程执行的
- 如何重定向，是父进程要给子进程提供信息
- 重定向不会影响父进程,因为进程具有独立性
- 进行重定向时，子进程会发生写实拷贝，拷贝父进程的 PCB 和文件描述符表，再来修改自己的文件描述符表进行重定向
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#define NUM 1024
#define OPT_NUM 64 // 命令行参数的最多个数
#define NONE_REDIR 0 // 无重定向
#define INPUT_REDIR 1 // 输入重定向
#define OUTPUT_REDIR 2 // 输出重定向
#define APPEDN_REDIR 3 // 追加重定向
// 过滤空格
#define trimSpace(start) do{ while(isspace(*start)) ++start; }while(0)
char lineCommand[NUM];
char* myargv[OPT_NUM];
// 上一个进程的退出信息
int lastCode = 0;
int lastSignal = 0;
int redirType = NONE_REDIR; // 重定向类型默认为无重定向
char* redirFile = NULL; // 重定向的文件名
// "ls -a -l > myfile.txt" -> "ls -a -l" "myfile.txt"
void commandCheck(char* commands)
{
// 重置重定向信息
redirType = NONE_REDIR;
redirFile = NULL;
// 重置错误码
errno = 0;
assert(commands);
char* start = commands;
char* end = commands + strlen(commands);
while(start < end)
{
if(*start == '>')
{
*start = '\0';
++start;
if(*start == '>')
{
// "ls -a >> myfile.txt"
redirType = APPEDN_REDIR; // 追加重定向
++start;
}
else
{
// "ls -a > myfile.txt"
redirType = OUTPUT_REDIR; // 输出重定向
}
trimSpace(start); // 过滤空格
redirFile = start;
break;
}
else if(*start == '<')
{
// "cat < myfile.txt"
*start = '\0'; // 将字符串分割成两部分
++start;
trimSpace(start); // 过滤空格
// 填写重定向信息
redirType = INPUT_REDIR; // 输入重定向
redirFile = start;
break;
}
else
{
++start;
}
}
}
int main()
{
while(1)
{
char* user = getenv("USER");
// 根据用户输出对应的提示信息, get_current_dir_name函数可以获得当前的工作路径
if(strcmp(user, "root") == 0)
{
printf("[%s@%s %s]# ", user, getenv("HOSTNAME"), get_current_dir_name());
}
else
{
printf("[%s@%s %s]$ ", user, getenv("HOSTNAME"), get_current_dir_name());
}
fflush(stdout); // 刷新缓冲区
// 获取用户输入
char* s = fgets(lineCommand, sizeof(lineCommand) - 1, stdin);
assert(s != NULL);
// 清除最后一个\n, abcd\n
lineCommand[strlen(lineCommand) - 1] = 0;
// 字符串切割:"ls -a -l" -> "ls" "-a" "-l"
// "ls -a -l > myfile.txt" -> "ls -a -l" "myfile.txt"
// "cat < myfile.txt" -> "cat" "myfile.txt"
commandCheck(lineCommand); // 如果有重定向,则将字符串拆成两部分
myargv[0] = strtok(lineCommand, " ");
int i = 1;
// 因为无法执行"ll"指令, 所以这里做一下处理
if(myargv[0] != NULL && strcmp(myargv[0], "ll") == 0)
{
myargv[0] = "ls";
myargv[i++] = "-l";
}
if(myargv[0] != NULL && strcmp(myargv[0], "ls") == 0)
{
myargv[i++] = "--color=auto";
}
// 如果切割完毕, strtok返回NULL, myargv[end] = NULL
while(myargv[i++] = strtok(NULL, " "));
// 如果是cd命令, 不需要创建子进程来执行, 让当前进程的父进程shell执行对应的命令, 本质就是调用系统接口
// 像这种不需要创建子进程来执行, 而是让shell自己执行的命令, 称为内建命令或者内置命令
// echo和cd就是一个内建命令
if(myargv[0] != NULL && strcmp(myargv[0], "cd") == 0)
{
// 如果cd命令没有第二个参数, 则切换到家目录
if(myargv[1] == NULL)
{
chdir(getenv("HOME")); // 更改到家目录
}
else
{
if(strcmp(myargv[1], "-") == 0) // 该功能还有BUG, 因为环境变量的问题
{
chdir(getenv("OLDPWD")); // 回到上一次所处的路径
}
else if(strcmp(myargv[1], "~") == 0)
{
chdir(getenv("HOME")); // 去到家目录
}
else
{
chdir(myargv[1]); // 更改到指定目录
}
}
continue; // 不创建子进程, continue回到while循环处
}
// 实现echo命令, 当前的echo命令功能也不是很全
if(myargv[0] != NULL && myargv[1] != NULL && strcmp(myargv[0], "echo") == 0)
{
if(strcmp(myargv[1], "$?") == 0)
{
printf("%d, %d\n", lastSignal, lastCode);
}
else
{
printf("%s\n", myargv[1]);
}
continue;
}
// 创建子进程来执行命令
pid_t id = fork();
assert(id != -1);
// child process
if(id == 0)
{
// 因为命令是子进程执行的,真正重定向的工作一定是子进程执行的
// 如何重定向,是父进程要个子进程提供信息
// 这里的重定向不会影响父进程,因为进程具有独立性
switch(redirType)
{
case NONE_REDIR:
// 什么都不做
break;
case INPUT_REDIR:
{
ssize_t fd = open(redirFile, O_RDONLY);
if(fd < 0)
{
perror("open");
exit(errno);
}
// 重定向的文件已经成功打开了
dup2(fd, 0);
}
break;
case OUTPUT_REDIR:
case APPEDN_REDIR:
{
int flags = O_WRONLY | O_CREAT;
if(redirType == APPEDN_REDIR) flags |= O_APPEND;
else flags |= O_TRUNC;
ssize_t fd = open(redirFile, flags, 0666);
if(fd < 0)
{
perror("open");
exit(errno);
}
dup2(fd, 1); // ls等指令执行结果是打印在显示器上的
}
break;
default:
printf("error\n");
break;
}
execvp(myargv[0], myargv); // 执行程序替换的时候,不会影响曾经进程打开的重定向的文件,因为程序替换只是替换代码和数据
exit(errno); // 进程替换失败
}
int status = 0;
pid_t ret = waitpid(id, &status, 0); // 阻塞等待
assert(ret > 0);
lastCode = ((status >> 8) & 0xFF);
lastSignal = (status & 0x7F);
}
return 0;
}
myshell 重定向演示使用
当进程退出时，曾经被打开的文件会被关闭。
Linux 下一切皆文件
在之前的博客里说过：Linux 系统下一切皆文件。那 Linux 系统是如何做到一切皆文件的呢？我们又如何理解 Linux 下一切皆文件呢？见下图：
struct file 内包含引用计数，打开该文件的进程退了，则引用计数减减。当该计数为 0 时，操作系统才会释放这个被打开的文件。
文件的操作方法
👉总结👈
本篇博客主要讲解了文件操作的库函数和系统调用，深入了解文件、文件描述符、重定向以及为什么 Linux 下一切皆文件。那么以上就是本篇博客的全部内容了，如果大家觉得有收获的话，可以点个三连支持一下！谢谢大家！💖💝❣️
