Linux Execi süsteemi kõne

Exec-süsteemi kõnet kasutatakse aktiivses protsessis oleva faili käivitamiseks. Execi nimetamisel asendatakse eelmine käivitatav fail ja käivitatakse uus fail.

Täpsemalt öeldes võime öelda, et 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 teostab süsteemikõne exec (), asendatakse andmefailiga, mille nimi on toodud argumendis exec () helistamise ajal.

Uus programm laaditakse samasse protsessiruumi. Praegune protsess muudetakse lihtsalt uueks protsessiks ja seetõttu ei muudeta protsessi ID PID-d, selle põhjuseks on asjaolu, et me ei loo uut protsessi, vaid asendame protsessi teise protsessiga exec-is.

Kui parajasti käimasolev protsess sisaldab rohkem kui ühte lõime, siis kõik lõimed lõpetatakse ning uus protsessipilt laaditakse ja käivitatakse. Puuduvad hävitajafunktsioonid, mis lõpetaksid praeguse protsessi lõimed.

Protsessi PID-d ei muudeta, kuid andmed, kood, virn, hunnik jne. protsessi muudetakse ja asendatakse äsja laaditud protsessi omadega. Uus protsess viiakse läbi alates sisenemispunktist.

Execi süsteemikõne on funktsioonide kogum ja C-programmeerimiskeeles on nende funktsioonide standardnimed järgmised:

execl

täitma

execlp

execv

täitma

execvp

Siinkohal tuleb märkida, et neil funktsioonidel on sama alus exec millele järgneb üks või mitu tähte. Neid selgitatakse allpool:

e: See on osutite massiiv, mis osutab keskkonnamuutujatele ja edastatakse selgesõnaliselt äsja laaditud protsessile.

l: l on käsurea argumendid, mis edastasid funktsioonile loendi

p: p on keskkonnamuutuja tee, mis aitab leida protsessi laaditava argumendina edastatud faili.

v: v on käsurea argumentide jaoks. Need edastatakse funktsiooni osutite massiivina.

Miks kasutatakse execit?

exec-i kasutatakse juhul, kui kasutaja soovib samas protsessis käivitada uue faili või programmi.

Execi sisemine töö

Mõelge Execi toimimise mõistmiseks järgmistele punktidele:

Praegune protsessipilt kirjutatakse uue protsessipildiga üle.
Uus protsessipilt on see, mille andsite edasi exec-argumendina
Praegu käimasolev protsess on lõppenud
Uuel protsessipildil on sama protsessi ID, sama keskkond ja sama failikirjeldaja (kuna protsessi ei asendata, protsessupilt asendatakse)
Mõjutatud on protsessori stat ja virtuaalne mälu. Praeguse protsessipildi virtuaalse mälu kaardistamine asendatakse uue protsessipildi virtuaalse mäluga.

Execi perekonna funktsioonide süntaksid:

Execi iga funktsiooni süntaksid on järgmised:

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 protsessipilt on edukalt asendatud, ei tagastata helistamisfunktsioonile enam midagi, kuna seda kutsunud protsess ei tööta enam. Kuid vea korral tagastatakse -1. Kui ilmnes mõni viga, errno on seatud.

Süntaksis:

tee kasutatakse käivitatava faili täieliku tee nime määramiseks.

arg on vastuvõetud argument. See on tegelikult faili nimi, mis selle käigus käivitatakse. Enamasti on arg ja path väärtus sama.

const char * arg funktsioonides execl (), execlp () ja execle () on arg0, arg1, arg2,…, argn. Põhimõtteliselt on see tühiste lõpetatud stringide osutajate loend. Siin osutab esimene argument failinimele, mis käivitatakse punktis 2 kirjeldatud viisil.

envp on massiiv, mis sisaldab osutajaid, mis osutavad keskkonnamuutujatele.

faili Kasutatakse tee nime määramiseks, mis tuvastab uue protsessipildifaili tee.

Execi funktsioonid, mis lõpevad e kasutatakse uue protsessipildi keskkonna muutmiseks. Need funktsioonid edastavad argumendi abil keskkonna seadistamise loendi envp. See argument on märkide massiiv, mis osutab nulliga lõpetatud stringile ja määratleb keskkonnamuutuja.

Execi perekonna funktsioonide kasutamiseks peate oma C-programmi lisama järgmise päisefaili:

# kaasata

Näide 1: Exec-süsteemi kõne kasutamine C-programmis

Vaatleme järgmist näidet, milles oleme kasutanud exec-süsteemi kõnet Linuxi, Ubuntu C-programmeerimisel: meil on siin kaks näite c.c ja tere.c:

