Comment appeler le système sous-jacent des fichiers d'exploitation Linux

Le système d'exploitation Linux poursuit le concept selon lequel tout est un fichier. Presque tous les périphériques de fichiers peuvent être utilisés avec un ensemble d'appels système, à savoir open()/close()/write()/read(), etc. Les appels système sont similaires aux appels de la bibliothèque C dans les fichiers d'exploitation. Le manuel manuel fourni avec Linux fait le plus autorité. Vérifiez l'utilisation des appels système en consultant le manuel de l'utilisateur.

nom de code—— Ce qu'il représente

• 1 —— environnement shell Commandes exploitables/exécutables

• 2 —— Fonctions et outils appelables du noyau système

• #🎜 🎜#3 —— Certaines fonctions et bibliothèques de fonctions couramment utilisées, la plupart des bibliothèques de fonctions C

• 4 ——

• 5 —— Fichiers de configuration ou formats de certains fichiers

• 6 ——

• 7 —— Gestion et protocoles, tels que les systèmes de fichiers Linux, les protocoles réseau, etc.
  #🎜 🎜##🎜 🎜#8 —— Commandes disponibles pour les administrateurs système

• 9 —— 🎜#Notez que les fichiers d'en-tête système sont généralement stockés dans le répertoire /usr/include sous Linux ; certains des fichiers d'en-tête inclus ci-dessous incluent sys, qui incluent en fait le fichier d'en-tête dans le sous-répertoire ci-dessous#🎜 🎜#
open()——Ouvrir ou créer un fichier

• 

Type de valeur de retour :

int&mdash ;—Descripteur de fichier fd, each chaque fois que vous ouvrez un fichier, vous obtiendrez un descripteur de fichier. Ce descripteur de fichier est un entier. Nous effectuons des opérations de lecture et d'écriture via le descripteur de fichier. /usr/include目录下；下面包含的一些头文件有的带了sys，其实是include底下的子目录中的头文件

open（）——打开或者创建一个文件

返回值类型： int——文件描述符fd，每打开一个文件，就会得到一个文件描述符，这个文件描述符是整形的，我们通过文件描述符进行读写操作。

• 失败：-1

• 成功：>= 0，即文件描述符；

• mode_t是一个类型别名，实际上就是一个有符号的整数，对open函数而言，仅仅当创建新文件时才使用第三个参数

flag：打开标志

注意： 这些其实都是定义的一些宏，当需要使用到多个参数时，使用按位或“ | ”构成多个flag参数

也可跟随下面的方式一起使用：

其他不一一介绍，需要使用时自查。

write（）

返回值：

• 若成功为已经写入的字节数；

• 若出错为-1；

注意：计划写入的字节数和函数的返回值不相等时，表示写入出现了错误，可以用来检验写入是否成功；

参数：

• fd：写入文件的文件描述符；

• buf：存放待写数据的缓存；

• count：要求写入一次数据的字节数；

注意：

对于普通文件，写操作从文件的当前位移量处开始，若如果在打开该文件时，指定了O_APPEND选择项，则在每次写操作之前，将文件位移量设置在文件的当前结尾处。在一次成功写之后，该文件位移量增加实际写的字节数。

read（）

返回值 ：读到的字节数

• 若已到文件尾为0；若出错为-1；

参数

• fd：读取文件的文件描述符；

• buf：存放读取数据的缓存；

• count

Échec : -1

Succès : >= 0, qui est le descripteur de fichier # ; 🎜 🎜#

mode_t est un alias de type, qui est en fait un entier signé Pour la fonction open, le troisième paramètre n'est utilisé que lors de la création d'un nouveau fichier#🎜🎜 ##🎜. 🎜#

flag：Ouvrir le drapeau

