Apelul de sistem exec este folosit pentru a executa un fișier care se află într-un proces activ. Când se numește exec, fișierul executabil anterior este înlocuit și se execută un fișier nou.
Mai precis, putem spune că utilizarea apelului de sistem exec va înlocui vechiul fișier sau program din proces cu un fișier sau program nou. Întregul conținut al procesului este înlocuit cu un nou program.
Segmentul de date utilizator care execută apelul de sistem exec () este înlocuit cu fișierul de date al cărui nume este furnizat în argument în timp ce apelează exec ().
Noul program este încărcat în același spațiu de proces. Procesul actual este doar transformat într-un proces nou și, prin urmare, ID-ul procesului PID nu este modificat, deoarece nu creăm un proces nou, doar înlocuim un proces cu un alt proces în exec.
Dacă procesul care rulează în prezent conține mai mult de un fir, toate firele vor fi încheiate și noua imagine a procesului va fi încărcată și apoi executată. Nu există funcții de distrugere care termină firele procesului curent.
PID al procesului nu este modificat, dar datele, codul, stiva, heap, etc. ale procesului sunt modificate și sunt înlocuite cu cele ale procesului nou încărcat. Noul proces este executat de la punctul de intrare.
Apelul de sistem Exec este o colecție de funcții și în limbajul de programare C, numele standard pentru aceste funcții sunt după cum urmează:
- execl
- execle
- execlp
- execv
- execve
- execvp
Trebuie remarcat aici că aceste funcții au aceeași bază exec urmat de una sau mai multe litere. Acestea sunt explicate mai jos:
Și: Este o matrice de indicatori care indică variabilele de mediu și este transmisă explicit procesului nou încărcat.
: l este pentru argumentele din linia de comandă a trecut o listă funcției
p: p este variabila de mediu de cale care ajută la găsirea fișierului transmis ca argument pentru a fi încărcat în proces.
v: v este pentru argumentele din linia de comandă. Acestea sunt transmise ca o serie de indicatori către funcție.
De ce este folosit exec?
exec este utilizat atunci când utilizatorul dorește să lanseze un nou fișier sau program în același proces.
Lucrul interior al execut
Luați în considerare următoarele puncte pentru a înțelege funcționarea execut:
- Imaginea procesului curent este suprascrisă cu o nouă imagine proces.
- Noua imagine de proces este cea pe care ați trecut-o ca argument exec
- Procesul care rulează în prezent este încheiat
- Noua imagine de proces are același ID de proces, același mediu și același descriptor de fișier (deoarece procesul nu este înlocuit, imaginea de proces este înlocuită)
- Statistica procesorului și memoria virtuală sunt afectate. Cartarea memoriei virtuale a imaginii procesului curent este înlocuită de memoria virtuală a imaginii procesului nou.
Sintaxele funcțiilor familiei exec:
Următoarele sunt sintaxele pentru fiecare funcție a execut:
int execl (const char * path, const char * arg, ...)int execlp (const char * fișier, const char * arg, ...)
int execle (const char * path, const char * arg, ..., char * const envp [])
int execv (const char * path, const char * argv [])
int execvp (const char * fișier, const char * argv [])
int execvpe (const char * fișier, const char * argv [], char * const envp [])
Descriere:
Tipul returnat al acestor funcții este Int. Când imaginea procesului este înlocuită cu succes, nimic nu se întoarce la funcția de apelare, deoarece procesul care a apelat-o nu mai rulează. Dar dacă există vreo eroare -1 va fi returnat. Dacă a apărut vreo eroare o errno este setat.
În sintaxă:
- cale este folosit pentru a specifica numele complet al căii fișierului care urmează să fie executat.
- furios este argumentul trecut. Este de fapt numele fișierului care va fi executat în proces. De cele mai multe ori valoarea arg și a căii este aceeași.
- const char * arg în funcțiile execl (), execlp () și execle () este considerat ca arg0, arg1, arg2, ..., argn. Este practic o listă de indicatori către șiruri terminate nule. Aici primul argument indică numele fișierului care va fi executat așa cum este descris la punctul 2.
- invp este o matrice care conține indicii care indică variabilele de mediu.
- fişier este folosit pentru a specifica numele căii care va identifica calea unui nou fișier imagine proces.
- Funcțiile apelului exec se termină cu Și sunt folosite pentru a schimba mediul pentru noua imagine de proces. Aceste funcții transmit lista setărilor de mediu utilizând argumentul invp . Acest argument este o matrice de caractere care indică șirul terminat nul și definește variabila de mediu.
Pentru a utiliza funcțiile familiei exec, trebuie să includeți următorul fișier antet în programul dvs. C:
#includeExemplul 1: Utilizarea apelului de sistem exec în programul C.
Luați în considerare următorul exemplu în care am folosit apelul de sistem exec în programarea C în Linux, Ubuntu: Avem două fișiere c aici example.c și hello.c:
exemplu.c
COD:
#include#include
#include
intprincipal(intargc, char *argv[])
{
printf ('PID al exemplului.c =% d n',obraznic());
char *argumente[] = {'Buna ziua', „C”, „Programare”,NUL};
execv('./Buna ziua',argumente);
printf („Înapoi la example.c”);
întoarcere 0;
}
buna
COD:
#include#include
#include
intprincipal(intargc, char *argv[])
{
printf („Suntem în Hello.c n');
printf ('PID de hello.c =% d n',obraznic());
întoarcere 0;
}
IEȘIRE:
PID al exemplului.c = 4733Suntem în Hello.c
PID de hello.c = 4733
În exemplul de mai sus avem un fișier example.c și un fișier hello.c. În exemplul .c fișier, în primul rând am imprimat ID-ul procesului curent (fișierul example.c rulează în procesul curent). Apoi, în următoarea linie am creat o serie de indicatori de caractere. Ultimul element al acestei matrice ar trebui să fie NULL ca punct de terminare.
Apoi am folosit funcția execv () care ia numele fișierului și matricea de pointer de caractere ca argument. Trebuie menționat aici că am folosit ./ cu numele fișierului, specifică calea fișierului. Deoarece fișierul se află în folderul în care se află example.c, nu este necesar să specificați calea completă.
Când funcția execv () este apelată, imaginea noastră de proces va fi înlocuită acum fișierul example.c nu este în proces, dar fișierul hello.c este în proces. Se poate vedea că ID-ul procesului este același, indiferent dacă hello.c este o imagine de proces sau example.c este o imagine de proces, deoarece procesul este același, iar imaginea de proces este doar înlocuită.
Apoi mai avem de remarcat aici care este instrucțiunea printf () după ce execv () nu este executat. Acest lucru se datorează faptului că controlul nu se întoarce niciodată înapoi la vechea imagine de proces, odată ce o nouă imagine de proces o înlocuiește. Controlul revine la funcția de apelare numai atunci când înlocuirea imaginii procesului nu reușește. (Valoarea returnată este -1 în acest caz).
Diferența dintre apelurile de sistem fork () și exec ():
Apelul de sistem fork () este utilizat pentru a crea o copie exactă a unui proces în execuție, iar copia creată este procesul copil, iar procesul de execuție este procesul părinte. În timp ce, apelul de sistem exec () este utilizat pentru a înlocui o imagine de proces cu o nouă imagine de proces. Prin urmare, nu există un concept de procese părinte și copil în apelul de sistem exec ().
În apelul de sistem fork (), procesele părinte și copil sunt executate în același timp. Dar în apelul de sistem exec (), dacă înlocuirea imaginii procesului are succes, controlul nu revine la locul unde a fost apelată funcția exec, ci va executa noul proces. Controlul va fi transferat înapoi numai dacă există vreo eroare.
Exemplul 2: Combinarea apelurilor de sistem fork () și exec ()
Luați în considerare următorul exemplu în care am folosit atât apelurile de sistem fork (), cât și exec () în același program:
exemplu.c
COD:
#include#include
#include
intprincipal(intargc, char *argv[])
{
printf ('PID al exemplului.c =% d n',obraznic());
pid_t p;
p=furculiţă();
dacă(p== -1)
{
printf („Există o eroare la apelarea fork ()”);
}
dacă(p==0)
{
printf („Suntem în procesul copilului n');
printf ('Apelarea hello.c din procesul copil n');
char *argumente[] = {'Buna ziua', „C”, „Programare”,NUL};
execv('./Buna ziua',argumente);
}
altceva
{
printf („Suntem în procesul părinte”);
}
întoarcere 0;
}
buna:
COD:
#include#include
#include
intprincipal(intargc, char *argv[])
{
printf („Suntem în Hello.c n');
printf ('PID de hello.c =% d n',obraznic());
întoarcere 0;
}
IEȘIRE:
PID al exemplului.c = 4790Suntem în procesul părinte
Suntem în procesul copilului
Apelând hello.c din procesul copil
Suntem în hello.c
PID de hello.c = 4791
În acest exemplu am folosit apelul de sistem fork (). Când se creează procesul copil 0 va fi atribuit lui p și apoi vom trece la procesul copil. Acum blocul de instrucțiuni cu if (p == 0) va fi executat. Se afișează un mesaj și am folosit apelul de sistem execv () și imaginea procesului copil curent, care este example.c va fi înlocuită cu hello.c. Înainte de executarea apelului () copilul și procesele părinte erau aceleași.
Se poate vedea că PID-ul example.c și hello.c este diferit acum. Acest lucru se datorează faptului că example.c este imaginea procesului părinte și hello.c este imaginea procesului copil.