【Linux】基础IO(一) :文件描述符,文件流指针,重定向(上)

简介: 【Linux】基础IO(一) :文件描述符,文件流指针,重定向

重新认识文件


是不是只有C/C++有文件操作呢?python、java、go等文件接口操作的方法是不太一样的,那如何理解这种现象?有没有统一的视角去看待所有的语言文件操作呢?—我们今天从系统视角去理解 ---- 实际都是通过系统调用来访问

文件=内容+属性 — 针对文件的操作:对内容的操作,对属性的操作,对内容和属性的操作

文件可以分为两大类:磁盘文件 和 被打开的文件(内存文件)

当文件没有被操作的时候,文件一般放在磁盘位置。空文件也在磁盘中占据空间,因为文件属性也是数据,保存数据就需要空间。

我们在文件操作的时候,文件需要在哪里?—内存,依据冯诺依曼体系的规定

所以我们在文件操作的时候,文件需要提前load到内存,那load是内容还是属性?至少有属性吧!那是不是只有你一个人在load呢?当然不是,内存中一定存在大量的不同文件的属性

所以,打开文件的本质就是将需要的文件加载到内存中,OS内部一定会同时存在大量的被打开的文件,那操作系统需不需要管理呢?怎么管理?— 先描述,在组织!

先描述 — 构建在内存中的文件结构体 struct file (文件从磁盘中来,struct file* next连接下一个文件信息)。在组织 — struct file结构体利用某种数据结构链接起来。在OS内部,对被打开的文件进行管理,就转换成了对类似链表的增删查改

结论:文件被打开,OS要为被打开的文件,创建对应的内核数据结构

所有文件操作的本质就是进程和被打开文件的关系。 — struct task_struct 和 struct file


系统内部的文件操作


库函数底层必须调用系统调用接口,因为无论什么进程想访问文件,都必须按照操作系统提供的方式来进行访问,所以就算文件操作相关函数千变万化,但是底层是不变的,这些函数最后都会调用系统调用接口,按照操作系统的意愿来合理的访问磁盘上的文件。


我们不能用语言绕过操作系统去操纵硬件,所以必须通过系统调用通过操作系统来进行文件操作!不管什么编程语言,只是不同语言对系统调用进行了各自不同的封装,所以对这些文件操作接口的理解,其实就要落实到对系统调用接口的理解! 也就是说所有的只要要访问硬件或者操作系统内部的资源,都要通过系统调用!避不开的!


我们C语言的文件操作


C语言文件操作接口主要包括以下几类:


打开和关闭文件的接口,如fopen(), fclose()等。这些接口用于创建或打开一个文件,并返回一个FILE类型的指针,以及关闭一个已打开的文件,并释放相关资源。

顺序读写数据的接口,如fgetc(), fputc(), fgets(), fputs(), fprintf(), fscanf()等。这些接口用于从文件中读取或写入字符、字符串或格式化数据,并自动移动文件指针。

随机读写数据的接口,如fread(), fwrite(), fseek(), ftell()等。这些接口用于从文件中读取或写入二进制数据块,并根据指定位置移动或获取文件指针。

其他辅助功能的接口,如feof(), ferror(), clearerr()等。这些接口用于检测文件是否到达末尾、是否发生错误、以及清除错误标志。


文件的打开方式:


r:以只读的方式打开文件,若文件不存在就会出错。

w:以只写的方式打开文件,文件若存在则清空文件内容重新开始写入,若不存在则创建一个文件。

a:以只写的方式打开文件,文件若存在则从文件尾部以追加的方式进行写入,若不存在则创建一个文件。

r+:以可读写的方式打开文件,若文件不存在就会出错。

w+:以可读写的方式打开文件,其他与w一样。

a+:以可读写的方式打开文件,其他与a一样。


fopen, fread, fwrite, fseek, fclose等函数的使用


