Systémové volání Linux Exec

Systémové volání exec se používá k provedení souboru, který se nachází v aktivním procesu. Když se volá exec, nahradí se předchozí spustitelný soubor a provede se nový soubor.

Přesněji řečeno, můžeme říci, že použití systémového volání exec nahradí starý soubor nebo program z procesu novým souborem nebo programem. Celý obsah procesu je nahrazen novým programem.

Segment uživatelských dat, který provádí systémové volání exec (), je nahrazen datovým souborem, jehož název je uveden v argumentu při volání exec ().

Nový program je načten do stejného prostoru procesu. Aktuální proces se právě změnil na nový proces, a proto se ID procesu PID nezmění, je to proto, že nevytváříme nový proces, pouze nahrazujeme proces jiným procesem v exec.

Pokud aktuálně spuštěný proces obsahuje více než jedno vlákno, budou všechna vlákna ukončena a nový obraz procesu bude načten a poté spuštěn. Neexistují žádné funkce destruktoru, které ukončují vlákna aktuálního procesu.

PID procesu se nemění, ale data, kód, zásobník, halda atd. procesu se změní a nahradí se nově načteným procesem. Nový proces se provádí ze vstupního bodu.

Systémové volání Exec je kolekce funkcí a v programovacím jazyce C jsou standardní názvy těchto funkcí následující:

kromě

vykonat

execlp

vykon

vykonat

execvp

Zde je třeba poznamenat, že tyto funkce mají stejnou základnu vykon následované jedním nebo více písmeny. Níže jsou vysvětleny:

E: Jedná se o pole ukazatelů, které ukazují na proměnné prostředí a jsou předávány explicitně nově načtenému procesu.

já: l je pro argumenty příkazového řádku předán seznamu funkci

p: p je proměnná prostředí cesty, která pomáhá najít soubor předaný jako argument, který se má načíst do procesu.

proti: v je pro argumenty příkazového řádku. Ty jsou předávány jako pole ukazatelů funkci.

Proč se používá exec?

exec se používá, když chce uživatel spustit nový soubor nebo program ve stejném procesu.

Vnitřní práce vykon

Chcete-li pochopit fungování příkazu exec, zvažte následující body:

Aktuální obraz procesu je přepsán novým obrazem procesu.
Nový obraz procesu je ten, který jste předali jako argument exec
Aktuálně spuštěný proces je ukončen
Nový obraz procesu má stejné ID procesu, stejné prostředí a stejný deskriptor souboru (protože proces není nahrazen, je nahrazen obraz procesu)
Je ovlivněna statistika CPU a virtuální paměť. Mapování virtuální paměti aktuálního obrazu procesu je nahrazeno virtuální pamětí nového obrazu procesu.

Syntaxe funkcí rodiny exec:

Následují syntaxe pro každou funkci exec:

int execl (const char * cesta, const char * arg,…)
int execlp (soubor const char *, soubor const char * arg,…)
int execle (const char * cesta, const char * arg,…, char * const envp [])
int execv (const char * cesta, const char * argv [])
int execvp (soubor const char *, soubor const char * argv [])
int execvpe (const char * soubor, const char * argv [], char * const envp [])

Popis:

Návratový typ těchto funkcí je Int. Když je obraz procesu úspěšně nahrazen, nic se nevrátí do volající funkce, protože proces, který jej volal, již není spuštěn. Pokud ale dojde k nějaké chybě, bude vrácena -1. Pokud dojde k nějaké chybě, errno je nastaven.

V syntaxi:

cesta se používá k určení úplného názvu cesty k souboru, který má být spuštěn.

arg je předaný argument. Je to vlastně název souboru, který bude v procesu spuštěn. Většinou je hodnota arg a cesty stejná.

const char * arg ve funkcích execl (), execlp () a execle () je považován za arg0, arg1, arg2,…, argn. Je to v podstatě seznam ukazatelů na řetězce s nulovým zakončením. Zde první argument ukazuje na název souboru, který bude proveden podle popisu v bodě 2.

envp je pole, které obsahuje ukazatele, které odkazují na proměnné prostředí.

soubor se používá k určení názvu cesty, která bude identifikovat cestu nového obrazového souboru procesu.

Funkce exec volání, které končí E se používají ke změně prostředí pro nový obraz procesu. Tyto funkce předávají seznam nastavení prostředí pomocí argumentu envp. Tento argument je pole znaků, které ukazuje na řetězec s nulovým zakončením a definuje proměnnou prostředí.

Chcete-li používat funkce rodiny exec, musíte do svého programu C zahrnout následující soubor záhlaví:

#zahrnout

Příklad 1: Použití systémového volání exec v programu C

