Chiamata di sistema Linux Exec

La chiamata di sistema exec viene utilizzata per eseguire un file che risiede in un processo attivo. Quando viene chiamato exec, il file eseguibile precedente viene sostituito e il nuovo file viene eseguito.

Più precisamente, possiamo dire che l'uso della chiamata di sistema exec sostituirà il vecchio file o programma dal processo con un nuovo file o programma. L'intero contenuto del processo viene sostituito con un nuovo programma.

Il segmento di dati utente che esegue la chiamata di sistema exec() viene sostituito con il file di dati il cui nome è fornito nell'argomento durante la chiamata di exec().

Il nuovo programma viene caricato nello stesso spazio di processo. Il processo corrente è appena stato trasformato in un nuovo processo e quindi l'ID processo PID non viene modificato, questo perché non stiamo creando un nuovo processo, stiamo solo sostituendo un processo con un altro processo in exec.

Se il processo attualmente in esecuzione contiene piùdi un thread allora tutti i thread verranno terminati e la nuova immagine del processo verrà caricata e quindi eseguita. Non ci sono funzioni di distruzione che terminano i thread del processo corrente.

Il PID del processo non viene modificato ma i dati, il codice, lo stack, l'heap, ecc. del processo vengono modificati e vengono sostituiti con quelli del processo appena caricato. Il nuovo processo viene eseguito dal punto di ingresso.

La chiamata di sistema Exec è una raccolta di funzioni e nel linguaggio di programmazione C, i nomi standard per queste funzioni sono i seguenti:

eccellente

execle

execlp

execv

esecutivo

execvp

Va notato qui che queste funzioni hanno la stessa base eseguire seguito da una o più lettere. Questi sono spiegati di seguito:

e: È un array di puntatori che punta a variabili d'ambiente e viene passato esplicitamente al processo appena caricato.

io: l è per gli argomenti della riga di comando passati un elenco alla funzione

p: p è la variabile d'ambiente del percorso che aiuta a trovare il file passato come argomento da caricare nel processo.

v: v è per gli argomenti della riga di comando. Questi vengono passati come un array di puntatori alla funzione.

Perché si usa exec??

exec viene utilizzato quando l'utente desidera avviare un nuovo file o programma nello stesso processo.

Lavoro interno dell'exec

Considera i seguenti punti per comprendere il funzionamento di exec:

