Der Unterschied zwischen fork (), vfork (), exec () und clone ()

Ich habe nach dem Unterschied zwischen diesen vier bei Google gesucht und erwartet, dass es eine große Menge an Informationen dazu gibt, aber es gab wirklich keinen soliden Vergleich zwischen den vier Anrufen.

Ich habe versucht, eine Art grundlegenden Überblick über die Unterschiede zwischen diesen Systemaufrufen zu erhalten, und hier ist, was ich bekommen habe. Sind alle diese Informationen korrekt / fehlt mir etwas Wichtiges?

Fork : Der Fork-Aufruf erstellt im Grunde genommen ein Duplikat des aktuellen Prozesses, das in fast jeder Hinsicht identisch ist (in einigen Implementierungen wird nicht alles kopiert, z. B. Ressourcenbeschränkungen, aber die Idee ist, eine möglichst enge Kopie zu erstellen).

Der neue Prozess (untergeordnet) erhält eine andere Prozess-ID (PID) und hat die PID des alten Prozesses (übergeordnet) als übergeordnete PID (PPID). Da die beiden Prozesse jetzt genau denselben Code ausführen, können sie anhand des Rückkehrcodes von fork erkennen, welcher Code welcher ist - das Kind erhält 0, das Elternteil erhält die PID des Kindes. Dies alles ist natürlich vorausgesetzt, dass der Fork-Aufruf funktioniert. Wenn nicht, wird kein untergeordnetes Element erstellt und das übergeordnete Element erhält einen Fehlercode.

Vfork: Der grundlegende Unterschied zwischen vfork und fork besteht darin, dass beim Erstellen eines neuen Prozesses mit vfork () der übergeordnete Prozess vorübergehend angehalten wird und der untergeordnete Prozess möglicherweise den Adressraum des übergeordneten Prozesses ausleiht. Dieser seltsame Zustand setzt sich fort, bis der untergeordnete Prozess entweder beendet wird oder execve () aufruft. An diesem Punkt wird der übergeordnete Prozess fortgesetzt.

Dies bedeutet, dass der untergeordnete Prozess einer vfork () vorsichtig sein muss, um zu vermeiden, dass Variablen des übergeordneten Prozesses unerwartet geändert werden. Insbesondere darf der untergeordnete Prozess nicht von der Funktion zurückkehren, die den Aufruf von vfork () enthält, und er darf nicht exit () aufrufen (wenn er beendet werden muss, sollte er _exit () verwenden; dies gilt tatsächlich auch für das untergeordnete Element einer normalen Gabel ()).

Exec :Der Exec-Aufruf ist eine Möglichkeit, den gesamten aktuellen Prozess durch ein neues Programm zu ersetzen. Es lädt das Programm in den aktuellen Prozessbereich und führt es vom Einstiegspunkt aus. exec () ersetzt den aktuellen Prozess durch die ausführbare Datei, auf die die Funktion zeigt. Die Steuerung kehrt niemals zum ursprünglichen Programm zurück, es sei denn, es liegt ein exec () - Fehler vor.

Clone :Klonen als Gabel erzeugt einen neuen Prozess. Im Gegensatz zu Fork ermöglichen diese Aufrufe dem untergeordneten Prozess, Teile seines Ausführungskontexts mit dem aufrufenden Prozess zu teilen, z. B. den Speicherplatz, die Tabelle der Dateideskriptoren und die Tabelle der Signalhandler.

Wenn der untergeordnete Prozess mit dem Klon erstellt wird, führt er die Funktionsanwendung fn (arg) aus. (Dies unterscheidet sich von Fork, bei dem die Ausführung im untergeordneten Element ab dem Zeitpunkt des ursprünglichen Fork-Aufrufs fortgesetzt wird.) Das Argument fn ist ein Zeiger auf eine Funktion, die vom untergeordneten Prozess zu Beginn seiner Ausführung aufgerufen wird. Das Argument arg wird an die Funktion fn übergeben.

Wenn die Funktionsanwendung fn (arg) zurückkehrt, wird der untergeordnete Prozess beendet. Die von fn zurückgegebene Ganzzahl ist der Exit-Code für den untergeordneten Prozess. Der untergeordnete Prozess kann auch explizit durch Aufrufen von exit (2) oder nach Empfang eines schwerwiegenden Signals beendet werden.

Informationen erhalten Form:

• Unterschiede zwischen Gabel und Exec
• http://www.allinterview.com/showanswers/59616.html
• http://www.unixguide.net/unix/programming/1.1.2.shtml
• http://linux.about.com/library/cmd/blcmdl2_clone.htm

