Exec (Unix)

Această intrare pe tema limbajelor de programare este doar o schiță . Contribuiți la îmbunătățirea acestuia în conformitate cu convențiile Wikipedia .

Exec este o funcție de sistem găsită în biblioteca C standard a proiectului GNU, Biblioteca GNU C.

Informații generale

Exec înlocuiește codul și segmentele de date ale procesului care rulează în prezent în starea utilizatorului cu cele ale altui program conținut într-un fișier executabil specificat.

Acționând numai asupra proceselor aflate în starea de utilizator, executantul nu intervine asupra segmentului de sistem și asupra fișierelor utilizate de procesul care îl invocă.

În timpul apelului de executare și a încărcării ulterioare a noului cod compilat în RAM, procesul păstrează același pid .

Funcția exec trebuie să transmită parametrii noului program pe care îl execută. Acestea sunt citite de program prin mecanismul obișnuit de trecere argc, argv.

Implementare

Acest serviciu este implementat în C sub Unix (dar și în POSIX în general), printr-o familie de apeluri de sistem (incluse în unistd.h pe unix și process.h pe sistemele dos / win32.).

În principal găsim:

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[]);

Primul argument, calea pe care o vedem în fiecare dintre execut *, specifică calea și numele fișierului pentru a rula ca proces copil. Argumentele arg0, ..., argN sunt o listă de indicatori către argumentele care trebuie transmise procesului copil; argv este o serie de indicatori pentru argumente. Argumentul envp este în schimb o serie de indicatori pentru configurația curentă a mediului. Apelurile execle, execlpe, execve și execvpe (adică cele cu sufixul „e”) modifică mediul procesului lor copil, trecând o listă cu configurațiile mediului tocmai prin argumentul envp (matrice de indicatori de caractere).

Funcții și nume

Singurul apel real al sistemului este executarea, celelalte diferă de aceasta prin modul în care sunt trecuți parametrii.

În principiu, se poate spune că p final pe care îl găsim în cele două variante execlp și execvp, înseamnă că primul parametru trecut ca argument nu trebuie neapărat să fie calea, ci poate fi numele a ceea ce intenționăm să executăm.

Un exemplu ar putea fi următorul:

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

și complementarul său conținând p, dar nu calea:

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

Celelalte litere pe care le putem găsi pe lângă sufixul „p” (e, lov) au semnificații foarte specifice.

Pe scurt, avem următoarele funcții de bază:

Eroare de manipulare

În mod normal, funcțiile exec * nu revin la procesul de apelare, dacă o funcție exec revine la procesul de apelare înseamnă că apelul nu a avut succes. Valoarea de eroare -1 este apoi returnată și errno ne prezintă una dintre următoarele valori:

Specificațiile Execve și variantele sale:

execve

Sintaxă

int execve (const char * nume de cale, char * const argv [], char * const envp [])

• „nume de cale” este numele executabil (completat cu calea) pentru noul proces
• „argv []” este vectorul argumentelor introduse în calea de acces (accesibil de la main ca principal (int argc, char * argv [], char * env [])).
• „env []” este vectorul de mediu în care se execută pathmane (accesibil din main ca principal (int argc, char * argv [], char * env [])).
• Elementele env au forma "var = valoare".

Comportament

execve efectuează următoarele acțiuni

• căutați formatul căii
• lansați încărcătorul pentru formatul de cale
• creează o nouă hartă de memorie pentru proces
• aranjează în mod adecvat argumentele și mediul
• rearanjează structurile de date de gestionare a memoriei procesului
• încărcați o mică parte din executabil (cerere de paginare)
• transferă controlul către noul program

Procesul este apoi pus în modul utilizator: apelul - ca toți cei din familia exec - revine numai în caz de eroare.

Exemplu de utilizare

 / * fișier sursă execve.c * /

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

extern char ** environ;

int main () {
char * argv [] = {"nume de fișier", NULL};

if (execve ("nume de fișier", argv, mediu)) == - 1)

perror ("executare eșuată");

}

execl

exemplu

Să trecem mai departe pentru a vedea un exemplu de utilizare execl:

 int main () {

printf ("Executarea lui ls \ n");
execl ("/ bin / ls", "ls", "- l", (char *) 0);

printf ("A apărut o eroare la executarea codului \ n");
ieșire (1);
}

Observații : S-ar putea să ne întrebăm de ce după executl, există un printf care raportează o eroare și o ieșire care atrage atenția, dar trebuie să credeți că execl șterge programul original suprascriindu-l cu cel trecut ca parametru. Deci, instrucțiunile care urmează apelului la execl vor fi executate numai dacă nu au fost suprascrise de noul program, adică numai dacă a apărut o eroare în timpul execuției și controlul a fost transmis înapoi apelantului (execl).

execv

exemplu

Acum să vedem un exemplu de utilizare a execv:

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

printf ("A apărut o eroare la executarea codului \ n");
ieșire (1);
}

Observații : Ca și până acum, instrucțiunile care urmează apelului către executv vor fi executate numai dacă nu au fost suprascrise de noul program, adică numai dacă a apărut o eroare în timpul executării și controlul a fost transmis înapoi către apelant (execv ).

execlp

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

• Primul argument specifică calea programului (căutată în folderele căii variabilei de mediu)
• Argumentele ulterioare specifică o listă de șiruri terminate de șirul NULL care alcătuiesc argumentele transmise programului

Exemplu de utilizare:

 pentru (i = 1; i <= 2; i ++) {
       furculiță ();
       execlp ("echo", "myEcho", "i", (char *) 0);
       printf ("% d \ n", i); // cod care nu va fi executat niciodată, cu excepția cazului în care există erori în executlp
       }

Compilația va genera:

 the
the

execvp

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

Exemplu de utilizare:

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

printf ("A apărut o eroare la executarea codului \ n");
ieșire (1);
}

execle

Această secțiune pe informatică este încă goală. Ajută-ne să-l scriem!

linkuri externe

• Depozit sursă Exec , la openbsd.su .

Portal IT : accesați intrările Wikipedia care se ocupă cu IT