Zvažte následující příklad, ve kterém jsme použili systémové volání exec v programování C v Linuxu, Ubuntu: Máme zde dva c soubory příklad.ca ahoj.C:

příklad.C

KÓD:

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

printf ("PID příkladu.c =% d \ n ", getpid ());
char * args [] = "Hello", "C", "Programming", NULL;
execv ("./ ahoj ", args);
printf ("Zpět na příklad.C");
návrat 0;

Ahoj.C

KÓD:

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

printf ("Jsme v Hello.c \ n ");
printf ("PID ahoj.c =% d \ n ", getpid ());
návrat 0;

VÝSTUP:

PID příkladu.c = 4733
Jsme v Hello.C
PID ahoj.c = 4733

Ve výše uvedeném příkladu máme příklad.c soubor a ahoj.soubor c. V příkladu .Soubor c Nejdříve jsme vytiskli ID aktuálního procesu (příklad souboru.c běží v aktuálním procesu). Pak jsme v dalším řádku vytvořili řadu ukazatelů znaků. Poslední prvek tohoto pole by měl být NULL jako koncový bod.

Pak jsme použili funkci execv (), která jako argument přebírá název souboru a pole ukazatelů znaků. Zde je třeba poznamenat, že jsme použili ./ s názvem souboru určuje cestu k souboru. Protože soubor je ve složce, kde je příklad.c bydlí, takže není nutné specifikovat úplnou cestu.

Když je volána funkce execv (), náš obraz procesu bude nyní nahrazen příkladem souboru.c není v procesu, ale soubor ahoj.c je v procesu. Je vidět, že ID procesu je stejné, ať už ahoj.c je obraz procesu nebo příklad.c je obraz procesu, protože proces je stejný a obraz procesu je pouze nahrazen.

Pak zde musíme poznamenat další věc, kterou je příkaz printf () po provedení příkazu execv (). Důvodem je, že kontrola se nikdy nevrátí zpět na starý obraz procesu, jakmile jej nový obraz procesu nahradí. Ovládací prvek se vrátí zpět k volací funkci pouze v případě neúspěšného nahrazení obrazu procesu. (Návratová hodnota je v tomto případě -1).

Rozdíl mezi systémovými voláními fork () a exec ():

Systémové volání fork () se používá k vytvoření přesné kopie běžícího procesu a vytvořená kopie je podřízený proces a spuštěný proces je nadřazený proces. Vzhledem k tomu, že se systémové volání exec () používá k nahrazení obrazu procesu novým obrazem procesu. Proto v systémovém volání exec () neexistuje koncept nadřazených a podřízených procesů.

V systémovém volání fork () jsou nadřazené a podřízené procesy prováděny současně. Ale v systémovém volání exec (), pokud je nahrazení obrazu procesu úspěšné, se ovládací prvek nevrátí tam, kde byla volána funkce exec, spíše provede nový proces. Ovládací prvek bude přenesen zpět pouze v případě, že dojde k chybě.

Příklad 2: Kombinace systémových volání fork () a exec ()

Zvažte následující příklad, ve kterém jsme ve stejném programu použili jak systémová volání fork (), tak exec ():

příklad.C

KÓD:

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

printf ("PID příkladu.c =% d \ n ", getpid ());
pid_t p;
p = vidlice ();
pokud (p == - 1)

printf ("Při volání fork () došlo k chybě");

pokud (p == 0)

printf ("Jsme v podřízeném procesu \ n");
printf ("Volání ahoj.c z podřízeného procesu \ n ");
char * args [] = "Hello", "C", "Programming", NULL;
execv ("./ ahoj ", args);

jiný

printf ("Jsme v nadřazeném procesu");

návrat 0;

Ahoj.C:

KÓD:

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

printf ("Jsme v Hello.c \ n ");
printf ("PID ahoj.c =% d \ n ", getpid ());
návrat 0;

VÝSTUP:

PID příkladu.c = 4790
Jsme v rodičovském procesu
Jsme v dětském procesu
Volám ahoj.c z podřízeného procesu
Jsme ahoj.C
PID ahoj.c = 4791

V tomto příkladu jsme použili systémové volání fork (). Když je vytvořen podřízený proces, 0 bude přiřazeno p a poté se přesuneme do podřízeného procesu. Nyní bude proveden blok výpisů s if (p == 0). Zobrazí se zpráva a použili jsme systémové volání execv () a aktuální podřízený obraz procesu, což je příklad.c bude nahrazeno ahoj.C. Před spuštěním příkazu execv () byly podřízené a nadřazené procesy stejné.

Je vidět, že PID příkladu.ca ahoj.c je teď jiné. Je to proto, že příklad.c je nadřazený obraz procesu a ahoj.c je podřízený obraz procesu.