Linux-Systemaufrufe für Betriebsdateien

Zu importierende Headerdateien:

#include <unistd.h>

1. Öffnen Sie die Datei

Öffnen einer vorhandenen Datei

int öffnen(const char *Pfadname, int Flags);

Erstellen Sie eine neue Datei und legen Sie Berechtigungen fest

int öffnen(const char *Pfadname, int Flags, mode_t Modus);

Parametereinführung

Pfadname: Der Pfad und Name der zu öffnenden Datei

Flaggen: Offene Flagge

Logo-Einführung:

Die Argumentflags müssen einen der folgenden Zugriffsmodi enthalten:
O_RDONLY, O_WRONLY oder O_RDWR. Diese fordern das Öffnen der Datei an,
Nur, Nur Schreiben oder Lesen/Schreiben.

O_RDONLY Nur zum Lesen öffnen

O_RDWR Zum Lesen und Schreiben geöffnet

O_CREAT Erstellt die Datei, wenn sie nicht existiert

O_APPEND An das Ende der Datei anhängen

O_TRUNC Löscht die Datei und schreibt den Modus neu

Für den Modus stehen folgende symbolische Konstanten zur Verfügung:

S_IRWXU 00700 Benutzer (Dateibesitzer) hat Lese-, Schreib- und Ausführungsberechtigung
                       

S_IRUSR 00400 Benutzer hat Leseberechtigung

S_IWUSR 00200 Benutzer hat Schreibberechtigung

S_IXUSR 00100 Benutzer hat Ausführungsberechtigung

S_IRWXG 00070 Gruppe hat Lese-, Schreib- und Ausführungsberechtigung

S_IRGRP 00040 Gruppe hat Leseberechtigung

S_IWGRP 00020 Gruppe hat Schreibberechtigung

S_IXGRP 00010 Gruppe hat Ausführungsberechtigung

S_IRWXO 00007 andere haben Lese-, Schreib- und Ausführungsberechtigung

S_IROTH 00004 andere haben Leseberechtigung

S_IWOTH 00002 andere haben Schreibberechtigung

S_IXOTH 00001 andere haben Ausführungsberechtigung

Rückgabewert: Dateideskriptor

2. Dateien lesen

ssize_t lesen (int fd, void *buf, size_t Anzahl);

Parametereinführung

fd: der entsprechende geöffnete Dateideskriptor buf: der Speicherplatz für die Daten count: die Anzahl der Datenbytes, die gleichzeitig aus der Datei gelesen werden sollen return value: die tatsächliche Anzahl der gelesenen Bytes

3. Schreiben Sie eine Datei

ssize_t schreiben (int fd, const void *buf, size_t Anzahl);

Parametereinführung:

fd: entspricht dem geöffneten Dateideskriptor buf: speichert die zu schreibenden Daten count: wie viele Daten gleichzeitig in die Datei geschrieben werden sollen

4. Schließen

int schließen(int fd);

fd: der entsprechende Dateideskriptor

Analysefragen

Wenn der übergeordnete Prozess zuerst eine Datei öffnet, kann der untergeordnete Prozess sie nach dem Forking freigeben?

Dateiinhalt

Code

#include <stdio.h>
#include <unistd.h>
#include <assert.h>
#include <fcntl.h>
#include<stdlib.h>

int main()
{
    char buff[128] = {0};

    int fd = öffnen("meineDatei.txt", O_RDONLY);

    pid_t pid = gabel();
    behaupten(pid != -1);

    wenn (pid == 0)
    {
        lesen(fd, buff, 1);
        printf("Kind-Buff = %s\n", Buff);

        Schlaf (1);
        lesen(fd, buff, 1);
        printf("Kind-Buff = %s\n", Buff);

    }
    anders
    {
        lesen(fd, buff, 1);
        printf("übergeordneter Buff = %s\n", Buff);

        Schlaf (1);
        lesen(fd, buff, 1);
        printf("übergeordneter Buff = %s\n", Buff);
    }

    schließen(fd);

    Ausfahrt (0);
}

Laufergebnisse:

abschließend :

Da der PCB des durch Fork erstellten untergeordneten Prozesses eine Kopie des übergeordneten Prozesses ist, kopiert der Zeiger auf die geöffnete Datei in der Dateitabelle im PCB des untergeordneten Prozesses einfach den Wert im PCB des übergeordneten Prozesses, sodass die übergeordneten und untergeordneten Prozesse alle Dateideskriptoren gemeinsam nutzen, die vor dem Fork des übergeordneten Prozesses geöffnet wurden.

Übungen

Kopie einer Datei abschließen (ähnlich dem Befehl: cp)

Der ursprüngliche Dateiinhalt ist:

Code:

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include<stdlib.h>
#include <assert.h>

int Haupt(void)
{
    char buff[128] = {0};

    int fdr = öffnen("meineDatei.txt", O_RDONLY);
    behaupten(fdr != -1);

    int fdw = öffnen("neueDatei.txt", O_WRONLY | O_CREAT, 0600);
    behaupten(fdw != -1);

    Int. n = 0;
    während (n = lesen(fdr, buff, 128) > 0)
    {
        schreiben(fdw, buff, n);
    }

    schließen(fdr);
    schließen(fdw);
    
    Ausfahrt (0);
}

Ausführen des Beispiels:

Sie können sehen, dass newfile.txt erfolgreich erstellt wurde

Der Unterschied zwischen Systemaufrufen und Bibliotheksfunktionen

Unterschied: Die Implementierung von Systemaufrufen erfolgt im Kernel und gehört zum Kernelbereich, während die Implementierung von Bibliotheksfunktionen in der Funktionsbibliothek erfolgt und zum Benutzerbereich gehört.

Ausführungsprozess des Systemaufrufs:

Dies ist das Ende dieses Artikels über Linux-Systemaufrufe zum Bedienen von Dateien. Weitere Informationen zu Linux-Dateisystemaufrufen finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!