（19）Linux系统下的文件操作 && 文件系统接口

2024-01-07 18:07:25

前言：本篇主要讲解底层文件系统接口，详细介绍 open 接口和它的 flags 参数 (即系统传递标记位)，重点讲解?O_RDWR, O_RDONLY, O_WRONLY, O_CREAT 和 O_APPEND 这些操作模式。

一、先来段代码回顾C文件接口?

hello.c写文件?

#include <stdio.h>
#include <string.h>
int main()
{
 FILE *fp = fopen("myfile", "w");
 if(!fp){
 printf("fopen error!\n");
 }
 const char *msg = "hello bit!\n";
 int count = 5;
 while(count--){
 fwrite(msg, strlen(msg), 1, fp);
 }
 fclose(fp);
 return 0;
}

?hello.c读文件

#include <stdio.h>
#include <string.h>
int main()
{
 FILE *fp = fopen("myfile", "r");
 if(!fp){
 printf("fopen error!\n");
 }
 char buf[1024];
 const char *msg = "hello bit!\n";
 while(1){
 //注意返回值和参数，此处有坑，仔细查看man手册关于该函数的说明
 ssize_t s = fread(buf, 1, strlen(msg), fp);
 if(s > 0){
 buf[s] = 0;
 printf("%s", buf);
 }
 if(feof(fp)){
 break;
 }
 }
 fclose(fp);
 return 0;
}

?输出信息到显示器，你有哪些方法

#include <stdio.h>
#include <string.h>
int main()
{
 const char *msg = "hello fwrite\n";
 fwrite(msg, strlen(msg), 1, stdout);
 printf("hello printf\n");
 fprintf(stdout, "hello fprintf\n");
 return 0;
}

1、关于文件操作的思考

我们曾经讲过：文件 = 文件内容 + 文件属性??①

文件属性也是数据！这意味着，即便你创建一个空文件，也要占据磁盘空间！所以：

????????????????????????????????② 文件操作 = 文件内容的操作 + 文件属性的操作?

?因此，在操作文件的过程中，既改变内容又改变属性的情况很正常，不要把它们割裂开来！

那么，所谓的 "打开" 文件，究竟在做什么？?③?

"打开文件不是目的，访问文件才是目的！"?

访问文件时，都是要通过 fread,fwrite,fgets... 这样的代码来完成对文件的操作的，

如果通过这些方式，那么 "打开" 文件就需要将文件的属性或内容加载到内存 (memory) 中！

因为这是由冯诺依曼体系结构决定的，将来 \textrm{CPU} 要执行 fread,fwrite 来对文件进行读写的。

?既然如此……??是不是所有的文件都会处于被打开的状态呢？并不是！?④

那没有被打开的文件在哪里？

对于文件的理解，在宏观上我们可以区分成?内存文件 (打开的文件) 和 磁盘文件。?⑤ (存储在磁盘中)?

⑥ 通常我们打开文件、访问文件和关闭文件，是谁在进行相关操作？

运行起来的时候，才会执行对应的代码，然后才是真正的对文件进行相关的操作。
实际上是? 进程在对文件进行操作！在系统角度理解是我们曾经写的代码变成了进程。

进程执行调度对应的代码到了 fopen,write 这样的接口，然后才完成了对文件的操作。
当我执行 fopen 时，对应地就把文件打开了，所以文件操作和进程之间是撇不开关系。

🔺 结论：学习文件操作，实际上就是学习 "进程" 与 "打开文件" 的关系。 ⑦
?

2、当前路径（Current Path）

文件的本质实际上是进程与打开文件之间的关系。

?因此文件操作和进程有关系，我们写一下我们的代码，获取进程 $\textrm{pid}$ ，查一下进程信息：

#include <stdio.h>
#include <unistd.h>
 
int main(void)
{
    FILE* pf = fopen("log.txt", "w"); // 写入
    if (pf == NULL) {
        perror("fopen");
        return 1;
    }
 
    /* 获取进程 pid */
    printf("Mypid: %d\n", getpid());
 
    /* 打开文件后，等一等，方便查询 */
    while (1) {
        sleep(1);
    }
 
    const char* msg = "hello!";
    int count = 1;
    while (count <= 10) {
        fprintf(pf, "%s: %d\n", msg, count++);
    }
 
    fclose(pf);
}