#🎜🎜##🎜🎜##🎜🎜#Remarque : #🎜🎜# Ce sont en fait des macros définies, quand vous devez les utiliser Lors de l'utilisation un paramètre, utilisez au niveau du bit ou "|" pour former plusieurs paramètres de drapeau #🎜🎜##🎜🎜# peut également être utilisé de la manière suivante : #🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜 🎜# #🎜🎜 ##🎜🎜 #Les autres ne seront pas présentés un par un, veuillez vérifier vous-même quand vous devez les utiliser. #🎜🎜##🎜🎜#write()#🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜#Valeur de retour #🎜🎜# : #🎜🎜##🎜🎜##🎜🎜##🎜🎜#If réussi, c'est le nombre d'octets qui ont été écrits #🎜🎜##🎜🎜##🎜🎜##🎜🎜#Si une erreur se produit, c'est -1 ; ##🎜🎜#Remarque : prévoyez d'écrire Lorsque le nombre d'octets saisi n'est pas égal à la valeur de retour de la fonction, cela signifie qu'il y a une erreur d'écriture, qui peut être utilisée pour vérifier si l'écriture a réussi # ; 🎜🎜##🎜🎜##🎜🎜#Paramètres : #🎜🎜##🎜 🎜##🎜🎜##🎜🎜##🎜🎜#fd : Descripteur de fichier pour l'écriture de fichiers #🎜 ; 🎜##🎜🎜##🎜🎜##🎜🎜# buf : Cache qui stocke les données à écrire ; count : Le nombre d'octets requis pour écrire des données une fois ; Pour les fichiers ordinaires, l'opération d'écriture commence à partir du déplacement actuel du fichier. Si lorsque le fichier est ouvert et que l'option O_APPEND est spécifiée, le décalage du fichier est défini sur la fin actuelle du fichier avant chaque opération d'écriture. Après une écriture réussie, le décalage du fichier est augmenté du nombre d'octets réellement écrits. #🎜🎜##🎜🎜#read（）#🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜#Valeur de retour #🎜🎜# : Nombre d'octets lus #🎜🎜##🎜🎜##🎜🎜## 🎜🎜#Si la fin du fichier a été atteinte, ce sera 0 ; s'il y a une erreur, ce sera -1 #🎜🎜##🎜🎜#fd : Le descripteur du fichier ; du fichier lu ; #🎜🎜##🎜🎜##🎜🎜##🎜🎜#buf : Cache qui stocke les données lues ; 🎜#count : Le nombre d'octets requis pour lire les données une fois ; notez que la valeur de retour est la lecture réelle. Le nombre d'octets n'est pas le même 🎜#Start, avant de réussir le retour, le déplacement est augmenté du nombre d'octets réellement lus (ce déplacement peut être paramétré par vous-même #🎜🎜##🎜🎜#close()#🎜🎜##🎜🎜# #🎜🎜##🎜🎜#) ;

Remarque : Lorsqu'un processus se termine, tous les fichiers qu'il ouvre sont automatiquement fermés par le noyau.

Remarque : Ces fonctions sans cache sont toutes des appels système fournis par le noyau ; c'est exactement ce que nous faisons ; Les différences entre ces opérations d'E/S apprises en langage C ne font pas partie du standard C, mais de POSIX.

Lorsque le standard C opère sur des fichiers, il opère sur le pointeur de structure de FILE, et le descripteur de fichier est utilisé ici.