näide.c

KOOD:

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

printf ("näite PID.c =% d \ n ", getpid ());
char * args [] = "Tere", "C", "Programmeerimine", NULL;
execv ("./ tere ", väidab);
printf ("Tagasi näite juurde.c ");
tagastama 0;

Tere.c

KOOD:

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

printf ("Oleme Tere.c \ n ");
printf ("tere PID.c =% d \ n ", getpid ());
tagastama 0;

VÄLJUND:

Näite PID.c = 4733
Oleme tere.c
Tere PID.c = 4733

Ülaltoodud näites on meil näide.c fail ja tere.c fail. Näites .c fail on kõigepealt printinud praeguse protsessi ID (failinäide.c töötab praeguses protsessis). Seejärel oleme järgmisel real loonud rea tähemärkide massiivi. Selle massiivi viimane element peaks olema lõpppunktiks NULL.

Siis oleme kasutanud funktsiooni execv (), mis võtab argumendiks failinime ja tähemärkide massiivi. Siinkohal tuleb märkida, et oleme kasutanud ./ faili nimega määrab see faili tee. Kuna fail on kaustas, kus näide.c elab nii, et pole vaja määrata täielikku teed.

Kui kutsutakse funktsiooni execv (), asendatakse meie protsessipilt nüüd failinäide.c pole protsessis, kuid fail tere.c on protsessis. On näha, et protsessi ID on sama, kas tere.c on protsessipilt või näide.c on protsessipilt, kuna protsess on sama ja protsessupilt asendatakse ainult.

Siis on siin veel üks asi, mida märkida: printf () käsk pärast seda, kui execv () pole käivitatud. Seda seetõttu, et juhtimisprotsessi ei tagastata enam vanale protsessipildile, kui uus protsessipilt selle asemele tuleb. Juhtelement naaseb helistamisfunktsiooni juurde alles siis, kui protsessipildi asendamine ebaõnnestub. (Tagasiväärtus on sel juhul -1).

Kahvel () ja exec () süsteemikõnede erinevus:

Fork () süsteemikõnet kasutatakse jooksva protsessi täpse koopia loomiseks ja loodud koopia on alamprotsess ja käimasolev protsess on vanemprotsess. Seevastu süsteemipuhetust exec () kasutatakse protsessipildi asendamiseks uue protsessipildiga. Seega pole exec () süsteemikõnes vanemate ja laste protsesside mõistet.

Fork () süsteemikõnes käivitatakse vanema ja lapse protsessid korraga. Kuid kui exec () süsteemikõnes on protsessipildi asendamine õnnestunud, ei naase juhtelement sinna, kuhu kutsuti funktsioon exec, pigem täidab see uue protsessi. Juhtimine viiakse tagasi ainult vea korral.

Näide 2: süsteemi kahvli () ja exec () ühendamine

Vaatleme järgmist näidet, milles oleme ühes programmis kasutanud nii süsteemi fork () kui ka exec () kõnesid:

näide.c

KOOD:

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

printf ("näite PID.c =% d \ n ", getpid ());
pid_t p;
p = kahvel ();
kui (p == - 1)

printf ("kahvli () helistamisel ilmnes viga");

kui (p == 0)

printf ("Oleme lapseprotsessis \ n");
printf ("Helistamine tere.c lapse protsessist \ n ");
char * args [] = "Tere", "C", "Programmeerimine", NULL;
execv ("./ tere ", väidab);

muud

printf ("Oleme põhiprotsessis");

tagastama 0;

Tere.c:

KOOD:

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

printf ("Oleme Tere.c \ n ");
printf ("tere PID.c =% d \ n ", getpid ());
tagastama 0;

VÄLJUND:

Näite PID.c = 4790
Oleme parent protsessis
Oleme lapseprotsessis
Helistamine tere.c lapse protsessist
Oleme tere.c
Tere PID.c = 4791

Selles näites oleme kasutanud süsteemi fork () kõnet. Kui lapseprotsess on loodud, määratakse p-le 0 ja seejärel liigume lapseprotsessi juurde. Nüüd käivitatakse lausete plokk if (p == 0) abil. Kuvatakse teade ja oleme kasutanud execv () süsteemikõnet ja praegust lapseprotsessi pilti, mis on näide.c asendatakse tere.c. Enne execv () kõnet olid lapse ja vanema protsessid samad.

On näha, et näite PID.c ja tere.c on nüüd teistsugune. Selle põhjuseks on näide.c on vanemprotsessi pilt ja tere.c on lapse protsessi pilt.