Linux读写文件

时间：2024-04-19 17:46:17

前言

学习了文件系统，就能理解为什么说Linux下一切皆文件。

语言层面的操作

在c语言的学习中我们可以使用fopen()函数对文件进行操作。

image-20240414193759510

int main()
{
  //FILE * fp = fopen("./log.txt", "w");
  //FILE * fp = fopen("./log.txt", "r");
  FILE * fp = fopen("./log.txt", "a");
   if(NULL == fp)
   {
      perror("fopen");
      return 1;
   }
   //测试w
   int count = 5;
   while(count--)
   {
      const char * msg = "hello world\n";
      fputs(msg ,fp);
   }

   //测试r
   char buffer[32];
   while(fgets(buffer, sizeof(buffer), fp))
   {
      printf("%s", buffer);
   }

   //测试a
   int count = 5;
   while(count--)
   {
      const char * msg = "hello world\n";
      fputs(msg ,fp);
   }
   fclose(fp);
   return 0;
}

FILE在c语言上是一个结构体，包含了文件操作的基本属性，对文件的操作都要通过这个结构的指针来进行。

文件操作常用的函数

  • fopen() 打开流
  • fclose() 关闭流
  • fputc() 写一个字符到流中
  • fgetc() 从流中读一个字符
  • fputs() 写字符串到流
  • fgets() 从流中读一行或指定个字符
  • fprintf() 按格式输出到流
  • fscanf() 从流中按格式读取

上面提到的这些函数都是库函数，而像open()、close（）、read()、write()都是属于系统提供的接口。

它们之间有什么联系呢？

可以看到fopen()的类型是一个FILE*类型的指针，而FILE是一个结构体，结构体中包含着文件名、文件状态和文件当前位置等信息,里面有一个我们需要的fd，有了fd系统就能找到相应的文件进行读写。

系统调用接口

open（）

image-20240414200335275
mode能帮我们设置权限信息，我们在创建一个新的文件的话必须告诉系统权限是什么。

image-20240414201619541

flags

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

read（）

//读取文件内容
int main()
{
  size_t fd = open("./log.txt", O_RDONLY);
  char buffer[1024];
  ssize_t s = read(fd, buffer, sizeof(buffer) - 1);
  if(s > 0)
  {
    buffer[s] = 0; printf("%s\n", buffer);
  }
  return 0;
}

文件描述符fd

fd分配规则，找最小的未分配的描述符给fd

int main()
{
	
  int fd = open("./log.txt", O_WRONLY | O_CREAT, 0644);
  int fd1 = open("./log1.txt", O_WRONLY | O_CREAT, 0644);

  int fd2 = open("./log2.txt", O_WRONLY | O_CREAT, 0644);
   printf("%d\n", fd); //3
   printf("%d\n", fd1);//4
   printf("%d\n", fd2);//5

  close(fd);
}

当程序运行起来之后，OS会自动帮我们打开3个标准输入输出。因为我们的进程都是bash调用fork()创建出来的，bash默认打开了这3个，所以子进程继承了下去同样打开了这3个标准输入输出。

image-20240416175939494

inode

磁盘读写的最小单位是扇区，扇区的大小一般只有 512B 大小，文件系统把多个扇区组成了一个逻辑块，每次读写的最小单位就是逻辑块（数据块），Linux 中的逻辑块大小为 4KB，也就是一次性读写 8 个扇区，这将大大提高了磁盘的读写的效率。

Linux 文件系统会为每个文件分配两个数据结构：索引节点（index node）和目录项（directory entry），它们主要用来记录文件的元信息和目录层次结构。目录也是文件，也是用索引节点唯一标识，和普通文件不同的是，普通文件在磁盘里面保存的是文件数据，而目录文件在磁盘里面保存子目录或文件。

  • 索引节点，也就是 inode，用来记录文件的元信息，比如 inode 编号、文件大小、访问权限、创建时间、修改时间、数据在磁盘的位置等等。索引节点是文件的唯一标识，它们之间一一对应，也同样都会被存储在硬盘中，所以索引节点同样占用磁盘空间。
  • 目录项，也就是 dentry，用来记录文件的名字、索引节点指针以及与其他目录项的层级关联关系。多个目录项关联起来，就会形成目录结构，但它与索引节点不同的是，目录项是由内核维护的一个数据结构，不存放于磁盘，而是缓存在内存。

由于索引节点唯一标识一个文件，而目录项记录着文件的名，所以目录项和索引节点的关系是多对一，也就是说，一个文件可以有多个别字。比如，硬链接的实现就是多个目录项中的索引节点指向同一个文件。

image-20240417105059387

inode 与目录项的关系

image-20240417105201278

