Exec (Unix)

De la Viquipèdia, l'enciclopèdia lliure.
Saltar a la navegació Saltar a la cerca

Exec és una funció del sistema que es troba a la biblioteca C estàndard del projecte GNU , la Biblioteca GNU C.

Informació general

Exec substitueix el codi i els segments de dades del procés que s’executa actualment a l’estat de l’usuari pels d’un altre programa contingut en un fitxer executable especificat.

Actuant només en els processos en estat d’usuari, l’executiu no intervé sobre el segment del sistema ni sobre els fitxers utilitzats pel procés que l’invoca.

Durant la trucada a executar i la posterior càrrega del nou codi compilat a la memòria RAM, el procés manté el mateix pid .

La funció exec ha de passar paràmetres al nou programa que executa. El programa els llegeix mitjançant el mecanisme de pas habitual argc, argv.

Implementació

Aquest servei s’implementa en C sota Unix (però també en POSIX en general), mitjançant una família de trucades al sistema (incloses a unistd.h a unix i process.h als sistemes dos / win32.).

Principalment trobem:

int execl(const char *pathname, const char *arg, ..., (char *) NULL);
int execle(const char *pathname, const char *arg, ..., (char *) NULL, char *const envp[]);
int execlp(const char *file, const char *arg, ..., (char *) NULL);
int execlpe(const char *path, const char *arg0, ..., const char *const *envp); //Solo process.h ??
int execv(const char *pathname, char *const argv[]);
int execve(const char *pathname, char *const argv[], char *const envp[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[], char *const envp[]);

El primer argument, ruta que veiem a cadascun dels fitxers exec *, especifica el camí i el nom del fitxer que s’executarà com a procés secundari. Els arguments arg0, ..., argN són una llista d’indicadors dels arguments per passar al procés fill; argv és un conjunt d’indicadors d’arguments. En canvi, l'argument envp és una matriu de punteres a la configuració d'entorn actual. Les trucades execle, execlpe, execve i execvpe (és a dir, aquelles amb el sufix 'e'), modifiquen l'entorn del procés fill, passant una llista amb les configuracions de l'entorn precisament a través de l'argument envp (matriu de punteres de caràcters).

Funcions i noms

L'única trucada real del sistema és l'execve, les altres es diferencien d'aquesta manera de passar els paràmetres.

En principi es pot dir que la p final que trobem a les dues variants execlp i execvp, significa que el primer paràmetre passat com a argument no ha de ser necessàriament el camí d'accés, sinó que pot ser el nom del que pretenem executar.

Un exemple podria ser el següent:

 execl ("/ bin / ls", "ls", "-l", (char *) 0);

i el seu complementari que conté la p però no el camí:

 execlp ("ls", "ls", "-l", (char *) 0);

Les altres lletres que podem trobar a més del sufix "p" (e, lov) tenen significats molt específics.

En resum, tenim les funcions bàsiques següents:

Funció Característic
p No cal que especifiqueu el camí.
v Els arguments de la línia d’ordres es passaran a la funció mitjançant una matriu de punteres.
e El conjunt de punteres d’entorn es passen explícitament al procés fill.
l Els arguments de la línia d'ordres es passen individualment a la funció.

Gestió d'errors

Normalment, les funcions exec * no tornen al procés de trucada, si una funció exec torna al procés de trucada significa que la trucada no ha tingut èxit. A continuació, es retorna el valor d'error -1 i errno ens presenta un dels valors següents:

Error Significat
E2BIG S'han introduït massa arguments.
EACCES No podeu tenir accés al fitxer especificat (problemes de bloqueig / privilegis).
ENOENT El fitxer o camí d'accés especificat no existeix.
ENOMEM No hi ha prou memòria per executar el procés fill

Especificacions d'Execve i les seves variants:

executar

Sintaxi

int execve (const char * nom de ruta, char * const argv [], char * const envp [])

  • "nom de ruta" és el nom executable (completat amb el camí d'accés) per al nou procés
  • "argv []" és el vector d'arguments introduïts al nom de ruta (accessible des de main com main (int argc, char * argv [], char * env [])).
  • "env []" és el vector d'entorn en què s'executa pathmane (accessible des de main com main (int argc, char * argv [], char * env [])).
  • Els elements d'env tenen la forma "var = valor".

Comportament

execve realitza les accions següents

  • cerqueu el format de la ruta
  • llançar el carregador per al format de ruta
  • crea un nou mapa de memòria per al procés
  • organitza adequadament arguments i entorn
  • reordena les estructures de dades de gestió de memòria del procés
  • carregar una petita part de l'executable (demanda de paginació)
  • transfereix el control al nou programa

El procés es posa en mode d’usuari: la trucada, com totes les de la família exec, només torna en cas d’error.

Exemple d'ús

 / * fitxer font execve.c * /

#include <stdio.h>
#include <unistd.h>

extern char ** environ;

int main () {
char * argv [] = {"nom del fitxer", NULL};

if (execve ("nom de fitxer", argv, entorn)) == - 1)

perror ("execve ha fallat");

}

execl

exemple

Passem a veure un exemple d'ús de execl:

 int main () {

printf ("Execució de ls \ n");
execl ("/ bin / ls", "ls", "- l", (char *) 0);

printf ("S'ha produït un error en executar el codi \ n");
sortida (1);
}

Observacions : Us podríeu preguntar per què després de execl, hi ha un printf que informa d'un error i una sortida que crida l'atenció, però heu de pensar que execl elimina el programa original sobreescrivint-lo amb el que s'ha passat com a paràmetre. Per tant, les instruccions que segueixen la crida a execl només s’executaran si el nou programa no les ha sobreescrit, és a dir, només si s’ha produït un error durant l’execució i el control s’ha tornat a la persona que truca (execl).

execv

exemple

Vegem ara un exemple d'ús de execv:

 int main () {
char * a [] = {"ls", "- l", (char *) 0};
printf ("Execució de ls \ n");
execv ("/ home / ls", a);

printf ("S'ha produït un error en executar el codi \ n");
sortida (1);
}

Observacions : com abans, les instruccions posteriors a la trucada a execv només s’executaran si el nou programa no les ha sobreescrit, és a dir, només si s’ha produït un error durant l’execució i el control s’ha tornat a la persona que truca (execv ).

execlp

Prototip: int execlp(const char *file, const char *arg, ..., (char *) NULL);

  • El primer argument especifica el camí del programa (cercat a les carpetes del camí variable de l'entorn)
  • Els arguments posteriors especifiquen una llista de cadenes acabades per la cadena NULL que componen els arguments que es transmeten al programa

Exemple d'ús:

 per a (i = 1; i <= 2; i ++) {
       forquilla ();
       execlp ("eco", "myEcho", "i", (char *) 0);
       printf ("% d \ n", i); // codi que no s'executarà mai, tret que hi hagi errors a l'execlp
       }

La compilació produirà:

 el
el

execvp

Prototip: int execvp(const char *file, char *const argv[]);

Exemple d'ús:

 int main () {
char * a [] = {"ls", "- l", (char *) 0};
printf ("Execució de ls \ n");
execvp ("ls", a);

printf ("S'ha produït un error en executar el codi \ n");
sortida (1);
}

execle

Enllaços externs

Informàtica Portal de TI : accediu a les entrades de Viquipèdia relacionades amb TI