Linux 文件系统：C语言接口、系统接口

一、文件接口

二、感性理解Linux系统下“一切皆文件”

三、C语言文件接口

1、fopen

2、当前路径

3、fwrite、fprintf、fputs

4、fgets

模拟实现cat命令

5、fscanf

五、系统接口

1、open系统调用

2、write系统调用

例：O_WRONLY

例：O_WRONLY|O_CREAT

例：O_TRUNC

例：O_APPEND

3、read

例：O_RDONLY

4、系统调用和库函数

一、文件接口

在探讨文件操作的范畴时，我们确实将文件视为内容加属性的集合。操作文件无非是对其内容或属性的操作。这些操作在底层是通过操作系统（OS）的接口完成的，因为只有操作系统有权直接与硬件交互。当我们编写代码来操作文件时，实际上是通过进程来实现的。进程是操作系统中能够执行操作的实体，它是文件访问的本质执行者。

为什么在学习C/C++时没有听过文件类的系统调用接口？

封装的复杂性：操作系统层面的文件接口相对底层且复杂，直接使用它们进行文件操作需要深入理解操作系统的工作原理。为了简化开发过程，不同的编程语言对这些系统调用接口进行了封装，提供了更易于使用的文件操作API。这种封装隐藏了系统调用接口的复杂性，使得开发者在日常开发中很少需要直接接触到这些底层接口。
跨平台性的需求：直接使用操作系统的文件接口会使得代码与特定的操作系统绑定，从而失去跨平台的能力。编程语言通过提供封装后的文件操作接口，使得开发的应用可以在不同的操作系统上运行，而无需关心底层的系统调用差异。这种抽象层的存在极大地提高了代码的可移植性。

为什么需要操作系统提供的文件接口？

权限限制：直接向硬件写入数据需要特定的权限，这些权限通常仅操作系统拥有。因此，普通用户或应用程序需要通过操作系统提供的接口来进行文件操作。
封装和简化：操作系统层面的文件接口通常比较底层且复杂。不同的编程语言通过封装这些系统调用接口，提供了更简单易用的文件操作API，以适应不同的开发需求和习惯。
跨平台兼容性：如果直接使用操作系统的文件接口，那么编写的代码将与特定的操作系统绑定，失去跨平台的能力。通过使用编程语言提供的封装接口，可以实现代码的跨平台运行，因为这些语言级别的接口会根据运行平台调用相应的系统接口。

为什么要学习操作系统层面的文件接口？

尽管语言级别的封装提供了便利和跨平台能力，但学习操作系统层面的文件接口仍然有其价值：

统一性：操作系统层面的文件接口是统一的，每个操作系统提供的接口虽然固定，但是了解这些接口可以帮助开发者更深入地理解文件操作的本质，以及不同操作系统之间的差异。
高级功能和性能优化：某些高级功能或性能优化可能需要直接使用操作系统提供的文件接口来实现，尤其是在需要精细控制文件行为的场景中。

显示器和文件操作的比较

显示器作为硬件，使用printf进行打印操作时，我们通常不会感到奇怪。这是因为printf等函数已经封装了向显示器输出的底层细节。实际上，向显示器打印信息与向磁盘文件写入数据在本质上是相似的，都涉及到了操作系统层面的硬件访问接口。这种封装隐藏了底层的复杂性，使得开发者可以更加专注于应用逻辑的实现。

二、感性理解Linux系统下“一切皆文件”

在计算机系统中，文件的概念可以从狭义和广义两个角度来理解：

狭义的文件

狭义上的文件通常指的是存储在磁盘上的数据集合，这些数据可以是文本、图片、视频等任何形式的信息。这类文件可以通过文件系统进行管理，我们可以使用各种编程语言提供的文件操作API（如fopen, fread, fwrite等）来读取或写入这些文件。例如，从文件中读取数据到程序的内存中，或者将程序处理的数据写回到磁盘文件中。

广义的文件

从广义上讲，文件不仅仅局限于磁盘上的数据集合。在类Unix操作系统中，遵循“一切皆文件”的哲学，几乎所有的外设（如显示器、键盘、网卡、声卡等）都可以被抽象为文件。这意味着，这些设备的操作也可以通过读写文件的方式来进行。例如，向显示器输出信息（printf/cout）本质上是向一个特殊的文件写入数据；从键盘读取输入（scanf/cin）本质上是从一个特殊的文件中读取数据。

