L'Appel système fork() et la fonction execv

Je suis en train de lancer deux exécutables consécutivement à l'aide de ce code c:

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

int main (int argc, char *argv[])
{
    fork();
    execv("./prcs1", &argv[1]); //GIVE ADDRESS OF 2nd element as starting point to skip source.txt
    fork();
    execv("./prcs2", argv);
    printf("EXECV Failed\n");
}

Le programme s'arrête après la première execv() appel en dépit de la fourche, il n'arrive jamais à la deuxième execv(). J'ai essayé d'appeler wait() après la première fourche, mais je ne suis pas sûr que ce qu'il manque.

Des idées pourquoi le contrôle n'est pas de retour à la mère après que l'enfant quitte?

Ahh, l'ancien "fork et exec" l'idiome... malheureusement, il n'est pas tout à fait aussi littérale que vous l'avez.
Voulez-vous votre processus principal de bloquer et d'attendre que c'est l'exécution du processus fils?

OriginalL'auteur Mike | 2013-10-02

c linux system-calls unix

16

Vous avez un couple de problèmes. Tout d'abord, si vous ne voulez exécuter deux programmes, vous ne devez appeler fork() une fois. Puis exécuter un programme dans le processus parent et celui de l'enfant. Deuxièmement, vous êtes la construction de la argv tableau pour être passé à execv de manière incorrecte. La première entrée doit être le nom de l'exécutable. Faire quelque chose comme:
```
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>

int main(int argc, char **argv)
{
    pid_t i = fork();
    if (i == 0)
    {
        execv("./prcs1", (char *[]){ "./prcs1", argv[1], NULL });
        _exit(1);
    }
    else if (i > 0)
    {
        execv("./prcs2", (char *[]){ "./prcs2", argv[0], NULL });
        _exit(2);
    }
    else
    {
        perror("fork failed");
        _exit(3);
    }
}
```
Notez que cet exemple n'a pas de contrôle d'erreur.

