Linux文件系统(1)

news2024/11/18 11:33:47

Linux文件系统(1)

📟作者主页：慢热的陕西人

🌴专栏链接：Linux

📣欢迎各位大佬👍点赞🔥关注🚓收藏，🍉留言

本博客主要内容从系统层面重新认识我们的文件系统

文章目录

  • Linux文件系统(1)
    • 我们先问几个问题：
    • 一些现有的结论
    • 快速回忆C文件操作
    • 系统的文件接口
    • 总结

我们先问几个问题：

①你真的理解文件原理和操作了吗?

②是不是只有C/C++有文件操作呢？有没有一种统一的视角去看所有的语言的文件操作呢？

③操作文件的时候，第一件事，都是打开文件，打开文件是做什么呢？如何理解呢？

一些现有的结论

①文件 = 内容 + 属性 —>针对文件的操作，对内容的操作，对属性的操作。

②当文件没有被操作的时候，文件一般在什么位置？磁盘

③当我们对文件进行操作的时候，文件需要在哪里？内存，冯诺依曼体系结构决定了。

④当我们对文件进行操作的时候，文件需要提前被load到内存，load是内容还是属性？至少得有属性。

⑤当我们对文件进行操作的时候，文件需要提前被load到内存，是不是只有我们一个人在load呢？不是，内存中一定存在着大量不同的文件的属性。

⑥所以综上所述，打开文件就是将文件的核心的属性和一些内容load到内存，OS内部一定会同时存在大量的被打开的文件，那么操作系统要不要管理这些被打开的文件呢？先描述再组织！

先描述：先构建在内存中的文件结构体(对象) struct XXX{就可以从磁盘来， struct file * next}；

a.每一个被打开的文件，都要在OS内对应文件对象的struct结构体，可以将所有的struct file结构体用某种数据结构链接起来----，在OS内部，对被打开的文件进行管理，就被转换成了对链表的增删查改。

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

struct file
{
    //各种属性
    //各种链接关系
}

⑦文件其实可以被分为两大类：磁盘文件和内存文件(被我们打开的文件)。

⑧文件被打开，是谁在打开？OS，是谁让操作系统打开的呢？进程

⑨我们之前的所有的文件操作，都是进程和被打开文件的关系。

⑩进程和被打开文件的关系：struct struct_task和struct file的关系

快速回忆C文件操作

①fopen函数:用于打开文件的函数

image-20231112175415441

一些参数：

image-20231112184405352

②perror函数:用于将错误码装化成对用的strerror

image-20231112175639963

③fclose函数

image-20231112180051947

④fputs函数：向文件中写入

image-20231112180231175

写一个程序尝试向文件中写入字符串：

运行结果：

image-20231112181203458

查看文件大小的命令:du -参数 文件名, 参数是单位，比如m，k等，例如我们刚刚这个文件就是1m

[mi@lavm-5wklnbmaja lesson7]$ du -m log.txt
1	log.txt

⑤snprintf函数：向字符串中写入(C语言的格式化支持的很好)

1.第一个函数是向屏幕输出

2.第二函数是向文件输出

3.第三个函数是向字符串(缓冲区)输出

4.第四个函数是向字符串(缓冲区)中输出n个字符

image-20231112182333353

尝试使用一下：

#include<stdio.h>    
    
#define LOG "log.txt"    
    
int main()    
{    
  //w：默认写方式打开文件，如果文件不存在，就创建它    
  //默认如果只是打开，文件内容会自动被清空    
  //同时，每次进行写入的时候，都会从最开始开始写入     
  FILE *fp = fopen(LOG, "w");    
  if(fp == NULL)    
  {    
    perror("fopen"); // fopen:xxxx    
    return 0;    
  }    
    
  //正常进行文件操作    
  const char* msg = "hello xupt, hello xiyou";                                                                                                                 
  int cnt = 5;    
  while(cnt)    
  {    
    fprintf(fp, "%s : %d : xupt \n", msg, cnt);    
   // fputs(msg, fp);    
    cnt--;    
  }    
    
  fclose(fp);    
  return 0;    
}