文件的读写操作

从程序的角度看，文件操作主要分为读（input）和写（output）两种基本操作。无论是操作磁盘上的普通文件，还是与外设交互，都可以用读写的概念来描述：

读操作（Input）：将数据从文件（无论是磁盘文件还是代表外设的特殊文件）传输到程序的内存中。
写操作（Output）：将数据从程序的内存传输到文件中，无论这个文件代表的是磁盘上的数据存储还是某种外设。

总结

因此，从系统的角度来看，任何能够被读取（input）或能夜被写出（output）的设备都可以被抽象为文件。这种广义上的文件概念极大地统一了操作系统对硬件的访问方式，简化了程序与外设之间的交互逻辑。

三、C语言文件接口

`1、fopen`

原型：FILE *fopen(const char *path, const char *mode);
功能：打开名为 path 的文件，并与之关联一个流。
模式：
- r：以文本模式打开文件进行读取。文件指针位于文件开头。
- r+：打开文件进行读写。文件指针位于文件开头。
- w：以文本模式打开文件进行写入。如果文件存在，则长度截为零。文件指针位于文件开头。
- w+：打开文件进行读写。如果文件不存在，则创建之。如果文件存在，则长度截为零。文件指针位于文件开头。
- a：以追加模式打开文件进行写入。如果文件不存在，则创建之。文件指针位于文件末尾。
- a+：打开文件进行读取和追加写入。如果文件不存在，则创建之。读取时文件指针位于文件开头，但写入总是追加到文件末尾。

#include <stdio.h>

int main()
{
    FILE*fp=fopen("log.txt","r");
    if(fp==NULL)
    {
        perror("fopen");
        return 1;
    }
    return 0;
}

[hbr@VM-16-9-centos file_system]$ ./myfile 
fopen: No such file or directory

#include <stdio.h>

int main()
{
    FILE*fp=fopen("log.txt","w");
    if(fp==NULL)
    {
        perror("fopen");
        return 1;
    }
    return 0;
}

[hbr@VM-16-9-centos file_system]$ make
gcc -std=c99 -o myfile myfile.c
[hbr@VM-16-9-centos file_system]$ ./myfile 
[hbr@VM-16-9-centos file_system]$ ls
log.txt  makefile  myfile  myfile.c

2、当前路径

当前路径（Current Working Directory, CWD）是指操作系统中一个进程当前所处的目录路径。当一个进程被启动时，它会有一个与之关联的目录，这个目录就是它的当前工作目录。进程在执行文件操作时，如果使用的是相对路径，那么这个相对路径就是基于当前工作目录来解析的。

例如，如果当前路径是 /home/whb，当进程尝试打开或创建一个名为 log.txt 的文件时，如果没有指定完整路径，操作系统会自动将 log.txt 与当前路径拼接，形成完整的文件路径 /home/whb/log.txt，然后在该路径下进行文件操作。

在Linux和Unix系统中，可以使用 pwd 命令查看当前工作目录，而在Windows系统中，则可以使用 cd 命令（不带任何参数）来查看。

#include <stdio.h>

int main()
{
    FILE*fp=fopen("log.txt","w");
    if(fp==NULL)
    {
        perror("fopen");
        return 1;
    }
    return 0;
}

在名为 file_system 的目录下编译并运行了一个C程序，该程序的作用是创建（或打开，如果已存在）一个名为 log.txt 的文件。由于指定的文件名是相对路径，所以 log.txt 被创建在了当前工作目录下，即 file_system 目录。

接着，将编译好的可执行文件 myfile 复制到上一级目录 linux 中，并在那里运行它。由于此时的当前工作目录是 /home/hbr/linux，程序再次执行时，根据其当前工作目录，创建了一个新的 log.txt 文件，这次在 linux 目录下。

[hbr@VM-16-9-centos file_system]$ make
gcc -std=c99 -o myfile myfile.c
[hbr@VM-16-9-centos file_system]$ ./myfile 
[hbr@VM-16-9-centos file_system]$ ls
log.txt  makefile  myfile  myfile.c  sysmax_process
[hbr@VM-16-9-centos file_system]$ cp myfile ..
[hbr@VM-16-9-centos file_system]$ cd ..
[hbr@VM-16-9-centos linux]$ ls
Development_tool      file_system  LICENSE  process       README.md
environment_variable  gdb          myfile   README.en.md
[hbr@VM-16-9-centos linux]$ pwd
/home/hbr/linux
[hbr@VM-16-9-centos linux]$ ./myfile 
[hbr@VM-16-9-centos linux]$ ls
Development_tool      file_system  LICENSE  myfile   README.en.md
environment_variable  gdb          log.txt  process  README.md