Et aussi une tout à fait déraisonnable return 0 :-S
Ouais; juste essayer de fermer le système. Je suppose que si un execv échoue il devrait être là.
Aucun moyen de parvenir à ce point est une erreur... mais pour être sûr, j'avais aussi ajouter _exit(EXIT_FAILURE) après l'enfant exec.
OK, amélioré sur la base de commentaires.
Sans vouloir pinailler, mais après une récente série de blocages grâce à tcmalloc et pthread_atfork, je voudrais vraiment insister pour utiliser _exit de l'enfant. C'est juste très dangereux de continuer après une fourche. Je suppose que si l'application est garanti d'être mono-thread (est-ce que votre programme d'allocation de promesse? le savez-vous?), vous avez peut être bien, mais pourquoi prendre le risque.

OriginalL'auteur Carl Norum

Vous devez comprendre comment la fourche et execv travailler ensemble.

fork() crée une copie de la procédure en cours, en renvoyant 0 à l'enfant, childpid parent
fork() peut échouer, et renvoie -1 en cas d'échec, vérifiez que
execv() remplace le double processus parent avec un nouveau processus de
typique fork/exec couplage remplace le processus de l'enfant avec un nouveau processus de
souvent vous de fourche plus d'un enfant, et que vous souhaitez exécuter simultanément,
cependant, vous l'avez demandé d'exécuter consécutivement, qui est l'un après l'autre
ainsi, vous devez attendre le premier à terminer avant de commencer la deuxième
vous devez donc utiliser une variante de wait(), exemple ci-dessous utilise waitpid() pour attendre spécifiques de l'enfant

Vous avez besoin stdlib de sortie (dans le cas execv échoue), et errno, pour imprimer la raison,

//I'm trying to run two executables consecutively using this c code:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>

Vous pourriez vouloir examiner la raison de votre enfant est sorti (vidage de la mémoire, signal, la sortie normale), donc j'ai ajouté cette fonction,

#include <sys/types.h>
#include <sys/wait.h>

//WIFEXITED(status) returns true if the child terminated normally, that is, by calling exit(3) or _exit(2), or by returning from main().
//WEXITSTATUS(status) returns the exit status of the child.  This consists of the least significant 8 bits of the status argument that the child specified in a call to exit(3) or _exit(2) or as the argument for a return statement in main().  This macro should only be employed if WIFEXITED returned true.
//WIFSIGNALED(status) returns true if the child process was terminated by a signal.
//WTERMSIG(status) returns the number of the signal that caused the child process to terminate.  This macro should only be employed if WIFSIGNALED returned true.
//WCOREDUMP(status) returns true if the child produced a core dump.  This macro should only be employed if WIFSIGNALED returned true.  This macro is not specified in POSIX.1-2001 and is not available on some UNIX implementations (e.g., AIX, SunOS).  Only use this enclosed in #ifdef WCOREDUMP ... #endif.
//WIFSTOPPED(status) returns true if the child process was stopped by delivery of a signal; this is only possible if the call was done using WUNTRACED or when the child is being traced (see ptrace(2)).
//WSTOPSIG(status) returns the number of the signal which caused the child to stop.  This macro should only be employed if WIFSTOPPED returned true.
//WIFCONTINUED(status) (since Linux 2.6.10) returns true if the child process was resumed by delivery of SIGCONT.
int
exitreason(pid_t cid, int status)
{
    if( WIFEXITED(status) )
    {
        printf("child %d terminated normally, that is, by calling exit(3) or _exit(2), or by returning from main().\n",cid);
        if( WEXITSTATUS(status) )
        {
        printf("child %d exit status %d.  This consists of the least significant 8 bits of the status argument that the child specified in a call to exit(3) or _exit(2) or as the argument for a return statement in main().\n",cid,WEXITSTATUS(status));
        }
    }
    if( WIFSIGNALED(status) )
    {
        printf("child %d process was terminated by a signal.\n",cid);
        if( WTERMSIG(status) )
        {
        printf("child %d signal %d that caused the child process to terminate.\n",cid,WTERMSIG(status));
        }
        if( WCOREDUMP(status) )
        {
        printf("child %d produced a core dump.  WCOREDUMP() is not specified in POSIX.1-2001 and is not available on some UNIX implementations (e.g., AIX, SunOS).  Only use this enclosed in #ifdef WCOREDUMP ... #endif.\n",cid);
        }
    }
    if( WIFSTOPPED(status) )
    {
        printf("child %d process was stopped by delivery of a signal; this is only possible if the call was done using WUNTRACED or when the child is being traced (see ptrace(2)).\n",cid);
        if( WSTOPSIG(status) )
        {
        printf("child %d number of the signal which caused the child to stop.\n",cid);
        }
    }
    if( WIFCONTINUED(status) )
    {
        printf("child %d process was resumed by delivery of SIGCONT.\n");
    }
}

Et voici votre programme annoté avec les commentaires expliquant les sections de code sont traitées par les parents, et qui, par le ou les enfant(s).

int main (int argc, char *argv[])
{
char proc1[] = "/bin/echo"; //"./prcs1";
char proc2[] = "/bin/echo"; //"./prcs2";
pid_t cid1, cid2, cidX;
int status=0;
int waitoptions = 0;
//WNOHANG    return immediately if no child has exited.
//WUNTRACED  also return if a child has stopped (but not traced via ptrace(2)).  Status for traced children which have stopped is provided even if this option is not specified.
//WCONTINUED also return if a stopped child has been resumed by delivery of SIGCONT.
int res;
if( (cid1 = fork()) == 0 ) //child1
{
printf("in child1\n");
if( (res = execv(proc1, &argv[1])) < 0 ) //GIVE ADDRESS OF 2nd element as starting point to skip source.txt
{
printf("error: child1: %d exec failed %d\n", cid1, errno);
printf("error: cannot execv %s\n",proc1);
exit(91); //must exit child
}
}
else if( cid1 > 0 ) //cid>0, parent, waitfor child
{
cidX = waitpid(cid1, &status, waitoptions);
printf("child1: %d res %d\n", cid1, res);
exitreason(cid1, status);
}
else //cid1 < 0, error
{
printf("error: child1 fork failed\n");
}
if( (cid2 = fork()) == 0 ) //child2
{
printf("in child2\n");
if( (res = execv(proc2, &argv[1])) < 0 ) //GIVE ADDRESS OF 2nd element as starting point to skip source.txt
{
printf("error: child2: %d exec failed %d\n", cid2, errno);
printf("error: cannot execv %s\n",proc2);
exit(92); //must exit child
}
}
else if( cid2 > 0 ) //cid>0, parent, waitfor child
{
cidX = waitpid(cid2, &status, waitoptions);
printf("child2: %d res %d\n", cid2, res);
exitreason(cid2, status);
}
else //cid2 < 0, error
{
printf("error: child2 fork failed\n");
}
}

OriginalL'auteur ChuckCottrill

4

Vous n'avez pas eu beaucoup de lecture sur fork (), je suppose.

lorsque vous appelez fork(), il crée un processus fils qui va exécuter le même code à partir de la fourche.

fork() retourne trois types de valeurs
- négatif qui indique une erreur
- positif, qui dit que vous êtes dans le processus parent et de la valeur montre childprosess ID
- zéro qui dit que vous êtes dans le processus enfant.
votre code devrait ressembler à ceci.
```
#include <stdio.h>
#include <unistd.h>
int main (int argc, char *argv[])
{
int ret = fork();
if(ret==0)
{
//child process
execv("./prcs1", &argv[1]); //GIVE ADDRESS OF 2nd element as starting point to skip source.txt
printf("EXECV Failed from child\n");
}
else if(ret>0)
{
//parent process
execv("./prcs2", argv);
printf("EXECV Failed from parent\n");
}
else
{
//you will come here only if fork() fails.
printf("forkFailed\n");
}
return 0;
}
```
+1 pour exécuter la même code from fork. Ceci est important car le code n'est pas de recommencer mais l'ensemble de données et de pile sont copiés alors que le texte reste le même dans la Région de la table avec une nouvelle copie de Compteur de Programme. Je pense que c'est la plus pertinente réponse.

OriginalL'auteur Dhaval
3

L'exec de la famille ne reviendra que si l'appel échoue.

Puisque vous ne cochez pas la valeur de retour de fork, vous appelez execv dans le parent et l'enfant processus.

Vérifier la valeur de retour: si il est à 0, vous êtes dans le processus de l'enfant, s'il est plus grand que zéro, vous êtes dans le processus parent. Au-dessous de zéro signifie que la fourche a échoué.

En fait, execv() jamais retourne si elle réussit. Voir linux.die.net/man/3/execv
Eh bien, il revient sur l'échec, mais vous avez raison ... je vais modifier la réponse

OriginalL'auteur LostBoy

Vous devez vous connecter pour publier un commentaire.