Systémové volání exec se používá ke spuštění souboru, který je uložen v aktivním procesu. Když se zavolá exec, nahradí se předchozí spustitelný soubor a spustí se nový soubor.
Přesněji můžeme říci, že pomocí 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ž jméno je uvedeno v argumentu při volání exec ().
Nový program se načte do stejného procesního prostoru. Aktuální proces se právě změnil na nový proces, a proto se ID procesu PID nemění, 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, všechna vlákna budou ukončena a nový obraz procesu bude načten a poté spuštěn. Neexistují žádné funkce destruktoru, které by ukončovaly vlákna aktuálního procesu.
PID procesu se nezmě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 provede ze vstupního bodu.
Systémové volání Exec je soubor funkcí a v programovacím jazyce C jsou standardní názvy těchto funkcí následující:
- popravit
- popravit
- execlp
- vykon
- popravit
- execvp
Zde je třeba poznamenat, že tyto funkce mají stejný základ vykon následuje jedno nebo více písmen. Ty jsou vysvětleny níže:
A: Jedná se o řadu ukazatelů, které ukazují na proměnné prostředí a jsou předávány explicitně do nově načteného procesu.
: l je pro argumenty příkazového řádku předán seznam funkci
p: p je proměnná prostředí cesty, která pomáhá najít soubor předaný jako argument, který má být načten do procesu.
proti: v je pro argumenty příkazového řádku. Ty jsou předávány jako pole ukazatelů na funkci.
Proč se používá exec?
exec se používá, když chce uživatel ve stejném procesu spustit nový soubor nebo program.
Vnitřní práce exekutora
Abyste porozuměli fungování 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ý popisovač souboru (protože proces není nahrazen, obraz procesu je nahrazen)
- Ovlivněna je 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íže jsou uvedeny syntaxe pro každou funkci exec:
int execl (const char* cesta, const char* arg, ...)int execlp (soubor const char*, 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*, const char* argv [])
int execvpe (soubor const char*, const char* argv [], char* const envp [])
Popis:
Návratový typ těchto funkcí je Int. Když je obraz procesu úspěšně nahrazen, nic nebude vráceno volající funkci, protože proces, který jej zavolal, již není spuštěn. Pokud však dojde k chybě, bude vrácena hodnota -1. Pokud dojde k nějaké chybě an errno je nastaven.
V syntaxi:
- cesta se používá k zadání úplného názvu cesty k souboru, který má být spuštěn.
- rozzlobený je argument předán. Je to vlastně název souboru, který bude v procesu spuštěn. Většinou je hodnota arg a path stejná.
- const char* arg ve funkcích jsou execl (), execlp () a execle () považovány za arg0, arg1, arg2, ..., argn. Je to v podstatě seznam ukazatelů na řetězce s nulovou koncovkou. Zde první argument ukazuje na název souboru, který bude spuštěn, jak je popsáno v bodě 2.
- envp je pole, které obsahuje ukazatele, které ukazují na proměnné prostředí.
- soubor se používá k zadání názvu cesty, která bude identifikovat cestu k novému souboru bitové kopie procesu.
- Funkce volání exec, které končí A 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 ukončenou hodnotou null 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í:
#zahrnoutPří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 soubory c example.c a hello.c:
příklad. c
KÓD:
#zahrnout#zahrnout
#zahrnout
inthlavní(intargc, char *argv[])
{
printf ('PID příkladu. C = %d n',dostat se());
char *args[] = {'Ahoj', 'C', 'Programování',NULA};
vykon('./Ahoj',args);
printf ('Zpět na example.c');
vrátit se 0;
}
Ahoj C
KÓD:
#zahrnout#zahrnout
#zahrnout
inthlavní(intargc, char *argv[])
{
printf ('Jsme v Hello.c n');
printf ('PID ahoj.c = %d n',dostat se());
vrátit se 0;
}
VÝSTUP:
PID příkladu. C = 4733Jsme v Hello.c
PID ahoj.c = 4733
Ve výše uvedeném příkladu máme soubor example.c a hello.c. V ukázkovém souboru .c jsme nejprve vytiskli ID aktuálního procesu (v aktuálním procesu běží soubor example.c). Pak jsme v dalším řádku vytvořili řadu ukazatelů znaků. Poslední prvek tohoto pole by měl být NULL jako koncový bod.
Poté jsme použili funkci execv (), která jako argument bere název souboru a pole ukazatelů znaků. Zde je třeba poznamenat, že jsme použili ./ s názvem souboru, který určuje cestu k souboru. Jelikož je soubor ve složce, kde je umístěn example.c, není nutné zadávat úplnou cestu.
Když je volána funkce execv (), náš obraz procesu bude nyní nahrazen, příklad souboru.c není v procesu, ale soubor hello.c je v procesu. Je vidět, že ID procesu je stejné, ať už hello.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í execv (). Důvodem je, že se ovládací prvek nikdy nevrátí zpět na starý obraz procesu, jakmile jej nahradí nový obraz procesu. Ovládací prvek se vrátí k volání funkce pouze v případě, že nahrazení bitové kopie procesu není úspěšné. (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. Zatímco systémové volání exec () se používá k nahrazení bitové kopie procesu novou bitovou kopií procesu. Proto v systémovém volání exec () neexistuje koncept nadřazených a podřízených procesů.
Ve volání systému fork () se nadřazené a podřízené procesy provádějí současně. Ale v systémovém volání exec (), pokud je nahrazení bitové kopie procesu úspěšné, se ovládací prvek nevrátí tam, kde byla volána funkce exec, ale provede nový proces. Ovládací prvek bude přenesen zpět pouze v případě jakékoli chyby.
Příklad 2: Kombinace systémových volání fork () a exec ()
Zvažte následující příklad, ve kterém jsme použili systémová volání fork () i exec () ve stejném programu:
příklad. c
KÓD:
#zahrnout#zahrnout
#zahrnout
inthlavní(intargc, char *argv[])
{
printf ('PID příkladu. C = %d n',dostat se());
pid_t p;
p=Vidlička();
-li(p== -1)
{
printf ('Při volání fork () došlo k chybě');
}
-li(p==0)
{
printf ('Jsme v dětském procesu.' n');
printf ('Volání hello.c z podřízeného procesu.' n');
char *args[] = {'Ahoj', 'C', 'Programování',NULA};
vykon('./Ahoj',args);
}
jiný
{
printf („Jsme v rodičovském procesu“);
}
vrátit se 0;
}
Ahoj C:
KÓD:
#zahrnout#zahrnout
#zahrnout
inthlavní(intargc, char *argv[])
{
printf ('Jsme v Hello.c n');
printf ('PID ahoj.c = %d n',dostat se());
vrátit se 0;
}
VÝSTUP:
PID příkladu. C = 4790Jsme v rodičovském procesu
Jsme v dětském procesu
Volání hello.c z podřízeného procesu
Jsme v 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 příkazů s if (p == 0). Zobrazí se zpráva a použili jsme systémové volání execv () a aktuální podřízený obraz procesu, který je example.c bude nahrazen hello.c. Před spuštěním execv () byly podřízené a nadřazené procesy stejné.
Je vidět, že PID příkladů.c a hello.c se nyní liší. Důvodem je, že example.c je obraz nadřazeného procesu a hello.c je obraz podřízeného procesu.