当你使用相对路径（如本例中的 "log.txt"）进行文件操作时，实际操作的文件路径是基于当前工作目录的。因此，即使是同一个程序，在不同的工作目录下运行时，操作的文件路径也可能不同。简而言之，程序中使用的相对路径 "log.txt" 被解析为与程序当前工作目录相关的绝对路径，导致在不同目录下运行相同的程序会在各自的目录下创建或操作 log.txt 文件。

#include <stdio.h>
#include <unistd.h>

int main()
{
    FILE*fp=fopen("log.txt","w");
    if(fp==NULL)
    {
        perror("fopen");
        return 1;
    }
    fclose(fp);
    while(1)
    {
        sleep(1);
    }
    return 0;
}

[hbr@VM-16-9-centos file_system]$ ps axj | head -1 && ps axj | grep myfile
 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
17230 27565 27565 17230 pts/0    27565 S+    1003   0:00 ./myfile
27409 27958 27957 27409 pts/1    27957 S+    1003   0:00 grep --color=auto myfile
[hbr@VM-16-9-centos file_system]$ ls /proc/27565 -d
/proc/27565
[hbr@VM-16-9-centos file_system]$ ls /proc/27565 -l
total 0
//我们这次只关注下面这行
lrwxrwxrwx 1 hbr hbr 0 Mar 15 21:02 cwd -> /home/hbr/linux/file_system
lrwxrwxrwx 1 hbr hbr 0 Mar 15 21:02 exe -> /home/hbr/linux/file_system/myfile

3、fwrite、fprintf、fputs

这三个函数都是用于向文件中写入数据的C语言函数。

fwrite：

fwrite 函数用于将数据块以二进制形式写入文件。
它的原型是 size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)。
ptr 是要写入的数据的指针，size 是每个数据项的大小（以字节为单位），nmemb 是要写入的数据项的数量，stream 是指向文件的指针。
该函数返回实际写入的数据项数目。

fprintf：

fprintf 函数用于按照指定的格式将数据写入文件。
它的原型是 int fprintf(FILE *stream, const char *format, ...)。
stream 是指向文件的指针，format 是格式化字符串，后面的参数是要写入的数据。
该函数返回写入的字符数。

fputs：

fputs 函数用于将字符串写入文件。
它的原型是 int fputs(const char *str, FILE *stream)。
str 是要写入的字符串，stream 是指向文件的指针。
该函数返回一个非负值表示成功，如果发生错误则返回 EOF。

#include <stdio.h>

int main()
{
    FILE*fp=fopen("log.txt","w");
    if(fp==NULL)
    {
        perror("fopen");
        return 1;
    }
    const char *s1 = "hello fwrite \n";
    fwrite(s1,strlen(s1),1,fp);
    const char *s2 = "hello fprintf \n";
    fprintf(fp,"%s",s2);
    const char *s3 = "hello fputs \n";
    fputs(s3,fp);
    
    fclose(fp);

    return 0;
}

[hbr@VM-16-9-centos file_system]$ ./myfile 
[hbr@VM-16-9-centos file_system]$ cat log.txt
hello fwrite 
hello fprintf 
hello fputs 
[hbr@VM-16-9-centos file_system]$ cat myfile.c

\0结尾是C语言的规定，文件用遵守吗?

#include <stdio.h>

int main()
{
    FILE*fp=fopen("log.txt","w");
    if(fp==NULL)
    {
        perror("fopen");
        return 1;
    }
    const char *s1 = "hello fwrite \n";
    fwrite(s1,strlen(s1)+1,1,fp);
    const char *s2 = "hello fprintf \n";
    fprintf(fp,"%s",s2);
    const char *s3 = "hello fputs \n";
    fputs(s3,fp);

    fclose(fp);

    return 0;
}

