Linux Exec rendszerhívás

Az exec rendszerhívás egy aktív folyamatban lévő fájl végrehajtására szolgál. Az exec hívásakor az előző futtatható fájl kicserélődik, és új fájl kerül végrehajtásra.

Pontosabban azt mondhatjuk, hogy az exec rendszerhívás használata a régi fájlt vagy programot egy új fájlra vagy programra cseréli. A folyamat teljes tartalmát egy új program váltja fel.

A felhasználói adatszegmens, amely végrehajtja az exec () rendszerhívást, lecserélésre kerül az adatfájlra, amelynek neve szerepel az argumentumban az exec () hívása közben.

Az új program ugyanarra a folyamattérre töltődik be. A jelenlegi folyamat csak egy új folyamatgá változik, és ezért a folyamatazonosító PID nem változik, ez azért van, mert nem új folyamatot hozunk létre, hanem egy folyamatot cserélünk le egy másikra.

Ha az éppen futó folyamat több szálat tartalmaz, akkor az összes szál leáll, és az új folyamatkép betöltődik, majd végrehajtásra kerül. Nincsenek olyan destruktori funkciók, amelyek lezárnák az aktuális folyamat szálait.

A folyamat PID-je nem változik, de az adatok, kód, verem, halom stb. A folyamat folyamatai megváltoznak, és helyébe lépnek az újonnan betöltött folyamatok. Az új folyamat a belépési ponttól indul.

Az Exec rendszerhívás függvények gyűjteménye, és C programozási nyelven ezeknek a függvényeknek a standard nevei a következők:

execl

execle

execlp

execv

végrehajtani

execvp

Itt kell megjegyezni, hogy ezeknek a funkcióknak ugyanaz az alapja exec amelyet egy vagy több betű követ. Ezeket az alábbiakban magyarázzuk:

e: Ez egy olyan tömb mutató, amely a környezeti változókra mutat, és kifejezetten továbbadódik az újonnan betöltött folyamatnak.

l: l a parancssori argumentumok egy listát adtak át a függvénynek

p: p az elérési út környezeti változó, amely segít megtalálni a folyamatba töltendő argumentumként átadott fájlt.

v: v a parancssori argumentumokra vonatkozik. Ezeket mutatók tömbjeként adják át a függvénynek.

Miért használják az exec-et??

Az exec akkor használható, ha a felhasználó új fájlt vagy programot akar elindítani ugyanabban a folyamatban.

Az exec belső munkája

Vegye figyelembe a következő pontokat az exec működésének megértéséhez:

Az aktuális folyamatkép felülíródik egy új folyamatképpel.
Az új folyamatkép az, amelyet exec argumentumként adott át
A jelenleg futó folyamat befejeződött
Az új folyamatkép ugyanazzal a folyamatazonosítóval, ugyanazzal a környezettel és fájlleíróval rendelkezik (mivel a folyamatot nem cserélik le, a folyamatképet lecserélik)
Ez a CPU statját és a virtuális memóriát érinti. Az aktuális folyamatkép virtuális memória-leképezését az új folyamatkép virtuális memóriája váltja fel.

Az exec családi funkciók szintaxisa:

A következő az exec egyes funkcióinak szintaxisa:

int execl (const char * elérési út, const char * arg,…)
int execlp (const char * fájl, const char * arg,…)
int execle (const char * elérési út, const char * arg,…, char * const envp [])
int execv (const char * elérési út, const char * argv [])
int execvp (const char * fájl, const char * argv [])
int execvpe (const char * fájl, const char * argv [], char * const envp [])

Leírás:

Ezen függvények visszatérési típusa Int. Ha a folyamatkép sikeresen kicserélődik, semmi sem kerül vissza a hívó függvénybe, mert az azt hívó folyamat már nem fut. De ha hibát észlel, -1 értéket ad vissza. Ha bármilyen hiba történt, akkor egy errno be van állítva.

Szintaxisban:

pálya a végrehajtandó fájl teljes elérési útjának megadására szolgál.

arg az elfogadott érv. Valójában a fájl neve lesz végrehajtva a folyamat során. A legtöbbször az arg és az út értéke megegyezik.

const char * arg az execl (), az execlp () és az execle () függvényekben arg0, arg1, arg2,…, argn. Alapjában véve a null végződő karakterláncok mutatóinak listája. Itt az első argumentum a fájlnévre mutat, amelyet a 2. pontban leírtak szerint hajtanak végre.

envp egy tömb, amely mutatókat tartalmaz, amelyek a környezeti változókra mutatnak.

fájl az útvonal nevének megadására szolgál, amely azonosítja az új folyamat képfájljának útvonalát.

Az exec funkciói ezzel végződnek e felhasználják az új folyamatkép környezetének megváltoztatására. Ezek a függvények átadják a környezeti beállítások listáját az argumentum használatával envp. Ez az argumentum egy tömb karakter, amely null-végű Stringre mutat és meghatározza a környezeti változót.

Az exec család funkcióinak használatához a következő fejlécfájlt kell tartalmaznia a C programban:

#include

1. példa: Az exec rendszerhívás használata a C programban