要想找到文件（普通文件或目录文件）的数据块，必须找到文件的inode，inode之所以被引用（找到），是因为在文件名所在的目录项中有记录它的编号，但是目录项是在目录文件的数据块中，而数据块必须通过 inode 才能找到…我们需要固定一个目录，就是根目录，根目录是所有目录的父目录，每个分区都有自己的根目录，创建文件系统之后它的位置就是固定不变的，也就是说，在文件系统的设计中，根目录所在数据块的地址是被“写
死”的，查找任意文件时，都直接到根目录的数据块中找相关的目录项，然后递归查找，最终可以找到任意子目录中的文件。

inode总结

  1. 每个文件都有自己单独的 inode,inode 是文件实体数据块在文件系统上的元信息。
  2. 所有文件的 inode 集中管理，形成 inode 数组，每个 inode 的编号就是在该 inode 数组中的下标。inode 中的前 12 个直接数据块指针和后 3 个间接块索引表用于指向文件的数据块实体。
  3. 文件系统中并不存在具体称为“目录”的数据结构，同样也没有称为“普通文件”的数据结构，统一用同一种 inode 表示。inode 表示的文件是普通文件，还是目录文件，取决于 inode 所指向数据块中的实际内容是什么，即数据块中的内容要么是普通文件本身的数据，要么是目录中的目录工页。
  4. 目录项仅存在于 inode 指向的数据块中，有目录项的数据块就是目录，目录项所属的 inode 指向的所有数据块便是目录。目录项中记录的是文件名、文件 inode 的编号和文件类型，目录项起到的作用有两个，一是粘合文件名及 inode，使文件名和 inode 关联绑定，二是标识此inode 所指向的数据块中的数据类型（比如是普通文件，还是目录，当然还有更多的类型）。
  5. inode 是文件的“实质”，但它并不能直接引用，必须通过文件名找到文件名所在的目录项，然后从该目录项中获得 inode 的编号，然后用此编号到 inode 数组中去找相关的 inode，最终找到文件的数据块。

文件系统

image-20240417111226315

磁盘是典型的块设备，硬盘分区被划分为一个个的block。一个block的大小是由格式化的时候确定的，并且不可以更改。例如mke2fs的-b选项可以设定block大小为1024、2048或4096字节。而上图中启动块（Boot Block）的大小是确定的）

  • Block Group：ext2文件系统会根据分区的大小划分为数个Block Group。而每个Block Group都有着相

    同的结构组成。

  • 超级块（Super Block）：存放文件系统本身的结构信息。记录的信息主要有：bolck 和 inode的总量，

    未使用的block和inode的数量，一个block和inode的大小，最近一次挂载的时间，最近一次写入数据的时间，最近一次检验磁盘的时间等其他文件系统的相关信息。Super Block的信息被破坏，可以说整个文件系统结构就被破坏了

  • GDT，Group Descriptor Table：块组描述符，描述块组属性信息

  • 块位图（Block Bitmap）：Block Bitmap中记录着Data Block中哪个数据块已经被占用，哪个数据块没

    有被占用

  • inode位图（inode Bitmap）：每个bit表示一个inode是否空闲可用。

  • i节点表:存放文件属性 如 文件大小，所有者，最近修改时间等

  • 数据区：存放文件内容

三个时间

gcc/ Makefile 会根据源文件和可执行程序的时间来判断谁更新,从而指导系统哪些源文件要重新编译。

[jiantao@VM-8-16-centos 4.18]$ stat test.c
  File: ‘test.c’
  Size: 0         	Blocks: 0          IO Block: 4096   regular empty file
Device: fd01h/64769d	Inode: 1442506     Links: 1
Access: (0664/-rw-rw-r--)  Uid: ( 1001/ jiantao)   Gid: ( 1001/ jiantao)
//文件最近被访问的时间,不会立即刷新，有一定的时间间隔os才会自动刷新
Access: 2024-04-18 09:45:22.453858883 +0800
//最近一次修改文件内容的时间，当我们修改文件内容的时候，有可能修改文件的属性	
Modify: 2024-04-18 09:45:22.453858883 +0800
//最近一次修改文件属性的时间
Change: 2024-04-18 09:45:22.453858883 +0800

重定向

调用write往1里面写东西是会显示到屏幕上面，为什么呢？

printf函数是向显示器上打印出东西，向显示器打印东西对应的是标准输出，标准输出的文件描述符fd是1，在操作系统看来只要是1对应内容就是要往显示器上打印，而不管1对应的是什么。

除了采用关闭0,1,2号描述符重新分配fd这种方式，还可以调用dup2实现重定向。

int dup2(int oldfd, int newfd);
dup2()  makes  newfd be the copy of oldfd, closing newfd first if necessary
    
    
int  main()
{
  //我这里的log.text已近是存在的
  int fd = open("./log.txt", O_WRONLY | O_CREAT); //清空内容
  dup2(fd,  1);
  //下面三个函数都是往1里面输出，经过dup2都输出到log.text
  printf("hello printf\n");
  fprintf(stdout, "hello fprintf\n");
  fputs("hello fputs\n", stdout);
}