fwrite使用了 strlen(s1)+1 作为要写入的字节数。这里 +1 是因为你想要包括字符串结束符 \0。
在文件中，你看到了 "hello fprintf" 被正确写入了，但是输出后面多了一个 ^@，这是因为 \0 字符在文本编辑器中通常显示为 ^@。
所以，对于文件，特别是文本文件，\0 结尾并不是必须的，因为在文件中，通常是根据字符的数量来确定字符串的结束，而不是依赖于特殊的结束符

[hbr@VM-16-9-centos file_system]$ ./myfile 
[hbr@VM-16-9-centos file_system]$ cat log.txt
hello fwrite 
^@ello fprintf 
hello fputs 
[hbr@VM-16-9-centos file_system]$ cat myfile.c

4、fgets

char *fgets(char *str, int n, FILE *stream);

str：一个指向字符数组的指针，用于存储读取到的文本数据。通常，您需要提前声明一个足够大的字符数组来存储读取的数据。fgets 会将读取的数据存储到这个数组中。
n：要读取的最大字符数，包括字符串结尾的 null 终止字符。这个参数可以防止 fgets 读取过多的数据，从而导致缓冲区溢出。
stream：指向要读取的文件流的指针，通常通过 fopen 打开文件后获得。

fgets 函数会从文件流 stream 中读取字符，直到满足以下条件之一：

读取了 n-1 个字符。
遇到换行符（'\n'）。
到达文件的末尾（EOF）。

一旦满足上述任何条件，fgets 就会停止读取字符，并将读取的字符存储在 str 指向的字符数组中。如果成功读取一行数据，fgets 会在字符串的末尾添加一个 null 终止字符（'\0'），以确保字符串正确终止。

#include <stdio.h>

int main()
{
    FILE *fp=fopen("log.txt","r");
    if(fp==NULL)
    {
        perror("fopen:");
        return 1;
    }
    char line[64];
    while(fgets(line,sizeof(line),fp)!=NULL)
    {
        fprintf(stdout,"%s",line);
    }
    fclose(fp);
}

[hbr@VM-16-9-centos exercise_func]$ cat log.txt 
hello
[hbr@VM-16-9-centos exercise_func]$ make
gcc -std=c99 -o mytest testC.c
[hbr@VM-16-9-centos exercise_func]$ ./mytest 
hello

模拟实现cat命令

通过添加命令行参数并读取参数内容实现cat命令功能。

#include <stdio.h>

int main(int argc,char*argv[])
{
    if(argc!=2)
    {
        printf("argv error\n");
        return 1;
    }
    FILE *fp=fopen(argv[1],"r");
    if(fp==NULL)
    {
        perror("fopen:");
        return 2;
    }
    char line[64];
    while(fgets(line,sizeof(line),fp)!=NULL)
    {
        fprintf(stdout,"%s",line);
    }
    fclose(fp);
}

[hbr@VM-16-9-centos exercise_func]$ ./mytest makefile
mytest:testC.c
	gcc -std=c99 -o $@ $^
.PHONY:clean
clean:
	rm -f mytest
[hbr@VM-16-9-centos exercise_func]$ ./mytest log.txt 
hello

5、fscanf

fscanf() 是 C 语言标准库 <stdio.h> 中的一个函数，用于从指定的输入流中读取格式化的数据。它的原型如下：

int fscanf(FILE *stream, const char *format, ...);

stream 是指向 FILE 结构体的指针，指定要从中读取数据的文件流。
format 是一个字符串，指定了读取数据的格式，就像 scanf() 函数中一样。
... 表示可变数量的参数，用于接收从输入流中读取的数据，根据 format 字符串中的格式进行解析。

fscanf() 会按照指定的格式从输入流中读取数据，并将其存储到提供的变量中。它会根据 format 字符串中的格式指示符进行解析，将相应的输入数据转换为指定的数据类型，并存储到相应的变量中。

例如，如果你有一个文件 data.txt 包含了一些数据：John 25 Alice 30

你可以使用 fscanf() 函数从文件中读取这些数据：

#include <stdio.h>

int main() {
    FILE *file = fopen("data.txt", "r");
    if (file == NULL) {
        perror("Error opening file");
        return 1;
    }

    char name[20];
    int age;

    // 从文件中读取数据
    while (fscanf(file, "%s %d", name, &age) != EOF) {
        printf("Name: %s, Age: %d\n", name, age);
    }

    fclose(file);
    return 0;
}

这段代码将会从 data.txt 文件中读取名字和年龄，并将它们打印到标准输出。

