Linux Exec-systemanrop

Exec-systemanropet brukes til å utføre en fil som ligger i en aktiv prosess. Når exec kalles, erstattes den forrige kjørbare filen og den nye filen kjøres.

Mer presist kan vi si at bruk av exec systemanrop vil erstatte den gamle filen eller programmet fra prosessen med en ny fil eller et nytt program. Hele innholdet i prosessen erstattes med et nytt program.

Brukerdatasegmentet som utfører systemanropet exec () erstattes med datafilen hvis navn er oppgitt i argumentet mens du ringer til exec ().

Det nye programmet lastes inn i samme prosessrom. Den nåværende prosessen er nettopp omgjort til en ny prosess, og derfor blir ikke prosess-ID-en PID endret, dette er fordi vi ikke lager en ny prosess, vi erstatter bare en prosess med en annen.

Hvis den nåværende prosessen inneholder mer enn en tråd, vil alle trådene bli avsluttet, og det nye prosessbildet vil bli lastet inn og deretter utført. Det er ingen destruktorfunksjoner som avslutter trådene i den nåværende prosessen.

PID for prosessen endres ikke, men data, kode, stack, heap osv. av prosessen endres og erstattes med de for nylig lastet prosess. Den nye prosessen kjøres fra inngangspunktet.

Exec-systemanrop er en samling funksjoner, og i programmeringsspråk C er standardnavnene for disse funksjonene som følger:

execl

execle

execlp

execv

utføre

execvp

Det skal bemerkes her at disse funksjonene har samme base utføre etterfulgt av ett eller flere bokstaver. Disse er forklart nedenfor:

e: Det er en rekke pekere som peker på miljøvariabler og sendes eksplisitt til den nylig lastede prosessen.

l: Jeg er for kommandolinjeargumentene sendt en liste til funksjonen

p: p er banen miljøvariabel som hjelper til med å finne filen som er sendt som et argument som skal lastes inn i prosessen.

v: v er for kommandolinjeargumentene. Disse sendes som en rekke pekere til funksjonen.

Hvorfor exec brukes?

exec brukes når brukeren vil starte en ny fil eller et nytt program i samme prosess.

Indre arbeid av eks

Tenk på følgende punkter for å forstå hvordan exec fungerer:

Gjeldende prosessbilde overskrives med et nytt prosessbilde.
Nytt prosessbilde er det du sendte som exec-argument
Den nåværende prosessen er avsluttet
Nytt prosessbilde har samme prosess-ID, samme miljø og samme filbeskrivelse (fordi prosessen ikke erstattes, erstattes prosessbildet)
CPU-stat og virtuelt minne påvirkes. Kartlegging av virtuelt minne av gjeldende prosessbilde erstattes av virtuelt minne av nytt prosessbilde.

Syntakser for familiefunksjoner:

Følgende er syntaksen for hver funksjon av exec:

int execl (const char * path, const char * arg,…)
int execlp (const char * file, 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 * file, const char * argv [])
int execvpe (const char * file, const char * argv [], char * const envp [])

Beskrivelse:

Returtypen til disse funksjonene er Int. Når prosessbildet er erstattet, returneres ingenting til anropsfunksjonen fordi prosessen som kalte det ikke lenger kjører. Men hvis det er noen feil -1 vil bli returnert. Hvis det oppstår en feil, errno er satt.

I syntaksen:

sti brukes til å spesifisere hele stienavnet på filen som skal kjøres.

arg er argumentet bestått. Det er faktisk navnet på filen som vil bli utført i prosessen. De fleste ganger er verdien av arg og sti den samme.

con char * arg i funksjoner regnes execl (), execlp () og execle () som arg0, arg1, arg2,…, argn. Det er i utgangspunktet en liste over pekere til null avsluttede strenger. Her peker det første argumentet på filnavnet som vil bli utført som beskrevet i punkt 2.

envp er en matrise som inneholder pekere som peker på miljøvariablene.

fil brukes til å spesifisere banenavnet som vil identifisere banen til den nye prosessbildefilen.

Funksjonene til exec call som slutter med e brukes til å endre miljøet for det nye prosessbildet. Disse funksjonene overfører listen over miljøinnstillinger ved hjelp av argumentet envp. Dette argumentet er en rekke tegn som peker på null avsluttet streng og definerer miljøvariabel.

For å bruke exec-familiefunksjonene, må du ta med følgende topptekstfil i C-programmet:

#inkludere

Eksempel 1: Bruke exec systemanrop i C-program

