Bonsoir,

J'ai un problème avec un programme en C.

Le but est de créer un processus fils et que le père attende le signal de fin pour exécuter la fin de son code.

Le problème c'est que tout fonctionne correctement sans le wait, mais dès que je rajouter le wait, j'ai une belle erreur de segmentation et je ne vois pas d'où ça pourrait venir.

Si vous avez une idée je suis preneur

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include<time.h>
#include<errno.h>
#include<sys/wait.h>
 
 
int main(int argc, char **argv) {
       pid_t pid;
       struct timespec* t;
       t->tv_sec = 0;
       t->tv_nsec = 500000000;
       struct timespec* j;
       int status=0;
 
       switch(pid=fork()) {
 
               case -1 : // Oups !!! fork n'a pas marché !
                         perror("fork"); exit(errno);
 
               case  0 : // Code du fils
                         for(int i=0; i<10;i++)
                         {
                            printf("%d\n", i);
                            if(nanosleep(t ,j)<0)
                            {
                              perror("Problème avec nanosleep !\n");
                              exit(errno);
                            }
                         }
                         execlp("/bin/ps", "ps", "-f", NULL);
                         exit(2);
 
               default : // Code du père
                        if((pid = wait(&status)) == -1)
                        {
                          perror("Probleme avec le wait !\n");
                          exit(errno);
                        }
                         printf("Code de retour du fils : %d\n", WEXITSTATUS(status)); 
                         printf("Fin du processus père de pid %d.\n", getpid());
       }
 
 
 
       exit(0);
}

Bonjour,

Je ne vois pas de problème particulier sur le wait. Mais avant d'atteindre ce wait, il faut "franchir" du code qui utilise des pointeurs non initialisés (ligne 13, ligne 14 et ligne 27). Je suis étonné que le compilateur ne tousse pas très fort sur ces lignes.

Salut. Quand ça plante il faut utiliser un debugger et voir où ça a planté. Le développement ne consiste pas à deviner.

En revanche, là je peux déjà te dire qu'il y a des variables non initialisées. Utilise un vrai compilateur et des options adéquates pour afficher les warnings (usuellement -Wall -Wextra est un bon début).

Tu n'as pas besoin de déclarer un pointeur sur la structure timespec, ce n'est pas une structure incomplète.

-
Edité par markand 13 novembre 2019 à 9:23:58

Merci, finalement j'ai trouvé la solution. En fait c'était que je ne faisais pas de malloc après ma struct :/

Je viens de te dire que tu n'as pas besoin de l'allouer sur le tas.

struct timespec ts, left;
ts.tv_sec = 0;
ts.tv_nsec = 50000000;
nanosleep(&ts, &left);

Si tu ne lis pas nos réponses, inutile de poster des questions sur le forum.

-
Edité par markand 14 novembre 2019 à 15:25:33

Excuses moi mais j'ai testé avec les deux manières et les deux fonctionnent sans problème. Je ne comprend pas le terme "structure incomplète" que tu as utilisé.

Une structure incomplète est par définition... incomplète. Pour allouer une structure sur la pile le compilateur C a besoin de connaître sa taille. Ainsi, si une structure contient deux entiers, théoriquement cette structure fera 2 x 2 entiers en taille (2 * 4 octets, donc 64 bits usuellement). En revanche, il est tout à fait légal de déclarer uniquement une structure et donc ne pas connaître sa taille. Certaines bibliothèques font ça pour « encapsuler » les structures afin que le développeur n'utilise pas ce qu'il y a à l'intérieur étant donné que le C ne propose pas de contrôle d'accès (public/private/protected, etc... comme en C++).

Ainsi, comme la libarchive par exemple, la bibliothèque C fournira des fonctions qui forcera la création du côté de la bibliothèque et renverra une structure dite « opaque » car seulement utilisable en pointeur et sans en connaître le contenu. Ce principe a un léger avantage cela dit, il permet souvent de garantir une ABI stable.

Exemple, je suis une bibliothèque et je te fournis cette interface :

struct image;

struct image *
image_open(const char *path);

La structure image est incomplète mais je te fournis une fonction "image_open" qui te permet de créer cet objet, tu seras obligé de l'utiliser sous forme de pointeur car le compilateur ne peut pas connaître la taille de cette structure.

En revanche, nanosleep et la structure timespec sont complètement exposées dans le fichier d'entête alors il n'est pas nécessaire d'utiliser d'allocation dynamique puisque ton compilateur a accès complet à cette dite structure.