Vielen Dank, dass Sie sich die Zeit genommen haben, dies zu lesen! :) :)

• vfork()ist eine veraltete Optimierung. Vor einer guten Speicherverwaltung wurde fork()eine vollständige Kopie des Speichers der Eltern erstellt, sodass dies ziemlich teuer war. Da in vielen Fällen a fork()folgte exec(), wodurch die aktuelle Speicherzuordnung verworfen und eine neue erstellt wird, war dies ein unnötiger Aufwand. Heutzutage wird fork()der Speicher nicht kopiert. Es wird einfach als "Kopieren beim Schreiben" festgelegt, sodass fork()+ exec()genauso effizient ist wie vfork()+ exec().

• clone()ist der von fork(). Mit einigen Parametern wird ein neuer Prozess erstellt, mit anderen wird ein Thread erstellt. Der Unterschied zwischen ihnen besteht darin, welche Datenstrukturen (Speicherplatz, Prozessorstatus, Stapel, PID, geöffnete Dateien usw.) gemeinsam genutzt werden oder nicht.

• execve() Ersetzt das aktuelle ausführbare Image durch ein anderes, das aus einer ausführbaren Datei geladen wurde.
• fork() erstellt einen untergeordneten Prozess.
• vfork()ist eine historisch optimierte Version von fork(), die verwendet werden soll, wenn execve()sie direkt danach aufgerufen wird fork(). Es stellte sich heraus, dass es in Nicht-MMU-Systemen (in denen fork()nicht effizient gearbeitet werden kann) und in fork()Prozessen mit großem Speicherbedarf gut funktioniert , um ein kleines Programm auszuführen (denken Sie an Java Runtime.exec()). POSIX hat das standardisiert posix_spawn(), um diese beiden letztgenannten moderneren Anwendungen zu ersetzen vfork().
• posix_spawn()macht das Äquivalent von a fork()/execve()und erlaubt auch etwas fd Jonglieren dazwischen. Es soll ersetzen fork()/execve(), hauptsächlich für Nicht-MMU-Plattformen.
• pthread_create() erstellt einen neuen Thread.
• clone()ist ein Linux-spezifischer Aufruf, mit dem alles von fork()bis implementiert werden kann pthread_create(). Es gibt viel Kontrolle. Inspiriert am rfork().
• rfork()ist ein Plan-9-spezifischer Anruf. Es soll ein generischer Aufruf sein, der mehrere Grade der gemeinsamen Nutzung zwischen vollständigen Prozessen und Threads ermöglicht.

1. fork()- Erstellt einen neuen untergeordneten Prozess, der eine vollständige Kopie des übergeordneten Prozesses ist. Untergeordnete und übergeordnete Prozesse verwenden unterschiedliche virtuelle Adressräume, die anfänglich von denselben Speicherseiten gefüllt werden. Wenn dann beide Prozesse ausgeführt werden, unterscheiden sich die virtuellen Adressräume immer mehr, da das Betriebssystem ein verzögertes Kopieren von Speicherseiten durchführt, die von einem dieser beiden Prozesse geschrieben werden, und eine unabhängige Kopie der geänderten Seiten von zuweist Speicher für jeden Prozess. Diese Technik wird als Copy-On-Write (COW) bezeichnet.
2. vfork()- Erstellt einen neuen untergeordneten Prozess, bei dem es sich um eine "schnelle" Kopie des übergeordneten Prozesses handelt. Im Gegensatz zum Systemaufruf fork()teilen sich untergeordnete und übergeordnete Prozesse denselben virtuellen Adressraum. HINWEIS! Bei Verwendung des gleichen virtuellen Adressraums verwenden sowohl das übergeordnete als auch das untergeordnete Element denselben Stapel, den Stapelzeiger und den Anweisungszeiger, wie im Fall des Klassikers fork()! Um unerwünschte Interferenzen zwischen übergeordneten und untergeordneten Elementen zu vermeiden, die denselben Stapel verwenden, wird die Ausführung des übergeordneten Prozesses eingefroren, bis das untergeordnete Element entweder exec()(Erstellen eines neuen virtuellen Adressraums und Übergang zu einem anderen Stapel) oder _exit()(Beenden der Prozessausführung) aufruft ). vfork()ist die Optimierung der fork()für „fork-and-exec“ -Modell. Es kann 4-5 mal schneller als das durchgeführt werden fork(), weil im Gegensatz zumfork()(Selbst wenn COW im Auge behalten wird) beinhaltet die Implementierung eines vfork()Systemaufrufs nicht die Erstellung eines neuen Adressraums (die Zuweisung und Einrichtung neuer Seitenverzeichnisse).
3. clone()- Erstellt einen neuen untergeordneten Prozess. Verschiedene Parameter dieses Systemaufrufs geben an, welche Teile des übergeordneten Prozesses in den untergeordneten Prozess kopiert werden müssen und welche Teile zwischen ihnen geteilt werden. Infolgedessen kann dieser Systemaufruf verwendet werden, um alle Arten von Ausführungsentitäten zu erstellen, beginnend mit Threads und endend durch völlig unabhängige Prozesse. Tatsächlich ist der clone()Systemaufruf die Basis, die für die Implementierung pthread_create()und die gesamte Familie der fork()Systemaufrufe verwendet wird.
4. exec()- setzt den gesamten Speicher des Prozesses zurück, lädt und analysiert die angegebene ausführbare Binärdatei, richtet einen neuen Stapel ein und übergibt die Steuerung an den Einstiegspunkt der geladenen ausführbaren Datei. Dieser Systemaufruf gibt niemals die Kontrolle an den Aufrufer zurück und dient zum Laden eines neuen Programms in den bereits vorhandenen Prozess. Dieser Systemaufruf mitfork() Systemaufruf bildet zusammen ein klassisches UNIX-Prozessmanagementmodell namens "fork-and-exec".