五、系统接口

系统调用open和write是操作系统提供的两个底层接口，它们直接与内核交互，用于文件操作。这些调用允许用户空间的程序执行文件系统相关的操作，如打开文件、写入数据等。下面分别对这两个系统调用进行解释：

`1、open`系统调用

open系统调用用于打开或创建一个文件，并且为程序提供对该文件的访问。当一个文件被打开时，操作系统创建一个文件描述符（fd），这是一个非负整数，用于在后续操作中标识这个文件。

语法：

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

pathname：要打开或创建的文件的路径名。
flags：指定打开文件时的各种选项，如O_RDONLY（只读）、O_WRONLY（只写）、O_RDWR（读写）、O_CREAT（如果文件不存在，则创建它）O_TRUNC （文件存在，则清空文件，文件不存在，则创建它），O_APPEND（将数据追加到文件的末尾）。
mode：当创建新文件时，指定文件的权限。这个参数是可选的，取决于flags参数中是否包含O_CREAT标志。mode参数通常与权限位结合使用，如0644（典型的文本文件权限）或0755（典型的可执行文件权限）。

返回值：

成功时，返回一个非负整数，即文件描述符（fd）。
失败时，返回-1，并设置errno变量以指示错误原因。

`2、write`系统调用

write系统调用用于将数据写入到一个已经打开的文件中。它通过文件描述符来确定目标文件。

语法：

ssize_t write(int fd, const void *buf, size_t count);

fd：文件描述符，指明要写入数据的文件。这个描述符通常是通过open系统调用获取的。
buf：指向一个内存区域的指针，这个内存区域包含了要写入文件的数据。
count：要写入的字节数。

返回值：

成功时，返回写入的字节数。
如果返回0，表示没有写入任何数据。
失败时，返回-1，并设置errno变量以指示错误原因。

write系统调用直接操作底层文件系统，绕过了C标准库的缓冲区，因此写操作是即时发生的。这两个系统调用是进行文件操作的基础，它们提供了一种控制文件访问的方法，是构建更高级文件I/O函数（如C标准库中的fopen、fwrite等）的基石。

例：`O_WRONLY`

#include <stdio.h>
#include <string.h>
#include <fcntl.h>

int main() {
    int fd=open("log.txt",O_WRONLY);
    if(fd<0)
    {
        perror("open");
        return 1;
    }
    printf("open success,fd:%d\n",fd);

    return 0;
}

[hbr@VM-16-9-centos exercise_func]$ ./mytest 
open success,fd:3

例：O_WRONLY|O_CREAT

当使用 O_CREAT 选项与 open() 函数结合创建新文件时，应同时指定文件的权限模式（例如，0644）。这个 mode 参数定义了文件的初始权限。由于您没有提供 mode 参数，文件的权限由系统默认值和 umask 值共同决定。

[hbr@VM-16-9-centos exercise_func]$ cat testC.c 
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main() {
    int fd=open("log.txt",O_WRONLY|O_CREAT);
    if(fd<0)
    {
        perror("open");
        return 1;
    }
    const char *s="write success\n";
    write(fd,s,strlen(s));
    printf("open success,fd:%d\n",fd);
    close(fd);
}
[hbr@VM-16-9-centos exercise_func]$ make
gcc -std=c99 -o mytest testC.c
[hbr@VM-16-9-centos exercise_func]$ ./mytest 
open success,fd:3
[hbr@VM-16-9-centos exercise_func]$ ls
log.txt  makefile  mytest  test1.c  test2.c  test3.c  testC.c
[hbr@VM-16-9-centos exercise_func]$ cat log.txt 
cat: log.txt: Permission denied
[hbr@VM-16-9-centos exercise_func]$ ll
total 36
---xrwx--T 1 hbr hbr   14 Mar 18 22:44 log.txt

系统的umask值会影响通过shell或其他程序创建的文件的默认权限，由于使用了umask(0)，这会覆盖系统umask的影响，因此新创建的文件权限不受系统umask的限制。
我们将umask设置为0，然后指定open的权限参数mode为0664使其权限正常，这次就可以创建并打开写入文件了。

umask(0)
int fd=open("log.txt",O_WRONLY|O_CREAT,0664);