只是把标准输出重定向到log.txt中， >是输出重定向,如果标准输入输出都重定向到log中执行[./test > log.txt 2>&1 ]，就可以。

image-20240417081049264

缓冲区

image-20240417103811830

在语言中，当我们调用printf()函数向显示器打印的时候，是有一个刷新策略叫行缓冲，当遇到’\n’的时候就会刷新缓冲区。假如我先调用close（1）,后创建一个新文件分配的fd为1,调用printf()后调用close(fd)，然后使用重定向>到log.txt中，当我们去cat log.txt内容的时候，会发送里面没有东西，而调用系统接口的话能重定向成功。

测试代码

int main()
{
    close(1);
    int fd = open("./log.txt",O_CREAT | O_WRONLY, 0644);  
    printf("hello\n");
    const char* msg = "hellow\n";
    write(1, msg, strlen(msg));

    close(fd);
}

image-20240417103112845

因为我们在调用printf()的时候，内容是放到用户缓冲区中的，由于发生了重定向到普通文件，刷新策略发生了改变，由行缓冲变成全缓冲(缓冲区满了才刷新),所以并没有刷新。如果在close(fd)之前调用fflush()就能刷新成功。

image-20240417102556550

可以看到fflush()能帮我们把用户缓冲区的数据刷到内存缓冲区中，进程退出的时候，也会自动刷新FILE内部的数据到OS缓冲区。

用户缓冲区到OS刷新策略

1.立即刷新

2.行刷新 显示器打印

3缓冲区满了才刷新 全缓冲，往磁盘文件中写入

软硬链接

软连接特别像在Window的快捷方式，软链接有独立的inode，是一个独立的文件，有自己的数据块，数据块指向链接文件所在的路径和文件名。

拥有者前面的数字代表是硬链接数，硬链接是和连接文件拥有相同的inode和数据块，我们在创建一个目录的时候默认的链接数是2，是因为在当前目录下有一个隐藏目录. 。

image-20240417100446942

动静态库

静态库（.a）：程序在编译链接的时候把库的代码链接到可执行文件中。程序运行的时候将不再需要静态库。

动态库（.so）：程序在运行的时候才去链接动态库的代码，多个程序共享使用库的代码。

动态链接

一个与动态库链接的可执行文件仅仅包含它用到的函数入口地址的一个表，而不是外部函数所在目标文件的整个机器码。在可执行文件开始运行以前，外部函数的机器码由操作系统从磁盘上的该动态库中复制到内存中，这个
过程称为动态链接（dynamic linking）。

动态库可以在多个程序间共享，所以动态链接使得可执行文件更小，节省了磁盘空间。操作系统采用虚拟内存机制允许物理内存中的一份动态库被要用到该库的所有进程共用，节省了内存和磁盘空间

显示可执行程序依赖的库

image-20240418095953745

image-20240418101016063

image-20240418100310165

真实名字去掉lib，去掉 .a 或.so-(包含后缀)剩下的就是库文件名称，这里lib64/libc-2.17.so 的真实库名字是c-2.17。

静态连接

gcc默认是动态链接，想要静态链接要加上-static

image-20240418101150320

制作静态库

库的本身是二进制的，需要头文件才知道里面实现了什么函数，把所有的.o文件打包起来就是静态库

libmath.a:add.o
	ar -rc $@ $^
%.o:%.c
	gcc -c $<

.PHONY:clean
clean:
	rm -rf *.o libmath output libmath.a

.PHONY:output
output:
	mkdir output
	cp -rf *.h output
	cp libmath.a output

[%.o:%.c gcc -c $<]生成.o文件，用[ar -rc]生成静态库，ar是gnu归档工具，rc表示(replace and create)。

使用静态库

gcc  test.c -I./lib -L./lib -lmath
-I./lib 指明头文件搜索路径
-L./lib 指明库文件搜索路径
lmath 指明链接哪一个库

制作动态库

libmath.so:add.o
	gcc -shared -o $@ $^
#产生.o目标文件, 程序内部地址与位置无关，可以在任何地方加载
%.o:%.c
	gcc -fPIC -c $<
.PHONY:clean
clean:
	rm -f libmath.so *.o

.PHONY:output
output:
	mkdir libshared
	cp *.h libshared
	cp libmath.so libshared

shared: 表示生成共享库格式，fPIC：产生位置无关码(position independent code)。

动态库使用

[jiantaomy_lib]$ gcc test.c -I./libshared -L./libshared -lmath

image-20240418115110083

可以看到链接不上，需要拷贝.so文件到系统共享库路径下, 一般指/usr/lib,更改 LD_LIBRARY_PATH 或者在/etc/ld.so.conf.d/路径下增加一个my.conf里面填入库要链接动态库所在的路径，再ldconfig更新。

就能运行成功。

image-20240418115304125

相关文章