需要注意的是,当向文件中写入数据后,想要重新读取到数据,要么需要关闭文件重新打开,要么就要跳转读写位置到文件起始位置,然后再开始读取文件数据。


#include <stdio.h>
#include <string.h>
int main()
{
    FILE *fp = fopen("./bite", "wb+");
    if (fp == NULL) {
        perror("fopen error");
        return -1; 
    }   
    fseek(fp, 0, SEEK_SET);
    char *data = "linux so easy!\n";
    //size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
    size_t ret = fwrite(data, 1, strlen(data), fp);
    if (ret != strlen(data)) {
        perror("fwrite error");
        return -1; 
    }   
    fseek(fp, 0, SEEK_SET);//跳转读写位置到,从文件起始位置开始偏移0个字节
    char buf[1024] = {0};
    //size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
    ret = fread(buf, 1, 1023, fp);//因为设置读取块大小位1,块个数为1023因此fread返回值为实际读取到的数据长度
    if (ret == 0) {
        if (ferror(fp)) //判断上一次IO操作是否正确
            printf("fread error\n");
        if (feof(fp)) //判断是否读取到了文件末尾
            printf("read end of file!\n");
        return -1; 
    }   
    printf("%s", buf);
    fclose(fp);
    return 0;
}


当然这些也都是C库提供的函数,是对系统调用的上层封装,在系统级别文件操作我们是通过系统调用实现的


系统内部的文件操作


文件操作系统调用接口是指Linux内核提供的一组用于对文件进行打开、读写、关闭等操作的函数。它们包括以下几个常用的函数:


open:打开一个文件,返回一个文件描述符,可以指定文件的打开方式和权限。

write:向一个已打开的文件中写入数据,返回实际写入的字节数。

read:从一个已打开的文件中读取数据,返回实际读取的字节数。

lseek:改变一个已打开文件的读写位置,返回新的偏移量。

close:关闭一个已打开的文件,释放资源。


这些函数都需要传入一个文件描述符作为参数,它是一个非负整数,用于标识不同的打开文件。每个进程都有自己独立的一组文件描述符,并且默认有三个预定义的描述符:0代表标准输入,1代表标准输出,2代表标准错误输出。


这些函数都有可能失败,并返回-1,并设置errno变量为相应的错误码。因此,在调用这些函数后,需要检查返回值和错误码来判断是否成功。


我们主要介绍前三个:


OS一般会如何让用户给自己传递标志位的?多个标志位怎么实现呢? — 位图


其实是通过位操作实现的:

#include <stdio.h>
#define ONE 0x1
#define TWO 0x2
#define THREE 0x4
#define FOUR 0x8
#define FIVE 0x10
// 0000 0000 0000 0000 0000 0000 0000 0000
void Print(int flags)
{
    if(flags & ONE) printf("hello 1\n"); //充当不同的行为
    if(flags & TWO) printf("hello 2\n");
    if(flags & THREE) printf("hello 3\n");
    if(flags & FOUR) printf("hello 4\n");
    if(flags & FIVE) printf("hello 5\n");
}
int main()
{
    printf("--------------------------\n");
    Print(ONE);
    printf("--------------------------\n");
    Print(TWO);
    printf("--------------------------\n");
    Print(FOUR);
    printf("--------------------------\n");
    Print(ONE|TWO);
    printf("--------------------------\n");
    Print(ONE|TWO|THREE);
    printf("--------------------------\n");
    Print(ONE|TWO|THREE|FOUR|FIVE);
    printf("--------------------------\n");
    return 0;
}


open:打开一个文件,返回一个文件描述符,可以指定文件的打开方式和权限


open有两种调用方式:


一种是只传入文件名和访问模式,另一种是还传入创建权限(如果需要创建新文件)。访问模式有必需部分和可选部分,必需部分是 O_RDONLY(只读)、O_WRONLY(只写)或 O_RDWR(读写),可选部分有 O_APPEND(追加)、O_TRUNC(截断)、O_CREAT(创建)、O_EXCL(排他)等。创建权限是由几个标志按位或得到的,如 S_IRUSR(用户读)、S_IWUSR(用户写)、S_IXUSR(用户执行)等。


