Süsteemi käivitamist kasutatakse faili käivitamiseks, mis asub aktiivses protsessis. Kui käivitatakse käsk exec, asendatakse eelmine käivitatav fail ja käivitatakse uus fail.
Täpsemalt võime öelda, et käsu exec süsteemikõne kasutamine asendab protsessi vana faili või programmi uue faili või programmiga. Kogu protsessi sisu asendatakse uue programmiga.
Kasutajaandmete segment, mis täidab süsteemikõne exec (), asendatakse andmefailiga, mille nimi esitatakse argumendis exec () kutsudes.
Uus programm laaditakse samasse protsessiruumi. Praegune protsess muudeti lihtsalt uueks protsessiks ja seega ei muudeta protsessi ID PID -d, sest me ei loo uut protsessi, vaid asendame protsessi mõne muu protsessiga.
Kui praegu töötav protsess sisaldab rohkem kui ühte lõime, lõpetatakse kõik lõimed ning laaditakse uus protsessipilt ja seejärel käivitatakse. Puuduvad hävitamise funktsioonid, mis lõpetavad praeguse protsessi lõimed.
Protsessi PID -d ei muudeta, kuid protsessi andmeid, koodi, virna, hunnikut jne muudetakse ja need asendatakse äsja laaditud protsessiga. Uus protsess viiakse läbi sisenemispunktist.
Käivita süsteemikõne on funktsioonide kogum ja C -programmeerimiskeeles on nende funktsioonide standardnimed järgmised:
- täit
- eksiil
- execlp
- execv
- täitma
- execvp
Siinkohal tuleb märkida, et neil funktsioonidel on sama alus täideviija millele järgneb üks või mitu tähte. Neid selgitatakse allpool:
Ja: See on näpunäidete massiiv, mis osutab keskkonnamuutujatele ja edastatakse selgesõnaliselt äsja laaditud protsessile.
: l on käsurea argumendid, mis edastasid funktsioonile loendi
p: p on tee keskkonnamuutuja, mis aitab leida protsessi edastatava argumendina edastatud faili.
v: v on käsurea argumentide jaoks. Need edastatakse funktsioonile viidete massiivina.
Miks kasutatakse exec?
exec kasutatakse siis, kui kasutaja soovib samas protsessis käivitada uue faili või programmi.
Sisemine töötamine
Täitja töö mõistmiseks kaaluge järgmisi punkte.
- Praegune protsessipilt kirjutatakse uue protsessipildiga üle.
- Uus protsessipilt on see, mille andsite täitmisargumendina
- Hetkel töötav protsess on lõppenud
- Uuel protsessipildil on sama protsessi ID, sama keskkond ja sama failikirjeldus (kuna protsessi ei asendata protsessipilt asendatakse)
- See mõjutab CPU staatust ja virtuaalset mälu. Praeguse protsessipildi virtuaalse mälu kaardistamine asendatakse uue protsessipildi virtuaalse mäluga.
Täitepere funktsioonide süntaksid:
Järgmised on iga täitmisfunktsiooni süntaksid:
int execl (const char* tee, const char* arg,…)int execlp (const char* fail, const char* arg,…)
int execle (const char* tee, const char* arg,…, char* const envp [])
int execv (const char* tee, const char* argv [])
int execvp (const char* fail, const char* argv [])
int execvpe (const char* fail, const char* argv [], char* const envp [])
Kirjeldus:
Nende funktsioonide tagastustüüp on Int. Kui protsessi pilt on edukalt asendatud, ei tagastata midagi helistamisfunktsioonile, kuna seda kutsunud protsess ei tööta enam. Kuid vea korral tagastatakse -1. Kui ilmneb mõni viga an viga on seatud.
Süntaksis:
- tee kasutatakse käivitatava faili täieliku tee nime määramiseks.
- vihane kas argument on läbitud. See on tegelikult faili nimi, mis protsessis täidetakse. Enamasti on arg ja path väärtus sama.
- const char* arg funktsioonides execl (), execlp () ja execle () loetakse arg0, arg1, arg2,…, argn. Põhimõtteliselt on see näpunäidete nimekiri lõpetatud stringide nullimiseks. Siin osutab esimene argument failinimele, mis täidetakse punktis 2 kirjeldatud viisil.
- envp on massiiv, mis sisaldab keskkonnamuutujatele viitavaid näpunäiteid.
- faili kasutatakse tee nime määramiseks, mis tuvastab uue protsessipildifaili tee.
- Funktsioonid exec kutsuvad lõpuga Ja kasutatakse uue protsessipildi keskkonna muutmiseks. Need funktsioonid läbivad argumendi abil keskkonnaseadete loendi envp . See argument on märkide massiiv, mis osutab null -lõpetatud stringile ja määratleb keskkonnamuutuja.
Exec perekonna funktsioonide kasutamiseks peate oma C -programmi lisama järgmise päisefaili:
#kaasakeNäide 1: Exec -süsteemi kõne kasutamine C -programmis
Mõelge järgmisele näitele, milles oleme Linuxis Ubuntu C -programmeerimises kasutanud exec -süsteemi kutset: Meil on siin kaks c -faili example.c ja hello.c:
näide.c
KOOD:
#kaasake#kaasake
#kaasake
intpeamine(intargc, süsi *argv[])
{
printf ('Näite PID. C = %d n',loll());
süsi *args[] = {'Tere', 'C', 'Programmeerimine',NULL};
execv('./Tere',args);
printf ('Tagasi näite.c' juurde);
tagasi 0;
}
tere.c
KOOD:
#kaasake#kaasake
#kaasake
intpeamine(intargc, süsi *argv[])
{
printf ('Oleme Hello.c -s n');
printf ('Tere PID. C = %d n',loll());
tagasi 0;
}
VÄLJUND:
Näite PID. C = 4733Oleme Hello.c -s
Tere PID. C = 4733
Ülaltoodud näites on meil fail example.c ja hello.c. Näites .c fail on esmalt prinditud praeguse protsessi ID (fail example.c töötab praeguses protsessis). Seejärel oleme loonud järgmises reas märkide massiivi. Selle massiivi viimane element peaks olema lõpp -punkt NULL.
Seejärel oleme kasutanud funktsiooni execv (), mis võtab argumendiks failinime ja märgi osuti massiivi. Siinkohal tuleb märkida, et oleme faili nimega kasutanud ./, see määrab faili tee. Kuna fail asub kaustas example.c, ei ole vaja täielikku teed määrata.
Funktsiooni execv () kutsumisel asendatakse meie protsessipilt nüüd failiga example.c, kuid protsess hello.c ei ole protsessis. On näha, et protsessi ID on sama, kas tere.c on protsessi pilt või näide. C on protsessi pilt, kuna protsess on sama ja protsessipilt asendatakse ainult.
Siis on meil veel üks asi, mida siin tähele panna, mis on lause printf () pärast seda, kui execv () ei käivitata. Selle põhjuseks on asjaolu, et juhtelementi ei tagastata kunagi vana protsessipildi juurde, kui see asendatakse uue protsessipildiga. Juhtimine naaseb helistamisfunktsiooni alles siis, kui protsessipildi asendamine ebaõnnestus. (Tagastusväärtus on sel juhul -1).
Erinevus kahvli () ja exec () süsteemikõnede vahel:
Fork () süsteemikutset kasutatakse jooksva protsessi täpse koopia loomiseks ja loodud koopia on alamprotsess ning jooksev protsess on vanemprotsess. Seevastu süsteemi kutset exec () kasutatakse protsessipildi asendamiseks uue protsessipildiga. Seega puudub exec () süsteemikutses vanem- ja alamprotsesside kontseptsioon.
Fork () süsteemikõnes käivitatakse vanem- ja alamprotsess korraga. Kuid kui süsteemikutses exec () on protsessipildi asendamine edukas, ei naase juhtelement sinna, kus käivitusfunktsioon kutsuti, vaid käivitab uue protsessi. Juhtimine antakse tagasi ainult siis, kui esineb mõni viga.
Näide 2: kahvli () ja exec () süsteemikõnede kombineerimine
Vaatleme järgmist näidet, milles oleme samas programmis kasutanud nii fork () kui ka exec () süsteemikõnesid:
näide.c
KOOD:
#kaasake#kaasake
#kaasake
intpeamine(intargc, süsi *argv[])
{
printf ('Näite PID. C = %d n',loll());
pid_t lk;
lk=kahvel();
kui(lk== -1)
{
printf ('Kahvel () kutsumisel ilmnes viga);
}
kui(lk==0)
{
printf ('Me oleme lapsprotsessis n');
printf ('Helistamine lapsele protsessist tere.c n');
süsi *args[] = {'Tere', 'C', 'Programmeerimine',NULL};
execv('./Tere',args);
}
muidu
{
printf ('Oleme vanemprotsessis');
}
tagasi 0;
}
tere.c:
KOOD:
#kaasake#kaasake
#kaasake
intpeamine(intargc, süsi *argv[])
{
printf ('Oleme Hello.c -s n');
printf ('Tere PID. C = %d n',loll());
tagasi 0;
}
VÄLJUND:
Näite PID. C = 4790Oleme vanemate protsessis
Oleme lapsprotsessis
Lapseprotsessist helistamine hello.c -le
Oleme tere. C
Tere PID. C = 4791
Selles näites oleme kasutanud fork () süsteemikõnet. Kui alamprotsess on loodud, määratakse p -le 0 ja siis liigume alamprotsessi juurde. Nüüd täidetakse lausete plokk if (p == 0). Kuvatakse teade ja oleme kasutanud süsteemi kutset execv () ning praegust alamprotsessi pilti, mis on example.c asendatakse sõnaga hello.c. Enne execv () kõnet olid alam- ja vanemprotsessid samad.
On näha, et näite.c ja tere.c PID on nüüd erinev. Seda seetõttu, et näide.c on vanemprotsessi pilt ja tere. C on alamprotsessipilt.