getpid?拿到进程? $\textrm{pid}$ ?后，得益于 "昏睡指令" while(1){sleep(1);)?

我们的进程就一直的跑着，再打开一个窗口，通过 $ls?proc?指令检视该进程信息：

我们重点关注? $\textrm{exe}$ ?和? $\textrm{cwd}$ ， $\textrm{exe}$ ?后面链接指向的是可执行程序 mytest，即?路径 + 程序名。

而? $\textrm{cwd}$ ?(current working directory)，即 当前工作目录，记录着当前进程所处的路径！

每个进程都有一个工作路径，所以我们上一节实现的简单? $\textrm{shell}$ 程序可以用 chdir?更改路径。

创建文件时，如果文件在当前目录下不存在，fopen?会默认在当前路径下自动创建文件。

?默认创建在当前路径，和源代码、可执行程序在同一个路径下，因为这取决于? $\textrm{cwd}$ ：

cwd -> /home/ayf/lesson1

所以，当前路径更准确的说法应该是：在当前进程所处的工作路径。

" 当前路径指的是在当前进程所处的工作路径 "

只不过默认情况下 (默认路径) ，一个进程的工作路径在它当前所处的路径而已，这是可以改的。

所以我们在写文件操作代码时，不带路径默认是源代码所在的路径，注意是默认！而已！

3、文件操作模式（File Operation Mode）?

由文件操作符 (mode) 参数来指定，常用的模式包括：

man fopen

r：只读模式，打开一个已存在的文本文件，允许读取文件。
 
r+：读写模式，打开一个已存在的文本文件，允许读写文件。
 
w：只写模式，打开一个文本文件并清除其内容，如果文件不存在，则创建一个新文件。
 
w+：读写模式，打开一个文本文件并清除其内容，如果文件不存在，则创建一个新文件。
 
a：追加模式，打开一个文本文件并将数据追加到文件末尾，如果文件不存在，则创建一个新文件。
 
a+：读写模式，打开一个文本文件并将数据追加到文件末尾，如果文件不存在，则创建一个新文件。

?这里我们重点讲一下 a?和 a+

a 对应的是 appending 的首字母，意为 "追加" 。属于写入操作，不会覆盖源文件内容。

代码演示：测试追加效果

每次运行都会在 test.txt?里追加，我们多试几次看看：

a(append)?追加写入，可以不断地将文件中新增内容。（这让我联想到了追加重定向）

不同于 w，当我们以 w?方式打开文件准备写入的时候，其实文件已经先被清空了。

4、文件的读取（File Read）?

我们复习一下文本行输入函数?fgets，它可以从特定的文件流中，以行为单位读取特定的数据：?

char* fgets(char* s, int size, FILE* stream);_

?代码演示：fgets()

#include <stdio.h>
 
int main(void)
{
    FILE* pf = fopen("log.txt", "r"); // 读
    if (pf == NULL) {
        perror("fopen");//显示错误信息
        return 1;
    }
 
    char buffer[64];  // 用来存储
    while (fgets(buffer, sizeof(buffer), pf) != NULL) {
        // 打印读取到的内容
        printf("echo: %s", buffer);
    }
 
    fclose(pf);
}

运行结果如下：

?我们下面再来实现一个类似 $cat?的功能，输入文件名打印对应文件内容。

代码演示：实现一个自己的?cat

#include <stdio.h>
 
/* 读什么就打什么   mycat */
int main(int argc, char* argv[]) 
{
    if (argc != 2) {
        printf("Usage: %s filename\n", argv[0]);
        return 1;
    }
 
    FILE* pf = fopen(argv[1], "r");    // 读取
    if (pf == NULL) {
        perror("fopen");
        return 1;
    }
 
    char buffer[64];
    while (fgets(buffer, sizeof(buffer), pf) != NULL) {
        printf("%s", buffer);
    }
 
    fclose(pf);
}

读到什么就打印身边。

如果再把可执行程序 mytest?改名成 cat，$mv mytest cat?，

?我们就实现了一个自己的 cat?代码。

二、文件系统接口（Basic File IO）

操作文件，除了上述C接口（当然，C++也有接口，其他语言也有），我们还可以采用系统接口来进行文件访问，先来直接以代码的形式，实现和上面一模一样的代码：?