L'immagine di processo attuale viene sovrascritta con una nuova immagine di processo.
La nuova immagine del processo è quella passata come argomento exec
Il processo attualmente in esecuzione è terminato
La nuova immagine di processo ha lo stesso ID di processo, lo stesso ambiente e lo stesso descrittore di file (perché il processo non viene sostituito, l'immagine di processo viene sostituita)
Le statistiche della CPU e la memoria virtuale sono interessate. La mappatura della memoria virtuale dell'immagine di processo corrente viene sostituita dalla memoria virtuale della nuova immagine di processo.

Sintassi delle funzioni familiari exec:

Di seguito sono riportate le sintassi per ciascuna funzione di exec:

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

Descrizione:

Il tipo restituito da queste funzioni è Int. Quando l'immagine del processo viene sostituita correttamente, non viene restituito nulla alla funzione chiamante perché il processo che l'ha chiamata non è più in esecuzione. Ma se c'è qualche errore -1 verrà restituito. Se si verifica un errore e errno è impostato.

Nella sintassi:

sentiero è usato per specificare il nome completo del percorso del file che deve essere eseguito.

argomento l'argomento è passato?. In realtà è il nome del file che verrà eseguito nel processo. La maggior parte delle volte il valore di arg e path è lo stesso.

const char* arg nelle funzioni execl(), execlp() ed execle() è considerato come arg0, arg1, arg2,… , argn. È fondamentalmente un elenco di puntatori a stringhe terminate da null. Qui il primo argomento punta al nome del file che verrà eseguito come descritto al punto 2.

ambiente è un array che contiene puntatori che puntano alle variabili d'ambiente.

file viene utilizzato per specificare il nome del percorso che identificherà il percorso del nuovo file di immagine del processo.

Le funzioni di exec chiamano che terminano con e vengono utilizzati per modificare l'ambiente per la nuova immagine di processo. Queste funzioni passano l'elenco delle impostazioni dell'ambiente utilizzando l'argomento ambiente. Questo argomento è un array di caratteri che punta a una stringa con terminazione null e definisce la variabile di ambiente.

Per utilizzare le funzioni della famiglia exec, è necessario includere il seguente file di intestazione nel programma C:

#includere

Esempio 1: utilizzo della chiamata di sistema exec nel programma C

Considera il seguente esempio in cui abbiamo usato la chiamata di sistema exec nella programmazione C in Linux, Ubuntu: Abbiamo due file c qui esempio.c e ciao.c:

esempio.c

CODICE:

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

printf("PID di esempio.c = %d\n", getpid());
char *args[] = "Ciao", "C", "Programmazione", NULL;
execv("./ciao", argomenti);
printf("Torna all'esempio.c");
restituisce 0;

Ciao.c

CODICE:

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

printf("Siamo in Hello.c\n");
printf("PID di ciao.c = %d\n", getpid());
restituisce 0;

PRODUZIONE:

PID di esempio.c = 4733
Siamo in Hello.c
PID di ciao.c = 4733

Nell'esempio sopra abbiamo un esempio.file c e ciao.c file. Nell'esempio .c prima di tutto abbiamo stampato l'ID del processo corrente (file esempio.c è in esecuzione nel processo corrente). Quindi nella riga successiva abbiamo creato un array di puntatori a caratteri. L'ultimo elemento di questo array dovrebbe essere NULL come punto di terminazione.

Quindi abbiamo usato la funzione execv() che prende il nome del file e l'array di puntatori di caratteri come argomento. Va notato qui che abbiamo usato ./ con il nome del file, specifica il percorso del file. Poiché il file si trova nella cartella in cui esempio.c risiede quindi non è necessario specificare il percorso completo.

Quando viene chiamata la funzione execv(), la nostra immagine di processo verrà sostituita ora dal file example.c non è nel processo ma il file ciao.c è in lavorazione. Si può vedere che l'ID del processo è lo stesso se ciao.c è un'immagine di processo o un esempio.c è l'immagine del processo perché il processo è lo stesso e l'immagine del processo viene solo sostituita.

Quindi abbiamo un'altra cosa da notare qui che è l'istruzione printf() dopo che execv() non viene eseguito. Questo perché il controllo non viene mai restituito alla vecchia immagine di processo una volta che la nuova immagine di processo la sostituisce. Il controllo torna alla funzione di richiamo solo quando la sostituzione dell'immagine di processo non è riuscita. (Il valore restituito è -1 in questo caso).

Differenza tra le chiamate di sistema fork() ed exec():

La chiamata di sistema fork() viene utilizzata per creare una copia esatta di un processo in esecuzione e la copia creataèil processo figlio e il processo in esecuzione è il processo padre. Considerando che, la chiamata di sistema exec() viene utilizzata per sostituire un'immagine di processo con una nuova immagine di processo. Quindi non esiste il concetto di processi padre e figlio nella chiamata di sistema exec().

Nella chiamata di sistema fork() i processi padre e figlio vengono eseguiti contemporaneamente. Ma nella chiamata di sistema exec(), se la sostituzione dell'immagine del processo ha esito positivo, il controllo non ritorna nel punto in cui è stata chiamata la funzione exec, ma eseguirà il nuovo processo. Il controllo verrà ritrasferito solo in caso di errore.

Esempio 2: combinazione di chiamate di sistema fork() ed exec()

Considera il seguente esempio in cui abbiamo usato sia le chiamate di sistema fork() che exec() nello stesso programma:

esempio.c

CODICE:

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

printf("PID di esempio.c = %d\n", getpid());
pid_t p;
p = fork();
se(p==-1)

printf("Si è verificato un errore durante la chiamata a fork()");

se(p==0)

printf("Siamo nel processo figlio\n");
printf("Ti chiamo ciao.c dal processo figlio\n");
char *args[] = "Ciao", "C", "Programmazione", NULL;
execv("./ciao", argomenti);

altro

printf("Siamo nel processo padre");

restituisce 0;

Ciao.c:

CODICE:

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

printf("Siamo in Hello.c\n");
printf("PID di ciao.c = %d\n", getpid());
restituisce 0;

PRODUZIONE:

PID di esempio.c = 4790
Siamo in Processo Genitori
Siamo nel processo del bambino
chiamando ciao.c dal processo figlio
Siamo in ciao.c
PID di ciao.c = 4791

In questo esempio abbiamo usato la chiamata di sistema fork(). Quando il processo figlio viene creato, 0 verrà assegnato a p e poi ci sposteremo al processo figlio. Ora verrà eseguito il blocco di istruzioni con if(p==0). Viene visualizzato un messaggio e abbiamo usato la chiamata di sistema execv() e l'immagine del processo figlio corrente che è un esempio.c verrà sostituito con ciao.c. Prima che execv() chiamasse i processi figlio e genitore erano gli stessi.

Si può notare che il PID di esempio.c e ciao.c è diverso ora. Questo perché esempio.c è l'immagine del processo genitore e ciao.c è l'immagine del processo figlio.