So rufen Sie das zugrunde liegende System der Linux-Betriebsdateien auf

Das Linux-Betriebssystem folgt dem Konzept, dass alles eine Datei ist. Fast alle Dateigeräte können mit einer Reihe von Systemaufrufen bedient werden, nämlich open()/close()/write()/read() usw. Systemaufrufe und C-Bibliotheksaufrufe bedienen Dateien auf ähnliche Weise. Das mit Linux gelieferte Handbuch ist das maßgeblichste. Überprüfen Sie die Systemaufrufnutzung anhand des Man-Handbuchs.

Codename—— Was es darstellt

• 1 —— Befehle, die Benutzer in der Shell-Umgebung bedienen/ausführen können

• 2 — Funktionen und Tools, die vom System aufgerufen werden können Kernel

• 3 —— Einige häufig verwendete Funktionen und Funktionsbibliotheken, die meisten C-Funktionsbibliotheken

• 4 —— Beschreibung von Gerätedateien, normalerweise Geräte unter /dev

• 5 —— Das Format von Konfigurationsdateien oder bestimmten Dateien

• 6 — Für Systemadministratoren verfügbare Befehle

• 9 –– code>/usr/include im Linux-Verzeichnis; einige der unten enthaltenen Header-Dateien enthalten sys, bei denen es sich tatsächlich um Header-Dateien im Unterverzeichnis unter include

open() handelt – öffnen oder erstellen Sie eine Datei

• 

• Rückgabewerttyp:

  int——Dateideskriptor fd, jedes Mal, wenn Sie eine Datei öffnen, erhalten Sie einen Dateideskriptor. Wir führen Lese- und Schreibvorgänge über den Dateideskriptor aus.

Fehler: -1/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

Erfolg: >= 0, was der Dateideskriptor ist;

mode_t ist ein Typalias, der eigentlich eine vorzeichenbehaftete Ganzzahl ist Der dritte Parameter wird nur beim Erstellen einer neuen Datei verwendet. Flag: Open Flag. alt="So rufen Sie das zugrunde liegende System der Linux-Betriebsdateien auf" />

Hinweis:

Hierbei handelt es sich tatsächlich um einige definierte Makros. Wenn mehrere Parameter verwendet werden müssen, verwenden Sie das bitweise ODER „|“. „Mehrere Flag-Parameter bilden

kann auch auf folgende Weise verwendet werden:

🎜🎜🎜Andere werden nicht einzeln vorgestellt. Bitte überprüfen Sie selbst, wann Sie sie verwenden müssen. 🎜🎜write()🎜🎜fd: Dateideskriptor der geschriebenen Datei; 🎜🎜🎜 🎜buf: Cache zum Speichern der zu schreibenden Daten; 🎜🎜🎜🎜count: die Anzahl der erforderlichen Bytes um Daten einmal zu schreiben; 🎜🎜🎜🎜🎜Hinweis: 🎜🎜🎜 Bei normalen Dateien beginnt der Schreibvorgang mit dem aktuellen Offset der Datei. Wenn beim Öffnen der Datei die Option O_APPEND angegeben wird, wird der Dateioffset auf den aktuellen Wert gesetzt Ende der Datei vor jedem Schreibvorgang. Nach einem erfolgreichen Schreibvorgang wird der Dateioffset um die Anzahl der tatsächlich geschriebenen Bytes erhöht. 🎜🎜read()🎜🎜 🎜🎜🎜Rückgabewert🎜: Die Anzahl der gelesenen Bytes 🎜🎜🎜🎜Wenn das Ende der Datei erreicht ist, ist es 0; wenn ein Fehler auftritt, ist es -1; 🎜🎜🎜🎜🎜Parameter🎜🎜🎜 🎜🎜fd: Dateideskriptor zum Lesen von Dateien; 🎜🎜🎜🎜buf: Cache zum Speichern gelesener Daten; 🎜🎜🎜🎜count: Bytes Es ist erforderlich, die Daten einmal zu lesen. Beachten Sie, dass der Rückgabewert die tatsächliche Anzahl der gelesenen Bytes ist und nicht identisch ist. Hinweis: Der Lesevorgang beginnt mit der aktuellen Verschiebung der Datei Vor der erfolgreichen Rückkehr erhöht sich die Verschiebung um die tatsächliche Anzahl der gelesenen Bytes (diese Verschiebung kann selbst festgelegt werden 🎜🎜close()🎜🎜🎜🎜).

Hinweis: Wenn ein Prozess beendet wird, werden alle von ihm geöffneten Dateien automatisch vom Kernel geschlossen.

Hinweis: Diese Funktionen ohne Caching sind allesamt Systemaufrufe, die vom Kernel bereitgestellt werden. Dies ist genau der Unterschied zu den E/A-Operationen, die wir in der C-Sprache gelernt haben. Sie sind nicht Teil von Standard C, sondern Komponenten von POSIX .