La plage des descripteurs de fichiers est 0 - OPEN MAX. La limite supérieure adoptée par les premiers Unix était de 19 (c'est-à-dire que chaque processus est autorisé à ouvrir 20 fichiers). Désormais, de nombreux systèmes l'augmenteront. à 63. Linux est 1024. Le numéro spécifique peut être trouvé dans le fichier d'en-tête de .

Descripteur de fichier et pointeur de fichier

# 🎜🎜#

• FILE *fdopen(int fd, const char *mode), convertit le descripteur de fichier en pointeur de fichier

• int ; fileno(FILE *stream), convertit le pointeur de fichier en descripteur de fichier ; 🎜# Localiser un fichier ouvert

  off_t lseek(int fd,off_t offset,int whence);

fd：Descripteur de fichier ouvert ;

#🎜 🎜#décalage : montant du déplacement ;

d'où : position de positionnement, c'est-à-dire le point de référence

• fd：已经打开的文件描述符；

• offset：位移量；

• whence：定位的位置，即基准点

• SEEK_SET：将该文件的位移量设置为距文件开始处offset个字节；

• SEEK_CUR：将该文件的位移量设置为其当前值加offset，offset可正可负；

• SEEK_END

  SEEK_SET : Définissez le décalage du fichier pour décaler les octets à partir du début du fichier ;
#🎜 🎜#
• # ; 🎜🎜#SEEK_CUR : Définissez le déplacement du fichier sur sa valeur actuelle plus le décalage, et le décalage peut être positif ou négatif ; code>SEEK_END : définissez le déplacement du fichier sur la longueur du fichier plus le décalage. Le décalage peut être positif ou négatif (s'il s'agit d'une valeur positive à ce moment-là, il s'agit d'un fichier de trous, veuillez voir l'explication ci-dessous) ;

• Valeur de retour : ** En cas de succès, renvoie le nouveau déplacement du fichier (déplacement absolu) ** S'il y a une erreur, -1 ; la taille du fichier peut être renvoyée ; Un tube ou FIFO, puis lseek renvoie -1 et définit errno sur

  #include<stdio.h>
  #include<fcntl.h>
  #include<string.h>
  #include<stdlib.h>
  #include<unistd.h>
  #include<errno.h>
  
  //生成空洞文件
  char *buffer = "0123456789";
  
  int main(int argc,char *argv[])
  {
  	if(argc < 2)
  	{
  		fprintf(stderr,"-usage:%s [file]\n",argv[0]);
  		exit(1);
  	}
  
  	int fd = open(argv[1],O_WRONLY | O_CREATE | O_TRUNC,0777);
  	if(fd < 0)
  	{
  		perror("open error");
  		exit(1);
  	}
  
  	size_t size = strlen(buffer) * sizeof(char);
  	//将字符串写入到空洞文件中
  	if(write(fd,buffer,size) != size)
  	{
  		perror("write error");
  		exit(1);
  	}
  	
  	//定位到文件尾部的10个字节处
  	if(lseek(fd,10L;SEERK_END) < 0)
  	{
  		perror("lseek error");
  		exit(1);
  	}
  	//从文件尾部的10个字节处再写入字符串
  	if(write(fd,buffer,size) != size)
  	{
  		perror("write error");
  		exit(1);
  	}
  	close(fd)；
  	return 0;
  }

Nous pouvons le voir en utilisant le more ; commande pour visualiser le contenu du fichier, nous constatons que le contenu affiché n'est que le résultat d'une écriture unique, utilisez la commande od

-c pour visualiser le code ASSCI du fichier, nous trouverons qu'entre les deux contenu, il y a 10

Ouvrez un nouveau fichier

Lisez une partie du fichier binaire d'origine et écrivez-la dans le nouveau fichier

Lisez et écrivez à plusieurs reprises

jusqu'à ce que la lecture soit terminée, puis arrêtez-vous après l'écriture【lire( ) == 0 est utilisé comme condition d'arrêt de la boucle. S'il ne peut pas être lu, cela signifie qu'il est terminé. fichier, le processus enfant du fork peut-il partager l'accès avec le processus parent ?

Chaque fois que nous ouvrons un fichier, une structure telle qu'un fichier struct sera générée dans le noyau pour représenter le fichier ouvert et enregistrer les informations suivantes :

Décalage du fichier (à partir de 0, le pointeur de fichier se décale au fur et à mesure que les données sont écrites)

Nombre de références (plusieurs processus utilisent ce fichier ouvert)

nœud inode (stocke les informations d'attribut du processus : qui l'a créé, quel est son nom, dans Où est le disque stocké ? Grâce à ce nœud inode, nous pouvons trouver le fichier spécifique correspondant)

Méthode d'ouverture : comme le mode lecture seule, le mode écriture seule

• Test 1 : Ouvrez d'abord le fichier puis fork
• close(fd) est écrit sur le côté le plus extérieur, et les processus parent et enfant seront fermés à chaque fois qu'ils seront fermés, le nombre de références sera décrémenté de 1 jusqu'à ce qu'il atteigne 0.
  Les résultats d'exécution sont les suivants :
Les raisons sont les suivantes :

Test 2 : fork d'abord puis ouvrez le fichier

Après avoir modifié le code, les résultats d'exécution changent comme suit :

Parce que les processus parent et enfant sont séparés. Ensuite, les fichiers respectifs sont ouverts, les fichiers de structure respectifs sont générés et les décalages de fichiers ne sont plus partagés.

Dans les scénarios d'application réels, nous utilisons principalement les fichiers ouverts par le processus parent et les processus enfants pour accéder à ce formulaire.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!