字符串/0 问题: 系统调用不需要这个!

0c8c01f87a644c77baae1f7a6206b406.png

b180334525c44707a7e67794f70e3c96.png

使用 open 函数打开一个文件,如果不存在则创建一个新文件,并设置访问模式为读写和追加,创建权限为用户读写和组读写:

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>
int main() {
    // 打开或创建一个文件
    int fd = open("test.txt", O_RDWR | O_APPEND | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
    if (fd == -1) {
        // 打开失败,打印错误信息
        perror("open error");
        exit(1);
    }
    // 打开成功,打印文件描述符
    printf("open success, fd = %d\n", fd);
    // 关闭文件
    close(fd);
    return 0;
}



创建目录的命令mkdir,目录起始权限默认是0777,创建文件的命令touch,文件起始权限是0666,这些命令的实现实际上是要调用系统接口open的,并且在创建文件或目录的时候要在open的第三个参数中设置文件的起始权限。


 25 int main()
 26 {
 27     umask(0);//将进程的umask值设置为0000
 28 
 29     // C语言中的w选项实际上底层需要调用这么多的选项O_WRONLY O_CREAT O_TRUNC 0666
 30     // C语言中的a选项需要将O_TRUNC替换为O_APPEND
 31     int fd = open(FILE_NAME,O_WRONLY | O_CREAT,0666);//设置文件起始权限为0666
 32     if(fd < 0)
 33     {
 34         perror("open");
 35         return 1;//退出码设置为1
 36     }
 37     close(fd);   
 38 }
### write:向一个已打开的文件中写入数据,返回实际写入的字节数
**write:向一个已打开的文件中写入数据,返回实际写入的字节数。需要传入文件描述符、数据缓冲区和数据长度。如果返回值小于请求的字节数,可能是因为错误或者设备驱动程序对数据块长度敏感。如果返回值为 0,表示没有写入任何数据;如果返回值为 -1,则表示出现错误。**
使用 write 函数向一个已打开的文件中写入一段字符串,并检查返回值是否正确:
```c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main() {
    // 要写入的字符串和长度
    char *str = "Hello world!\n";
    int len = 13;
    // 向标准输出(文件描述符为1)写入字符串
    int ret = write(1, str, len);
    if (ret == -1) {
        // 写入失败,打印错误信息
        perror("write error");
        exit(1);
    }
    if (ret != len) {
        // 写入字节数不正确,打印警告信息
        fprintf(stderr, "write warning: expected %d bytes, but got %d bytes\n", len, ret);
    }
    // 写入成功,打印返回值
    printf("write success, ret = %d\n", ret);
}

read:从一个已打开的文件中读取数据,返回实际读取的字节数

read:从一个已打开的文件中读取数据,返回实际读取的字节数。需要传入文件描述符、数据缓冲区和数据长度。如果返回值小于请求的字节数,可能是因为错误或者已到达文件尾。如果返回值为 0,表示没有读取任何数据;如果返回值为 -1,则表示出现错误。

使用 read 函数从一个已打开的文件中读取一定长度的数据,并存储到一个缓冲区中,并

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main() {
   // 要读取的字节数和缓冲区大小 
   int len = 100;
   char buf[100];
   // 从标准输入(文件描述符为0)读取数据到缓冲区中
   int ret = read(0, buf, len);
   if (ret == -1) {
       // 读取失败,打印错误信息
       perror("read error");
       exit(1);
   }
   if (ret == 0) {
       // 读取到文件尾,没有数据可读,打印提示信息
       printf("read end of file\n");
   }
   // 读取成功,打印返回值和缓冲区内容(注意添加结束符)
   printf("read success, ret = %d\n", ret);
  buf[ret] = '\0';
   printf("buf: %s\n", buf);
}

使用这些接口时,有一些事项需要注意:


在调用 open 函数时,要根据文件的用途和状态选择合适的访问模式和创建权限。如果使用了 O_CREAT 标志,要指定创建权限,否则可能导致文件权限不正确。如果使用了 O_EXCL 标志,要检查返回值是否为 -1,否则可能导致覆盖已有文件。如果打开的是设备文件或符号链接,要注意一些特殊的访问模式,如 O_NONBLOCK、O_NOCTTY、O_NOFOLLOW 等。

在调用 write 函数时,要保证数据缓冲区的有效性和长度正确性。如果写入的是文本文件,要注意添加换行符或结束符。如果写入的是二进制文件,要注意字节序和对齐问题。如果写入的是设备文件或网络套接字,要注意数据块长度和超时问题。

在调用 read 函数时,要保证数据缓冲区的有效性和大小足够。如果读取的是文本文件,要注意处理换行符或结束符。如果读取的是二进制文件,要注意字节序和对齐问题。如果读取的是设备文件或网络套接字,要注意数据块长度和超时问题。

在调用这些接口后,都要检查返回值是否为 -1,并根据 errno 变量来判断错误原因,并进行相应的处理或提示。有些错误可能是暂时性的或可恢复的,如 EINTR、EAGAIN、EWOULDBLOCK 等;有些错误可能是严重性的或不可恢复的,如 EACCES、EBADF、EFAULT、EINVAL 等。


综合使用:


fopen, fread, fwrite, fseek, fclose等函数的使用

需要注意的是,当向文件中写入数据后,想要重新读取到数据,要么需要关闭文件重新打开,要么就要跳转读写位置到文件起始位置,然后再开始读取文件数据。

#include <stdio.h>
#include <string.h>
int main()
{
    FILE *fp = fopen("./bite", "wb+");
    if (fp == NULL) {
        perror("fopen error");
        return -1; 
    }   
    fseek(fp, 0, SEEK_SET);
    char *data = "linux so easy!\n";
    //size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
    size_t ret = fwrite(data, 1, strlen(data), fp);
    if (ret != strlen(data)) {
        perror("fwrite error");
        return -1; 
    }   
    fseek(fp, 0, SEEK_SET);//跳转读写位置到,从文件起始位置开始偏移0个字节
    char buf[1024] = {0};
    //size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
    ret = fread(buf, 1, 1023, fp);//因为设置读取块大小位1,块个数为1023因此fread返回值为实际读取到的数据长度
    if (ret == 0) {
        if (ferror(fp)) //判断上一次IO操作是否正确
            printf("fread error\n");
        if (feof(fp)) //判断是否读取到了文件末尾
            printf("read end of file!\n");
        return -1; 
    }   
    printf("%s", buf);
    fclose(fp);
    return 0;
}

综合使用:

open, read, write, lseek, close等函数的使用

#include <stdio.h>
#include <unistd.h>//是close, write这些接口的头文件
#include <string.h>
#include <fcntl.h>//是 O_CREAT 这些宏的头文件
#include <sys/stat.h>//umask接口头文件
int main()
{
    //将当前进程的默认文件创建权限掩码设置为0--- 并不影响系统的掩码,仅在当前进程内生效
    umask(0);
    //int open(const char *pathname, int flags, mode_t mode);
    int fd = open("./bite", O_CREAT|O_RDWR, 0664);
    if(fd < 0) {
        perror("open error");
        return -1; 
    }   
    char *data = "i like linux!\n";
    //ssize_t write(int fd, const void *buf, size_t count);
    ssize_t ret = write(fd, data, strlen(data));
    if (ret < 0) {
        perror("write error");
        return -1; 
    }   
    //off_t lseek(int fd, off_t offset, int whence);
    lseek(fd, 0, SEEK_SET);
    char buf[1024] = {0};
    //ssize_t read(int fd, void *buf, size_t count);
    ret = read(fd, buf, 1023);
    if (ret < 0) {
        perror("read error");
        return -1; 
    }else if (ret == 0) {
        printf("end of file!\n");
        return -1; 
    }   
    printf("%s", buf);
    close(fd);
    return 0;
}


看看Linux内核源代码是怎么说的


d2ec5a31c3584160ac829757c1c6cff4.png


可以看到内核源代码的设计内容跟我们所说的基本一致


理解文件控制块&&文件描述符&&文件指针的关系


在进程中每打开一个文件,都会创建有相应的文件描述信息struct file,这个描述信息被添加在pcb的struct files_struct中,以数组的形式进行管理,随即向用户返回数组的下标作为文件描述符,用于操作文件


进程可以打开多个文件,对于大量的被打开文件,操作系统一定是要进行管理的,也就是先描述再组织,所以操作系统会为被打开的文件创建对应的内核数据结构,也就是文件控制块FCB,在linux源码中是struct file{}结构体,包含了文件的大部分属性

 #include <assert.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define FILE_NAME(number) "log.txt"#number
int main()
{
    int fd0 = open(FILE_NAME(1),O_WRONLY | O_CREAT | O_TRUNC,0666);//设置文件起始权限为0666
    int fd1 = open(FILE_NAME(2),O_WRONLY | O_CREAT | O_TRUNC,0666);//设置文件起始权限为0666
    int fd2 = open(FILE_NAME(3),O_WRONLY | O_CREAT | O_TRUNC,0666);//设置文件起始权限为0666
    int fd3 = open(FILE_NAME(4),O_WRONLY | O_CREAT | O_TRUNC,0666);//设置文件起始权限为0666
    int fd4 = open(FILE_NAME(5),O_WRONLY | O_CREAT | O_TRUNC,0666);//设置文件起始权限为0666
    printf("fd:%d\n",fd0);
    printf("fd:%d\n",fd1);
    printf("fd:%d\n",fd2);
    printf("fd:%d\n",fd3);
    printf("fd:%d\n",fd4);
    close(fd0);
    close(fd1);
    close(fd2);
    close(fd3);
    close(fd4);  
}

结果:


4282e2a0595448e2a39154600047e4dc.png


通过上述讲解,我们知道open系统调用会返回文件描述符,那它为什么是从3开始呢??


其实main函数会默认打开这三个标准文件

这三个标准文件是:


标准输入(stdin):用于从键盘或其他输入设备读取数据,通常对应文件描述符0。可以使用C语言的scanf、getchar等函数或者Linux的read系统调用来读取标准输入。

标准输出(stdout):用于向屏幕或其他输出设备写入数据,通常对应文件描述符1。可以使用C语言的printf、putchar等函数或者Linux的write系统调用来写入标准输出。

标准错误输出(stderr):用于向屏幕或其他输出设备写入错误信息,通常对应文件描述符2。可以使用C语言的fprintf、perror等函数或者Linux的write系统调用来写入标准错误输出。


这三个标准文件在程序启动时就被自动打开,并且在程序结束时被自动关闭,无需手动操作。它们也可以被重定向到其他文件或设备,例如使用 > 或 < 符号。


61543d6b47e6446f9fb2d0d05c653349.png

12f42bd5861a449582ad7d63da9c7cd4.png



所以为什么open文件操作后返回值 是3? 因为 0 1 2 已经被占用了 ---- 本质是数组下标


内存中文件描述符,文件描述符表,文件控制块,进程控制块的关系如下图所示,文件描述符表,说白了就是一个存储指向文件控制块的指针的指针数组,而文件描述符就是这个指针数组的索引,进程控制块中会有一个指向文件描述符表的指针。通过文件描述符就可以找到对应的被打开的文件。

操作系统通过这些内核数据结构,将被打开的文件和进程联系起来。



5f09fbfa52e44a7a9f48cebb413f5fb2.png


相关文章
|
3天前
|
Linux 数据处理 C语言
【Linux】基础IO----系统文件IO & 文件描述符fd & 重定向(下)
【Linux】基础IO----系统文件IO & 文件描述符fd & 重定向(下)
17 0
|
3天前
|
Linux 编译器 C语言
【Linux】基础IO----理解缓冲区
【Linux】基础IO----理解缓冲区
16 0
【Linux】基础IO----理解缓冲区
|
3天前
|
Linux C语言 C++
【Linux】基础IO----系统文件IO & 文件描述符fd & 重定向(上)
【Linux】基础IO----系统文件IO & 文件描述符fd & 重定向(上)
18 0
|
4天前
|
运维 监控 网络协议
Linux抓包命令tcpdump使用技巧大全
【7月更文挑战第10天】
19 4
Linux抓包命令tcpdump使用技巧大全
|
4天前
|
监控 数据挖掘 Linux
探索Linux中的`sort`命令:数据处理与分析的得力助手
`sort`命令是Linux下文本数据排序利器,用于按字典、数字顺序等对行排序。关键参数有:-n(数字排序),-r(逆序),-u(去重),-k(指定字段),-t(字段分隔符)和-o(输出到文件)。在处理大文件时注意内存使用,确保字符编码一致,灵活运用管道和重定向。通过熟练使用`sort`,能提升数据分析效率。
|
4天前
|
数据挖掘 Linux 数据处理
Linux命令sprof详解
**`sprof`是Linux下的共享库性能分析工具,补充`gprof`,专注分析`.profile`文件以识别性能瓶颈。通过调用次数、执行时间数据优化资源和代码。使用参数如`-F`、`-I`、`-d`进行定制化分析。示例:先设置`LD_PROFILE`环境变量,运行程序生成`.profile`,然后用`sprof`分析。注意需用`-g`编译程序,并在代表性的负载下分析。结合其他工具如`perf`、`valgrind`提升分析效果。**
|
4天前
|
存储 数据挖掘 Linux
Linux命令split详解:大文件处理的得力助手
`split`命令是Linux用于将大文件分割成小文件的工具,常用于日志处理、备份。它支持按行数(-l)、字节数(-b)分割,并能自定义输出文件名(-a, -d)。例如,`split -b 10M largefile.txt smallfile_`会按10MB切割`largefile.txt`,生成`smallfile_`开头的文件。注意确保磁盘空间充足,避免文件名冲突,并备份原始文件。结合其他命令使用,能提高文件管理效率。
|
4天前
|
数据挖掘 大数据 Linux
探索Linux中的snice命令:一个虚构但启发性的数据分析工具
`snice`是一个想象中的Linux命令,用于低优先级地从大数据集中抽样数据。它结合`nice`和`sampling`,支持多种抽样策略,如随机和分层。参数包括指定样本数、策略、输入输出文件和进程优先级。示例:`snice -n 1000 -s random -i large_log.txt -o sample_log.txt`。使用时注意资源管理、数据完整性及权限,并与其它工具结合使用。虽然虚构,但体现了Linux工具在数据分析中的潜力。
|
16小时前
|
关系型数据库 MySQL Linux
Linux命令systemctl详解
`systemctl`是Linux系统用于管理systemd服务的核心命令,它与systemd守护进程交互,实现启动、停止、重启服务及查看服务状态等功能。主要参数包括`start`、`stop`、`restart`、`status`、`enable`和`disable`等。例如,启动Apache服务使用`systemctl start httpd.service`,查看服务状态用`systemctl status &lt;service&gt;`。使用时需注意权限,服务名通常以`.service`结尾,但命令中可省略。最佳实践包括利用tab键补全、定期查看服务状态和合理配置服务自启。