Tekintsük a következő példát, amelyben az exec rendszerhívást használtuk a C programozásban Linux, Ubuntu rendszerben: Itt két c fájl áll rendelkezésre.c és hello.c:

példa.c

KÓD:

#include
#include
#include
int main (int argc, char * argv [])

printf ("példa PID.c =% d \ n ", getpid ());
char * args [] = "Hello", "C", "Programozás", NULL;
execv ("./ hello ", érvel);
printf ("Vissza a példához.c ");
visszatér 0;

Helló.c

KÓD:

#include
#include
#include
int main (int argc, char * argv [])

printf ("Hello-ban vagyunk.c \ n ");
printf ("helló PID.c =% d \ n ", getpid ());
visszatér 0;

KIMENET:

PID a példa.c = 4733
Hello-ban vagyunk.c
Helló PID.c = 4733

A fenti példában van egy példa.c fájl és szia.c fájl. A példában .c fájl mindenekelőtt kinyomtattuk az aktuális folyamat azonosítóját (fájlpélda.c fut az aktuális folyamatban). Ezután a következő sorban létrehoztunk egy tömb karakter mutatót. Ennek a tömbnek az utolsó eleme legyen NULL, mint végpont.

Ezután az execv () függvényt használtuk, amely a fájl nevét és a karakter mutató tömböt veszi fel argumentumnak. Itt kell megjegyezni, hogy használtuk ./ a fájl nevével megadja a fájl elérési útját. Mivel a fájl abban a mappában van, ahol példa.c lakik, így nincs szükség a teljes elérési út megadására.

Ha meghívjuk az execv () függvényt, akkor a folyamatképünket a fájl példa helyettesíti.c nincs folyamatban, de a hello fájl.c folyamatban van. Látható, hogy a folyamatazonosító ugyanaz, akár hello.c a folyamat képe vagy példa.c a folyamat képe, mert a folyamat megegyezik, és a folyamat képe csak kicserélődik.

Ezután meg kell jegyeznünk egy másik dolgot, amely a printf () utasítás az execv () végrehajtása után. Ez azért van, mert a vezérlés soha nem kerül vissza a régi folyamatképbe, ha az új folyamatkép felváltja. A vezérlés csak akkor tér vissza a hívási funkcióhoz, ha a folyamatkép cseréje sikertelen. (A visszatérési érték ebben az esetben -1).

Különbség a fork () és az exec () rendszerhívások között:

A fork () rendszerhívás a futó folyamat pontos másolatának létrehozására szolgál, a létrehozott másolat pedig a gyermek folyamat, a futó folyamat pedig a szülő folyamat. Míg az exec () rendszerhívást használjuk arra, hogy a folyamatképet új folyamatképpel helyettesítsük. Ezért az exec () rendszerhívásban nincs fogalom a szülő és gyermek folyamatokról.

A fork () rendszerhívásban a szülő és a gyermek folyamatok egyszerre kerülnek végrehajtásra. De az exec () rendszerhívásnál, ha a folyamatkép cseréje sikeres, a vezérlő nem tér vissza oda, ahova az exec függvényt hívták, inkább végrehajtja az új folyamatot. A vezérlő csak akkor kerül vissza, ha bármilyen hiba van.

2. példa: A fork () és az exec () rendszerhívások kombinálása

Tekintsük a következő példát, amelyben a fork () és az exec () rendszerhívásokat egyaránt használtuk ugyanabban a programban:

példa.c

KÓD:

#include
#include
#include
int main (int argc, char * argv [])

printf ("példa PID.c =% d \ n ", getpid ());
pid_t p;
p = villa ();
ha (p == - 1)

printf ("Hiba történt a fork () meghívása közben");

ha (p == 0)

printf ("A gyermek folyamatban vagyunk \ n");
printf ("Helló hívása.c a gyermek folyamatából \ n ");
char * args [] = "Hello", "C", "Programozás", NULL;
execv ("./ hello ", érvel);

más

printf ("A szülő folyamatban vagyunk");

visszatér 0;

Helló.c:

KÓD:

#include
#include
#include
int main (int argc, char * argv [])

printf ("Hello-ban vagyunk.c \ n ");
printf ("helló PID.c =% d \ n ", getpid ());
visszatér 0;

KIMENET:

PID a példa.c = 4790
Szülői folyamatban vagyunk
Gyermek folyamatban vagyunk
Helló hívás.c a gyermek folyamatából
Sziasztok.c
Helló PID.c = 4791

Ebben a példában a fork () rendszerhívást használtuk. Amikor a gyermek folyamat létrejön, 0-t rendelünk p-hez, majd áttérünk a gyermek folyamatra. Most az if (p == 0) utasítással rendelkező blokk kerül végrehajtásra. Megjelenik egy üzenet, és felhasználtuk az execv () rendszerhívást és az aktuális gyermek folyamatképet, amely példa.c helyébe hello lép.c. Az execv () hívás előtt a gyermek és a szülő folyamatai azonosak voltak.

Látható, hogy a PID a példa.c és hello.c most más. Ez azért van, mert példa.c a szülő folyamat képe és hello.c a gyermek folyamatképe.