[hbr@VM-16-9-centos exercise_func]$ ll
total 32
-rw-rw-r-- 1 hbr hbr   72 Mar 18 21:19 makefile
-rw-rw-r-- 1 hbr hbr  374 Mar 18 22:52 testC.c
[hbr@VM-16-9-centos exercise_func]$ make
make: `mytest' is up to date.
[hbr@VM-16-9-centos exercise_func]$ ./mytest 
open success,fd:3
[hbr@VM-16-9-centos exercise_func]$ cat log.txt 
write success

例：O_TRUNC

在这里，O_TRUNC标志会将文件截断为零长度，即清空文件内容，然后再写入新的内容。因此，当你运行程序后，文件log.txt的内容被清空，然后写入了新的字符串"O_TRUNC success"。

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main() {
    umask(0);
    int fd=open("log.txt",O_WRONLY|O_CREAT|O_TRUNC,0664);
    if(fd<0)
    {
        perror("open");
        return 1;
    }
    const char *s="O_TRUNC success\n";
    write(fd,s,strlen(s));
    printf("open success,fd:%d\n",fd);
    close(fd);
}

[hbr@VM-16-9-centos exercise_func]$ ls
log.txt  makefile  mytest  test1.c  test2.c  test3.c  testC.c
[hbr@VM-16-9-centos exercise_func]$ cat log.txt 
write success
[hbr@VM-16-9-centos exercise_func]$ make
gcc -std=c99 -o mytest testC.c
[hbr@VM-16-9-centos exercise_func]$ ./mytest 
open success,fd:3
[hbr@VM-16-9-centos exercise_func]$ cat log.txt 
O_TRUNC success

例：O_APPEND

通过使用O_APPEND标志，你告诉系统在每次写入时都将数据追加到文件的末尾，而不是覆盖文件中已有的内容。每次你运行程序./mytest时，它会打开文件log.txt并将字符串"O_APPEND success"追加到文件的末尾。

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main() {
    umask(0);
    int fd=open("log.txt",O_WRONLY|O_CREAT|O_APPEND,0664);
    if(fd<0)
    {
        perror("open");
        return 1;
    }
   // const char *s="write success\n";
   // const char *s="O_TRUNC success\n";
    const char *s="O_APPEND success\n";
    write(fd,s,strlen(s));
    printf("open success,fd:%d\n",fd);
    close(fd);
}


[hbr@VM-16-9-centos exercise_func]$ make
gcc -std=c99 -o mytest testC.c
[hbr@VM-16-9-centos exercise_func]$ cat log.txt 
O_TRUNC success
[hbr@VM-16-9-centos exercise_func]$ ./mytest 
open success,fd:3
[hbr@VM-16-9-centos exercise_func]$ ./mytest 
open success,fd:3
[hbr@VM-16-9-centos exercise_func]$ ./mytest 
open success,fd:3
[hbr@VM-16-9-centos exercise_func]$ cat log.txt 
O_TRUNC success
O_APPEND success
O_APPEND success
O_APPEND success

3、read

#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);

fd是已打开文件的文件描述符。
buf是用于存储读取数据的缓冲区的指针。
count是要读取的字节数。

read函数会尝试从文件描述符fd指向的文件中读取count个字节的数据，并将其存储到buf指向的内存区域中。函数返回实际读取的字节数，如果出现错误，则返回-1。

例：O_RDONLY

使用read(fd, buffer, sizeof(buffer))从文件中读取数据。read函数会尝试从文件描述符fd指向的文件（在这里是log.txt）中读取64个字节的数据，并将其存储到buffer数组中。

在运行程序后，read函数将文件中的内容读取到buffer数组中，然后你通过printf("%s", buffer)将读取的内容输出到控制台。

[hbr@VM-16-9-centos exercise_func]$ cat testC.c 
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main() 
{
    umask(0);
    int fd = open("log.txt", O_RDONLY); 
    if (fd < 0) 
    {
        perror("open");
        return 1;
    }
    printf("open success, fd: %d\n", fd);
    char buffer[64];
    memset(buffer, '0', sizeof(buffer)); 
    read(fd, buffer, sizeof(buffer)); 
    printf("%s", buffer); // 输出读取的内容
    close(fd);
    return 0;
}
[hbr@VM-16-9-centos exercise_func]$ make
gcc -std=c99 -o mytest testC.c
[hbr@VM-16-9-centos exercise_func]$ ./mytest 
open success, fd: 3
O_TRUNC success
O_APPEND success
O_APPEND success