写文件：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
int main()
{
 umask(0);
 int fd = open("myfile", O_WRONLY|O_CREAT, 0644);
 if(fd < 0){
 perror("open");
 return 1;
 }
 int count = 5;
 const char *msg = "hello world!\n";
 int len = strlen(msg);
 while(count--){
 write(fd, msg, len);//fd: 后面讲， msg：缓冲区首地址， len: 本次读取，期望写入多少个字节的数
据。 返回值：实际写了多少字节数据
 }
 close(fd);
 return 0;
}

?读文件：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
int main()
{
 int fd = open("myfile", O_RDONLY);
 if(fd < 0){
 perror("open");
 return 1;
 }
 const char *msg = "hello world!\n";
 char buf[1024];
 while(1){
 ssize_t s = read(fd, buf, strlen(msg));//类比write
 if(s > 0){
 printf("%s", buf);
 }else{
 break;
 }
 }
 close(fd);
 return 0;
}

1、系统调用与封装（Syscall and Wrapper）?

当我们向文件写入时，最终是不是向磁盘写入？是！磁盘是硬件吗？就是硬件。

当我们像文件写入时，最后是向磁盘写入。磁盘是硬件，那么谁有资格向磁盘写入呢？

只能是操作系统！

既然是操作系统在写入，那我们自然不能绕开操作系统对磁盘硬件进行访问。

因为操作系统是对软硬件资源进行管理的大手子，你的任何操作都不能越过操作系统！

?所有的上层访问文件的操作，都必须贯穿操作系统。

想要被上层使用，必须使用操作系统的相关的 系统调用 (syscall)?！

回顾：：如何理解 printf？我们怎么从来没有见过这些系统调用接口呢？

显示器是硬件，我们 printf 的消息打印到了硬件上，是你自己调用的 printf 打印到硬件上的，

但并不是你的程序显示到了显示器上，因为显示器是硬件，它的管理者只能是操作系统，

你不能绕过操作系统，而必须使用对应的接口来访问显示器，我们看到的 printf 一打，

内容就出现在屏幕上，实际上在函数的内部，一定是调用了系统调用接口的。

?结论：printf?函数内部一定封装了系统调用接口。

所有的语言提供的接口，之所以你没有见到系统调用，因为所有的语言都被系统接口做了?封装。

所以你看不到对应的底层的系统接口的差别。为什么要封装？原生系统接口，使用成本比较高。

系统接口是 OS 提供的，就会带来一个问题：如果使用原生接口，你的代码只能在一个平台上跑。

直接使用原生系统接口，必然导致语言不具备 跨平台性 (Cross-platform) ！

如果语言直接使用操作系统接口，那么它就不具备跨平台性，可是为什么采用封装就能解决？

封装是如何解决跨平台问题的呢？很简单：

????????????????????????????????" 穷举所有的底层接口 + 条件编译 "

结论：我们学习的接口，C 库提供的文件访问接口，系统调用。它们两具有上下层关系，C 底层一定会调用这些系统调用接口。

解释：不同的语言，有不同的文件访问接口。
系统调用：这就是我什么我们必须学习文件级别的系统接口！

?2、文件打开：open()

打开文件，在 C 语言上是?fopen，在系统层面上是?open。

open 接口是我们要学习的系统接口中最重要的一个，没有之一！所以我们放到前面来讲。

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
int open(const char* pathname, int flags);
int open(const char* pathname, int flags, mode_t mode);

我们看到，这个 open 接口一个是两参数的，一个是三参数的，这个我们放到后面解释。

?open 接口的 pathname 参数表示要打开的文件名，和 C 语言的 fopen 一样，是要带路径的。
?flags 参数是打开文件要传递的选项，即系统传递标记位，我们下面会重点讲解。
?mode 参数，就是 "文件操作模式" 了。