Tenk på følgende eksempel der vi har brukt exec system call i C programmering i Linux, Ubuntu: Vi har to c filer her eksempel.c og hei.c:

eksempel.c

KODE:

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

printf ("PID for eksempel.c =% d \ n ", getpid ());
char * args [] = "Hei", "C", "Programmering", NULL;
execv ("./ hallo ", args);
printf ("Tilbake til eksempel.c ");
retur 0;

Hallo.c

KODE:

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

printf ("Vi er i Hello.c \ n ");
printf ("PID av hei.c =% d \ n ", getpid ());
retur 0;

PRODUKSJON:

PID for eksempel.c = 4733
Vi er i Hello.c
PID av hei.c = 4733

I eksemplet ovenfor har vi et eksempel.c-fil og hei.c-fil. I eksemplet .c-fil først og fremst har vi skrevet ut ID-en for den nåværende prosessen (fileksempel.c kjører i gjeldende prosess). Så i neste linje har vi opprettet en rekke tegnpekere. Det siste elementet i denne matrisen skal være NULL som avslutningspunkt.

Så har vi brukt funksjonen execv () som tar filnavnet og tegnpekerarrayen som argument. Det skal bemerkes her at vi har brukt ./ med filnavnet, spesifiserer den banen til filen. Siden filen er i mappen der eksempel.c bor så det er ikke nødvendig å spesifisere hele banen.

Når funksjonen execv () kalles, vil prosessbildet vårt erstattes nå fileksemplet.c er ikke i prosessen, men filen hei.c er i prosessen. Det kan sees at prosess-ID er den samme om hei.c er prosessbilde eller eksempel.c er prosessbilde fordi prosessen er den samme og prosessbildet bare erstattes.

Så har vi en annen ting å merke oss her som er printf () -uttalelsen etter at execv () ikke er utført. Dette er fordi kontrollen aldri returneres til det gamle prosessbildet når nytt prosessbilde erstatter det. Kontrollen kommer bare tilbake til anropsfunksjon når utskifting av prosessbilde ikke lykkes. (Returverdien er -1 i dette tilfellet).

Forskjellen mellom fork () og exec () systemanrop:

Gaffel () systemanrop brukes til å lage en eksakt kopi av en kjørende prosess, og den opprettede kopien er underordnet prosess og kjører prosessen er den overordnede prosessen. Mens exec () systemanrop brukes til å erstatte et prosessbilde med et nytt prosessbilde. Derfor er det ikke noe begrep om foreldre- og barneprosesser i exec () systemanrop.

In fork () systemanrop utføres foreldre- og barneprosesser samtidig. Men i exec () systemanrop, hvis erstatningen av prosessbildet er vellykket, kommer ikke kontrollen tilbake til der exec-funksjonen ble kalt, men den vil utføre den nye prosessen. Kontrollen overføres bare hvis det er noen feil.

Eksempel 2: Kombinere systemanrop for gaffel () og exec ()

Tenk på følgende eksempel der vi har brukt både fork () og exec () systemanrop i samme program:

eksempel.c

KODE:

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

printf ("PID for eksempel.c =% d \ n ", getpid ());
pid_t p;
p = gaffel ();
hvis (p == - 1)

printf ("Det er en feil mens du ringer til fork ()");

hvis (p == 0)

printf ("Vi er i barneprosessen \ n");
printf ("Ringer hei.c fra barneprosess \ n ");
char * args [] = "Hei", "C", "Programmering", NULL;
execv ("./ hallo ", args);

ellers

printf ("Vi er i foreldreprosessen");

retur 0;

Hallo.c:

KODE:

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

printf ("Vi er i Hello.c \ n ");
printf ("PID av hei.c =% d \ n ", getpid ());
retur 0;

PRODUKSJON:

PID for eksempel.c = 4790
Vi er i foreldreprosessen
Vi er i barneprosess
Ringer hei.c fra barneprosessen
Vi er i hei.c
PID av hei.c = 4791

I dette eksemplet har vi brukt fork () systemanrop. Når barneprosessen er opprettet, tildeles 0 til p, og deretter går vi til barneprosessen. Nå vil blokken av utsagn med if (p == 0) bli utført. En melding vises, og vi har brukt execv () systemanrop og det nåværende underordnede prosessbildet som eksempel.c erstattes med hei.c. Før execv () var barne- og foreldreprosesser de samme.

Det kan sees at PID for eksempel.c og hei.c er annerledes nå. Dette er fordi eksempel.c er det overordnede prosessbildet og hei.c er barnets prosessbilde.