运行结果：

image-20231112182923960

snprintf的使用：

#include<stdio.h>    
    
#define LOG "log.txt"    
    
int main()    
{    
  //w：默认写方式打开文件，如果文件不存在，就创建它    
  //默认如果只是打开，文件内容会自动被清空    
  //同时，每次进行写入的时候，都会从最开始开始写入     
  FILE *fp = fopen(LOG, "w");    
  if(fp == NULL)    
  {    
    perror("fopen"); // fopen:xxxx    
    return 0;    
  }    
    
  //正常进行文件操作    
  const char* msg = "hello xupt, hello xiyou";    
  int cnt = 5;    
  while(cnt)    
  {    
    char buffer[256];    
    snprintf(buffer, sizeof(buffer), "%s : %d\n", msg , cnt);                                                                                                  
    fputs(buffer, fp);    
   // fprintf(stdout, "%s : %d : xupt \n", msg, cnt);    
   // fputs(msg, fp);    
    cnt--;    
  }    
    
  fclose(fp);    
  return 0;    
}

运行结果：

image-20231112184036214

⑥stdout

那么我们观察到它们的类型都是我们对应的FILE，因为在Linux系统中一切皆文件，接下来我们尝试用fprintf函数向stdout中输出一些字符串看看

image-20231112183052514

代码：

#include<stdio.h>    
    
#define LOG "log.txt"    
    
int main()    
{    
  //w：默认写方式打开文件，如果文件不存在，就创建它    
  //默认如果只是打开，文件内容会自动被清空    
  //同时，每次进行写入的时候，都会从最开始开始写入     
  FILE *fp = fopen(LOG, "w");    
  if(fp == NULL)    
  {    
    perror("fopen"); // fopen:xxxx    
    return 0;    
  }    
    
  //正常进行文件操作    
  const char* msg = "hello xupt, hello xiyou";    
  int cnt = 5;    
  while(cnt)    
  {    
    fprintf(stdout, "%s : %d : xupt \n", msg, cnt);                                                                                                            
   // fputs(msg, fp);    
    cnt--;    
  }    
    
  fclose(fp);    
  return 0;    
}

运行结果：

直接向屏幕输出了字符串

image-20231112183450307

⑦fgets函数

把文件中的信息写入到缓冲区中

代码：

#include<stdio.h>    
    
#define LOG "log.txt"    
    
int main()    
{    
  //w：默认写方式打开文件，如果文件不存在，就创建它    
  //1.默认如果只是打开，文件内容会自动被清空    
  //2.同时，每次进行写入的时候，都会从最开始开始写入     
  //a:不会清空文件，每次都从文件的结尾开始写入     
  //r:以读的形式，打开文件    
  FILE *fp = fopen(LOG, "r");    
  if(fp == NULL)    
  {    
    perror("fopen"); // fopen:xxxx    
    return 0;    
  }    
    
    
  while(1)    
  {    
    char line[128];    
    if(fgets(line, sizeof(line), fp) == NULL) break;    
    else printf("%s", line);    
  }    
   fclose(fp);
  return 0;
}

运行结果：

image-20231112185104125

那么到此结束，开始系统的文件操作

系统的文件接口

①open

pathname:表示要打开的文件路径+文件名

flag:代表打开文件的方式

image-20231112185909086

返回值：

返回一个文件描述符，-1表示错误，然后回设置error

image-20231112190103226

参数：

这些参数都是一些宏定义，所以函数参数的类型是int，他们分别对应一些含义，这只是其中一部分。

这些参数被称为标志位，类似于之前介绍的位图，每个参数对应一个比特位。

我们如果要传多个标志位：直接将他们|运算一下即可。

image-20231112190508804

image-20231112190641570

OS一般如何让用户给自己传递标志位的？

1.我们怎么做的？