#if (defined _CRT_DECLARE_NONSTDC_NAMES && _CRT_DECLARE_NONSTDC_NAMES) || (!defined _CRT_DECLARE_NONSTDC_NAMES && !__STDC__)
    #define O_RDONLY     _O_RDONLY
    #define O_WRONLY     _O_WRONLY
    #define O_RDWR       _O_RDWR
    #define O_APPEND     _O_APPEND
    #define O_CREAT      _O_CREAT
    #define O_TRUNC      _O_TRUNC
    #define O_EXCL       _O_EXCL
    #define O_TEXT       _O_TEXT
    #define O_BINARY     _O_BINARY
    #define O_RAW        _O_BINARY
    #define O_TEMPORARY  _O_TEMPORARY
    #define O_NOINHERIT  _O_NOINHERIT
    #define O_SEQUENTIAL _O_SEQUENTIAL
    #define O_RANDOM     _O_RANDOM
#endif

思考：在 Linux 下，C 语言中文件不存在，就直接创建它，创建是不是需要权限？

当然是需要的，我们需要给文件设置初始权限，这个 mode 参数就是干这个活的。

我们再来看看这个接口的返回值，居然是个 int，而不是我们 fopen 的 FILE*?

?open 的返回值是个 int，返回 -1 表示 error，并设置 errno。

3、flags 系统传递标记位

我们可以输入 man 2 open? 看看如何设置 flags 参数，实际上就是设置文件操作模式的。

我们重点关注下面这几个文件操作模式，它们被定义在 <fcntl.h> 头文件中：

?O 实际上就是 Open 的意思，它们的用途通过名字不难猜：

O_RDONLY: 只读打开
O_WRONLY: 只写打开
O_RDWR : 读，写打开这三个常量，必须指定一个且只能指定一个
O_CREAT : 若文件不存在，则创建它。需要使用mode选项，来指明新文件的访问权限
O_APPEND: 追加写

返回值：

成功：新打开的文件描述符
失败：-1?

int open(const char* pathname, int flags);

我们称 flags 为 标记位，并且它是个整数类型（C99 标准之前没有 bool 类型)?

标记位实际上我们造就用过了，比如定义 flag 变量，设 flag=0，设 flag=1，传的都是单个的。

?思考：但如果我想一次传递多个标志位呢？定义多个标记位？flag1, flag2, flag3...

方案：系统传递标记位是通过位图来进行传递的。

想必大家已经对位图不陌生了，在前几章我们讲解 waitpid 的 status 参数时就介绍过了：

status 参数也是整型，也是被当作一个 "位图结构" 看待的，这里的 flags 也是如此！

当成位图，就是一串整数 $0000\, 0000$ 。

我们可以让不同的位表示，是否只读，是否只写，是否读写…… 等等等等：?

每个宏标记一般只需要满足有一个比特位是 1，并且和其它宏对应的值不重叠即可。?

代码演示：我们创建一个 test.c?

#include <stdio.h>
 
#define PRINT_A   0x1     // 0000 0001
#define PRINT_B   0x2     // 0000 0010
#define PRINT_C   0x4     // 0000 0100
#define PRINT_D   0x8     // 0000 1000
#define PRINT_DFL 0x0
 
// open
void Show (
    int flags  /* 传递标志位 */
    )
{
    if (flags & PRINT_A)     printf("Hello A\n");
    if (flags & PRINT_B)     printf("Hello B\n");
    if (flags & PRINT_C)     printf("Hello C\n");
    if (flags & PRINT_D)     printf("Hello D\n");
    if (flags == PRINT_DFL)  printf("Hello Default\n");
}
 
int main(void)
{
    /* 我想打谁，只需要传对应的标记位即可 */
    printf("# PRINT_DFL: \n");
    Show(PRINT_DFL);
 
    printf("# PRINT_A: \n");
    Show(PRINT_A);
 
    printf("# PRINT_B: \n");
    Show(PRINT_B);
 
    printf("# PRINT_A AND PRINT_B: \n");
    Show(PRINT_A | PRINT_B);
 
    printf("# PRINT_C AND PRINT_D: \n");
    Show(PRINT_C | PRINT_D);
 
    printf("# PRINT_A AND PRINT_B AND PRINT_C AND PRINT_D: \n");
    Show(PRINT_A | PRINT_B | PRINT_C | PRINT_D);
 
    return 0;
}

4、open 接口用法演示??

讲完了 flags 标记位，现在我们可以演示 open 接口的用法了。

int open(const char* pathname, int flags);

?代码演示：是用?open() 打开 log.txt 文件没有就创建。

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
int main(void)
{
    int fd = open("log.txt", O_WRONLY | O_CREAT);
    if (fd < 0) {         // 打开失败
        perror("open"); 
        return 1;
    }
 
    printf("fd: %d\n", fd);   // 把 fd 打出来看看
 
    return 0;
}