Fork (), vfork () und clone () rufen alle do_fork () auf, um die eigentliche Arbeit zu erledigen, jedoch mit unterschiedlichen Parametern.

asmlinkage int sys_fork(struct pt_regs regs)
{
    return do_fork(SIGCHLD, regs.esp, &regs, 0);
}

asmlinkage int sys_clone(struct pt_regs regs)
{
    unsigned long clone_flags;
    unsigned long newsp;

    clone_flags = regs.ebx;
    newsp = regs.ecx;
    if (!newsp)
        newsp = regs.esp;
    return do_fork(clone_flags, newsp, &regs, 0);
}
asmlinkage int sys_vfork(struct pt_regs regs)
{
    return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs.esp, &regs, 0);
}
#define CLONE_VFORK 0x00004000  /* set if the parent wants the child to wake it up on mm_release */
#define CLONE_VM    0x00000100  /* set if VM shared between processes */

SIGCHLD means the child should send this signal to its father when exit.

Für Fork haben das Kind und der Vater die unabhängige VM-Seitentabelle, aber da Fork aus Effizienzgründen keine Seiten wirklich kopiert, werden nur alle beschreibbaren Seiten so eingestellt, dass sie für den untergeordneten Prozess schreibgeschützt sind. Wenn der untergeordnete Prozess etwas auf diese Seite schreiben möchte, tritt eine Seitenausnahme auf und der Kernel weist eine neue Seite zu, die mit Schreibberechtigung von der alten Seite geklont wurde. Das nennt man "copy on write".

Für vfork ist der virtuelle Speicher genau von Kind und Vater - nur deshalb können Vater und Kind nicht gleichzeitig wach sein, da sie sich gegenseitig beeinflussen. Der Vater wird also am Ende von "do_fork ()" schlafen und aufwachen, wenn das Kind exit () oder execve () aufruft, da es seitdem eine neue Seitentabelle besitzt. Hier ist der Code (in do_fork ()), den der Vater schläft.

if ((clone_flags & CLONE_VFORK) && (retval > 0))
down(&sem);
return retval;

Hier ist der Code (in mm_release (), der von exit () und execve () aufgerufen wird und den Vater weckt.

up(tsk->p_opptr->vfork_sem);

Für sys_clone () ist es flexibler, da Sie beliebige clone_flags eingeben können. Also ruft pthread_create () diesen Systemaufruf mit vielen clone_flags auf:

int clone_flags = (CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGNAL | CLONE_SETTLS | CLONE_PARENT_SETTID | CLONE_CHILD_CLEARTID | CLONE_SYSVSEM);

Zusammenfassung: Mit fork (), vfork () und clone () werden untergeordnete Prozesse mit unterschiedlichen Ressourcen für die gemeinsame Nutzung von Ressourcen mit dem Vaterprozess erstellt. Wir können auch sagen, dass vfork () und clone () Threads erstellen können (tatsächlich sind sie Prozesse, da sie unabhängige task_struct haben), da sie die VM-Seitentabelle mit dem Vaterprozess gemeinsam nutzen.

In fork () wird entweder der untergeordnete oder der übergeordnete Prozess basierend auf der CPU-Auswahl ausgeführt. In vfork () wird das untergeordnete Element sicherlich zuerst ausgeführt. Nachdem das Kind beendet wurde, wird das Elternteil ausgeführt.