Standard C arbeitet beim Bearbeiten von Dateien mit dem Strukturzeiger von FILE, und hier wird der Dateideskriptor verwendet.

Der Bereich der Dateideskriptoren beträgt 0-OPEN MAX. Die Obergrenze lag bei 19 (das heißt, jeder Prozess darf 20 Dateien öffnen). Linux ist 1024. Wie viele sind spezifisch? Es kann in der Header-Datei von gefunden werden.

Dateideskriptor und Dateizeiger

• FILE *fdopen(int fd, const char *mode), konvertiert den Dateideskriptor in einen Dateizeiger;

• int fileno(FILE * stream), konvertieren Sie den Dateizeiger in einen Dateideskriptor;

lseek-Funktion

Funktion: Eine geöffnete Datei suchen

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

• fd: Beschreibung der geöffneten Datei Symbol fd：已经打开的文件描述符；

• offset：位移量；

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

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

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

• SEEK_END

• offset: Verschiebungsbetrag;

• woher: Positionierungsposition, also der Referenzpunkt

SEEK_SET : Setzt den Offset der Datei auf Offset-Bytes vom Anfang der Datei;

SEEK_CUR: Setzt den Offset der Datei auf ihren aktuellen Wert plus Offset, der Offset kann positiv oder negativ sein ;

SEEK_END: Stellen Sie die Verschiebung der Datei auf die Dateilänge plus Versatz ein. Der Versatz kann positiv oder negativ sein (wenn es zu diesem Zeitpunkt ein positiver Wert ist, handelt es sich bitte um eine Lochfeile siehe unten Erklärung);

Rückgabewert: ** Bei Erfolg die neue Dateiverschiebung (absolute Verschiebung) zurückgeben ** Wenn ein Fehler auftritt, beträgt sie -1, wenn sie am Ende der Datei positioniert wird die Datei kann zurückgegeben werden;

Die Funktion lseek kann auch verwendet werden, um zu bestimmen, ob die Dateideskriptor auf eine Pipe oder einen FIFO verweist, gibt lseek -1 zurück und setzt errno auf EPLPE;

hole-Dateibeispiel:

#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;
}

Wenn wir den Befehl „more“ zum Anzeigen des Dateiinhalts verwenden, stellen wir fest, dass der angezeigte Inhalt nur das Ergebnis des einmaligen Schreibens ist -c Befehl zum Anzeigen des ASSCI-Codes der Datei. Wir werden feststellen, dass zwischen den beiden Inhalten 10 liegen

Öffnen Sie eine neue Datei.

Lesen Sie einen Teil der ursprünglichen Binärdatei und schreiben Sie ihn in die neue Datei. ) == 0 wird als Bedingung für das Stoppen der Schleife verwendet. Wenn die Schleife nicht gelesen werden kann, bedeutet dies, dass sie abgeschlossen ist Datei, kann der untergeordnete Prozess des Forks den Zugriff mit dem übergeordneten Prozess teilen?

Jedes Mal, wenn wir eine Datei öffnen, wird im Kernel eine Struktur wie eine Strukturdatei generiert, um die geöffnete Datei darzustellen und die folgenden Informationen aufzuzeichnen:

Dateioffset (beginnend bei 0, Der Dateizeiger-Offset während die Daten geschrieben werden)

Referenzanzahl (mehrere Prozesse verwenden diese geöffnete Datei)

Inode-Knoten (speichert die Attributinformationen des Prozesses: Wer hat ihn erstellt, wie lautet der Name, wo ist die Festplatte? gespeichert? Über diesen Inode-Knoten können wir die entsprechende spezifische Datei finden

close(fd) steht auf der äußersten Seite und sowohl der übergeordnete als auch der untergeordnete Prozess werden geschlossen. Bei jedem Schließen wird der Referenzzähler um 1 verringert, bis er 0 erreicht.

Die Laufergebnisse sind wie folgt:

Die Gründe sind wie folgt:

• Test 2: Zuerst forken und dann die Datei öffnen

• Nach dem Ändern des Codes ändern sich die Laufergebnisse wie folgt :

• Weil die übergeordneten und untergeordneten Prozesse getrennt sind. Anschließend werden die jeweiligen Dateien geöffnet, die entsprechenden Strukturdateien generiert und Dateioffsets werden nicht mehr gemeinsam genutzt.
• In tatsächlichen Anwendungsszenarien verwenden wir hauptsächlich Dateien, die vom übergeordneten Prozess und untergeordneten Prozessen geöffnet wurden, um auf dieses Formular zuzugreifen.

Das obige ist der detaillierte Inhalt vonSo rufen Sie das zugrunde liegende System der Linux-Betriebsdateien auf. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!