2.系统怎么做的？我们用一个比特位表示一个标记位，那么一个int类型就可以表示32个标志位(位图)。

接下来一个小demo1实际操作演示一下：

#include<stdio.h>

#define ONE 0x1
#define TWO 0x2
#define THREE 0x4
#define FOUR 0x8
#define FIVE 0x10
    
void Print(int flag)    
{    
  if(flag & ONE) printf("hello 1\n");    
  if(flag & TWO) printf("hello 2\n");    
  if(flag & THREE) printf("hello 3\n");    
  if(flag & FOUR) printf("hello 4\n");    
  if(flag & FIVE) printf("hello 5\n");    
}    
    
int main()    
{    
  Print(ONE);   //打印1 
  printf("-------------------------------\n");    
  Print(TWO);    //打印2
  printf("-------------------------------\n");    
  Print(THREE);    //打印3
  printf("-------------------------------\n");    
  Print(FOUR);    //打印4
  printf("-------------------------------\n");    
  Print(FIVE);    //打印5                                                                                                                                      
  printf("-------------------------------\n");    
  Print(ONE | TWO | THREE | FOUR | FIVE);   //打印12345  
  printf("-------------------------------\n");    
  Print(ONE | THREE | FIVE); //打印135
  return 0;    
}

运行结果：

image-20231112192748966

那么其实flag就是如此工作的。

尝试使用一下：

#include<stdio.h>    
#include<errno.h>    
#include<string.h>    
#include<stdlib.h>    
#include<sys/types.h>    
#include<sys/stat.h>    
#include<unistd.h>    
    
#include<fcntl.h>    
//系统方案    
    
#define LOG "log.txt"    
    
int main()    
{    
  int fd = open(LOG, O_WRONLY);    
    
  printf("fd : %d errno : %d errnostring: %s\n", fd, errno, strerror(errno));                                                                                  
    
  close(fd);    
  return 0;    
}

我们查看结果却返回了-1，原因是：open函数不会创建文件，没有的指定文件的时候就会报错！

image-20231112194839982

我们创建了一个之后或者我们在参数中加上O_CREAT

  int fd = open(LOG, O_WRONLY | O_CREAT);

image-20231112194856013

但是我们去尝试查看这个文件的时候：

image-20231112195241507

那么我们可以使用open的一个重载：int open(const char *pathname, int flags, mode_t mode);

第三个参数mode是我们可以给予文件的默认权限：比如我们给个0666:

  int fd = open(LOG, O_WRONLY | O_CREAT, 0666);

image-20231112195528363

但是我们发现文件log.txt的权限却不是0666，原因其实是因为文件的权限还受umask的影响：默认权限&(~mask)

我们查看一下umask是否是2：果然如此我们把它改成0000在运行一下程序看看

image-20231112195724141

是我们想要的结果了!

image-20231112195825596

其实我们已经可以猜到：各种语言中的文件操作其实内部都是封装了操作系统给的接口，每个语言都进行了自己的个性化，所以每个语言的文件操作都不尽相同，但是底层都是封装了操作系统给的接口！

②write：操作系统提供的，向文件写入的接口

fd：文件描述符

buf：缓冲区

count: 写入缓冲区的大小

那么write的功能就是：将缓冲区buf中的count个字节的信息，写入到open返回的fd的对应的文件

返回值：表示实际写入了多少字节，写入失败返回-1

image-20231112200426541

代码：

#include<string.h>    
#include<stdlib.h>    
#include<sys/types.h>    
#include<sys/stat.h>    
#include<unistd.h>    
    
#include<fcntl.h>    
//系统方案    
    
#define LOG "log.txt"    
    