此时，我们的log.txt是原本就存在的，

如果你要创建这个文件，该文件是要受到Linux 权限的约束的！

创建一个文件，你需要告诉操作系统默认权限是什么。

当我们要打开一个曾经不存在的文件，不能使用两个参数的 open，而要使用三个参数的 open！

也就是带 mode_t mode 的 open，这里的 mode 代表创建文件的权限：

int open(const char* pathname, int flags, mode_t mode);

代码演示：

int main()
{
    int fd = open("log.txt", O_APPEND | O_CREAT, 0666);  // 八进制表示
    if (fd < 0) {
        perror("open");
        return 1;
    }
 
    printf("fd: %d\n", fd);
 
    return 0;
}

因为你要创建的文件，所以要听操作系统！我们来看看 umask：?

你要 666，操作系统不能给你，因为 umask 是 0002，所以最多只能给你 664。?

我们现在就是要 666，我们只需要调用 umask()，然后传 0：umask(0)?

就可以让权限掩码暂时不听按操作系统的默认权限掩码，而用你设置的！

?此时权限就变成了我们的666.

实际上，umask 命令就是调用这个接口的。

umask 设为 0，可以让我们以确定的权限打开文件，比如服务器要打开一个日志文件，权限就必须要按照它对应的权限设置好，不要采用系统的默认权限，可能会出问题。

5、文件关闭：close()?

在 C 语言中，关闭文件可以调用 fclose，在系统接口中我们可以调用 close 来关闭：?

#include <unistd.h>
 
int close(int fd);

?该接口相对 open 相对来说比较简单，只有一个 fd 参数，我们直接看代码：

  1 #include <stdio.h>  
  2 #include <sys/types.h>  
  3 #include <sys/stat.h>  
  4 #include <fcntl.h>  
  5 #include <unistd.h>  // 需引入头文件                                  
  6 int main()  
  7 {                                                                   
  8       umask(0);   // umask现在就为0，听我的，别听操作系统的umask了   
  9     int fd = open("log.txt", O_WRONLY | O_CREAT, 0666);  // 八进制表示 
 10 if (fd < 0) {  
 11         perror("open");  
 12         return 1;        
 13     }              
 14        
 15     printf("fd: %d\n", fd);  
 16     close(fd);//关闭文件     
 17                                              
 18     return 0;                                
 19 }

没啥问题，就。。。。。没了。

6、文件写入：write()

文件打开和文件关闭都有了，我们总要干点事吧？现在我们来做文件写入！

在 C 语言中我们用的是 fprintf, fputs, fwrite 等接口，而在系统中，我们可以调用 write 接口：

#include <unistd.h>
ssize_t write(int fd, const void* buf, size_t count);

write 接口有三个参数：

fd：文件描述符
buf：要写入的缓冲区的起始地址（如果是字符串，那么就是字符串的起始地址）
count：要写入的缓冲区的大小

代码演示：向文件写入 6行信息


  1 #include <stdio.h>  
  2 #include<string.h>
  3 #include <sys/types.h>
  4 #include <sys/stat.h>
  5 #include <fcntl.h>
  6 #include <unistd.h>  // 需引入头文件                                  
  7 int main()                             
  8 {                                                                   
  9       umask(0);   // umask现在就为0，听我的，别听操作系统的umask了   
 10     int fd = open("log.txt", O_WRONLY | O_CREAT, 0666);  // 八进制表示 
 11     if (fd < 0) {                      
 12         perror("open");                
 13         return 1;                      
 14     }                                  
 15     int cnt=6;                         
 16     const char* str="666666\n";        
 17     while(cnt--){                      
 18       write(fd,str,strlen(str));       
 19     }                                  
 20                                        
 21     close(fd);//关闭文件               
 22                                        
 23     return 0;                          
 24 }

?运行结果：

?> 文件名，前面什么都不写，直接重定向 + 文件名：?

$ > log.txt

这算是一个小技巧吧

感谢阅读！！！！！！！！！！！

文章来源:https://blog.csdn.net/ayf9999/article/details/135432827
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！

（19）Linux系统下的文件操作 &amp;&amp; 文件系统接口