int main()    
{    
  int fd = open(LOG, O_WRONLY | O_CREAT, 0666);    
    
  printf("fd : %d errno : %d errnostring: %s\n", fd, errno, strerror(errno));    
    
    
  //写入    
  const char * msg = "hello xupt";    
  int cnt = 5;    
  while(cnt)    
  {    
    char line[128];    
    snprintf(line, sizeof(line), "%s , %d \n", msg, cnt);    
    
    write(fd, line, strlen(line));    
                                                                                                                                                               
    cnt--;    
  }

运行结果：

image-20231112201547388

那么其实这里涉及到一个问题：就是我是否要往 write(fd, line, strlen(line));中的strlen(line) + 1，结论是不需要的。因为\0是C语言的标准，操作系统内部没有\0的标准。所以不需要去+1；

另外：我们这里的调用int fd = open(LOG, O_WRONLY | O_CREAT, 0666);,不会对文件做清空，如果我们要打开的时候清空，只需要加上参数O_TRUNC;

就是这样：int fd = open(LOG, O_WRONLY | O_CREAT | O_TRUNC, 0666); 等价于我们的fopen(filename, "w");

我们的：fopen(filename, "a"); 等价于int fd = open(LOG, O_WRONLY |O_APPEND | O_CREAT, 0666);

③read:将文件中的信息整体读取到缓冲区buf中；

image-20231112203754608

代码：

#include<sys/stat.h>    
#include<unistd.h>    
    
#include<fcntl.h>    
//系统方案    
    
#define LOG "log.txt"    
    
int main()    
{    
  //int fd = open(LOG, O_WRONLY | O_CREAT | O_TRUNC, 0666);    
  int fd = open(LOG, O_RDONLY, 0666);    
    
  printf("fd : %d errno : %d errnostring: %s\n", fd, errno, strerror(errno));    
    
    
//读取    
    
  char buf[1024];    
    
  ssize_t n = read(fd, buf, sizeof(buf) - 1); //使用操作系统进行IO的时候，要注意\0问题    
  if(n > 0)    
  {    
    buf[n] = '\0';    
    
    printf("%s", buf);    
  }    
   return 0;
}

运行结果：

image-20231112204423201

总结

接下来我们可以回答开始的三个问题：

①你真的理解文件原理和操作了吗?

文件原理和操作是需要从操作系统的角度去学习，我们从语言角度学习的远远不够。

②是不是只有C/C++有文件操作呢？有没有一种统一的视角去看所有的语言的文件操作呢？

并不是，所有的编程语言都有自己的文件操作，其实他们都是对操作系统文件操作的封装。所以我们从操作系统的角度去统一认识文件操作。

③操作文件的时候，第一件事，都是打开文件，打开文件是做什么呢？如何理解呢？

打开文件就是将文件的属性和一些内容加载到内存，创建对应的struct_file；

到这本篇博客的内容就到此结束了。
如果觉得本篇博客内容对你有所帮助的话，可以点赞，收藏，顺便关注一下！
如果文章内容有错误，欢迎在评论区指正

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1200248.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

关于值传递和引用传递的问题记录

关于值传递和引用传递的问题记录

目录 1. 问题概述 1.1 测试 1.2 结果 2. ArrayList和Arrays.ArrayList 1. 问题概述 最近忙着写论文很久没更新了&#xff0c;趁现在有时间简单记录一下最近遇到的一个坑。 对于Java中的List<>类型的对象&#xff0c;按我以前理解是引用传递&#xff0c;但有一点要注…
阅读更多...
Java12新增特性

Java12新增特性

前言 前面的文章&#xff0c;我们对Java9、Java10、Java11的特性进行了介绍&#xff0c;对应的文章如下 Java9新增特性 Java10新增特性 Java11新增特性 今天我们来介绍一下Java12版本的新增特性 版本介绍 Java 12是Java SE的第12个版本&#xff0c;于2019年3月19日发布。这个…
阅读更多...
fastANI-基因组平均核酸一致性（ANI）计算

fastANI-基因组平均核酸一致性（ANI）计算

文章目录 简介安装使用Many to Man-使用基因组路径作为输入One to One 结果其他参数说明可视化两个基因组之间的保守区域并行化 简介 FastANI 是为快速计算全基因组平均核苷酸同一性&#xff08;Average Nucleotide Identity&#xff0c;ANI&#xff09;而开发的&#xff0c;无…
阅读更多...
【第七章】软件设计师 之 程序设计语言与语言程序处理程序基础

【第七章】软件设计师 之 程序设计语言与语言程序处理程序基础

文章底部有个人公众号&#xff1a;热爱技术的小郑。主要分享开发知识、学习资料、毕业设计指导等。有兴趣的可以关注一下。为何分享&#xff1f; 踩过的坑没必要让别人在再踩&#xff0c;自己复盘也能加深记忆。利己利人、所谓双赢。 1、前言 正规式 2、编译过程 编译型&…
阅读更多...
深度解析找不到msvcp120.dll相关问题以及解决方法

深度解析找不到msvcp120.dll相关问题以及解决方法

​在计算机使用过程中&#xff0c;我们经常会遇到一些错误提示&#xff0c;其中之一就是“msvcp120.dll丢失”。这个错误通常会导致某些应用程序无法正常运行&#xff0c;给用户带来很大的困扰。那么&#xff0c;如何解决msvcp120.dll丢失的问题呢&#xff1f;本文将为大家介绍…
阅读更多...
xml schema中的sequence的含义

xml schema中的sequence的含义

https://www.w3.org/TR/xmlschema-1/#element-sequence xml schema中的sequence的含义&#xff1a;包含的元素必须按规定的顺序出现。通过属性maxOccurs和minOccurs可以定义最多、最少出现的次数。最多可以定义不限制次数&#xff0c;最少可以定义0次。默认是最少出现1次&…
阅读更多...
pyTorch Hub 系列#4：PGAN — GAN 模型

pyTorch Hub 系列#4：PGAN — GAN 模型

一、主题描述 2014 年生成对抗网络的诞生及其对任意数据分布进行有效建模的能力席卷了计算机视觉界。两人范例的简单性和推理时令人惊讶的快速样本生成是使 GAN 成为现实世界中实际应用的理想选择的两个主要因素。 然而&#xff0c;在它们出现后的很长一段时间内&#xff0c;GA…
阅读更多...
02:2440---时钟体系

02:2440---时钟体系

目录 一:时钟控制 1:基本概念 2:时钟结构图 3:结构图分析 4:总线 5:寄存器 A:FCLK--MPLLCON B:HCLK和PCLK--CLKDIVN C:注意 二:上电复位 1:上电复位 2:时钟选择 三:代码 一:时钟控制 1:基本概念 S3C2440A中的时钟控制逻辑可以产生所需的时钟信号&#xff0c;包括C…
阅读更多...
node插件express（路由）的插件使用（二）——cookie 和 session的基本使用区别

node插件express（路由）的插件使用（二）——cookie 和 session的基本使用区别

文章目录 前言一、express 框架中的 cookie0、cookie的介绍和作用1. 设置cookie2.删除cookie3.获取cookie&#xff08;1&#xff09;安装cookie-parser&#xff08;2&#xff09;导入cookie-parser&#xff08;3&#xff09;注册中间件&#xff08;4&#xff09;获取cookie&…
阅读更多...
类和对象(3)：拷贝构造函数

类和对象(3)：拷贝构造函数

引入&#xff1a; class Stack { public:Stack(int capacity 3){_a (int*)malloc(sizeof(int) * capacity);if (nullptr _a){perror("malloc");exit(-1);}_top 0;_capacity capacity;}~Stack(){free(_a);_top _capacity 0;_a nullptr;}private:int* _a;int _…
阅读更多...
终止进程，GPU显存仍被占用 | kill -9彻底杀死进程

终止进程，GPU显存仍被占用 | kill -9彻底杀死进程

问题描述&#xff1a;在Linux终端把进程终止后&#xff0c;发现显存没有被释放出来&#xff01; 显示所有进程 ps aux|grep python杀死单个进程 kill -9 PID杀死多个进程 kill -9 PID PID PID...结果如下&#xff0c;显存已经被释放出来了&#xff01;
阅读更多...
【操作系统】1.1 操作系统的基础概念、功能以及特性

【操作系统】1.1 操作系统的基础概念、功能以及特性

&#x1f4e2;&#xff1a;如果你也对机器人、人工智能感兴趣&#xff0c;看来我们志同道合✨ &#x1f4e2;&#xff1a;不妨浏览一下我的博客主页【https://blog.csdn.net/weixin_51244852】 &#x1f4e2;&#xff1a;文章若有幸对你有帮助&#xff0c;可点赞 &#x1f44d;…
阅读更多...
gpt支持json格式的数据返回（response_format: ‘json_object‘）

gpt支持json格式的数据返回（response_format: ‘json_object‘）

Api.h5.chatCreateChatCompletion({model: gpt-3.5-turbo-1106,token: sk-f4fe8b67-fcbe-46fd-8cc9-fd1dac5d6d59,messages: [{role: user,content:使用json格式返回十二生肖&#xff0c;包含中文名和英文名&#xff0c;[{id:"1", enName:"", cnName: &quo…
阅读更多...
Python 多进程多线程

Python 多进程多线程

多任务 并发&#xff1a;在一段时间内交替执行多个任务 并行&#xff1a;在一段时间内同事一起执行多个任务 进程 Process 进程&#xff1a;一个程序运行在系统之上&#xff0c; 便称这个程序喂一个运行进程&#xff0c;并分配进程ID方便系统管理。操作系统进行资源分配和调…
阅读更多...
Android开发之apk瘦身计划

Android开发之apk瘦身计划

为什么apk越来越大&#xff1f; 1.项目不断发展&#xff0c;功能越多&#xff0c;代码量增加的同时&#xff0c;资源文件也在不断的增多。 2.app支持的主流dpi越来越多&#xff0c;如ldpi、mdpi、hdpi、xh xxh xxxh等等&#xff0c;间接导致资源增多。 3.引入的第三方sdk或开…
阅读更多...
Linux进程空间地址

Linux进程空间地址

程序地址空间回顾 问题引入 ---------------明天再写0.0
阅读更多...
Linux提取RPM包文件

Linux提取RPM包文件

在讲解如何从 RPM 包中提取文件之前&#xff0c;先来系统学习一下 cpio 命令。cpio 命令用于从归档包中存入和读取文件&#xff0c;换句话说&#xff0c;cpio 命令可以从归档包中提取文件&#xff08;或目录&#xff09;&#xff0c;也可以将文件&#xff08;或目录&#xff09…
阅读更多...
【Go入门】面向对象

【Go入门】面向对象

【Go入门】面向对象 前面两章我们介绍了函数和struct&#xff0c;那你是否想过函数当作struct的字段一样来处理呢&#xff1f;今天我们就讲解一下函数的另一种形态&#xff0c;带有接收者的函数&#xff0c;我们称为method method 现在假设有这么一个场景&#xff0c;你定义…
阅读更多...
Qt贝塞尔曲线

Qt贝塞尔曲线

目录 引言核心代码基本表达绘制曲线使用QEasingCurve 完整代码 引言 贝塞尔曲线客户端开发中常见的过渡效果&#xff0c;如界面的淡入淡出、数值变化、颜色变化等等。为了能够更深的了解地理解贝塞尔曲线&#xff0c;本文通过Demo将贝塞尔曲线绘制出来&#xff0c;如下所示&am…
阅读更多...
SPC 的一些小知识

SPC 的一些小知识

在生产管理系统种&#xff0c;经常回涉及到质量管理分&#xff0c;我们经常听说SPC、SPC控制图等和SPC相关的词汇&#xff0c;那么SPC是什么意思呢&#xff1f;它有什么作用呢&#xff1f;在这里通俗一点介绍一下SPC。 SPC是统计过程控制&#xff08;Statistical Process Cont…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023