Discussion :

[frederic13870]

Bonjour ,

Je me lance dans la programmation système.

Cependant, pour mon cas, il faudrait que le fils d'un fork s'exècute APRES que le père soit presque terminé,
ou bien que celui-ci attende l'exécution du fils après que le père ait déroulé une bonne partie de son code.

En effet, je lance une commande système qui sera exécuter par le fils, mais construite par le père.

Un exemple valant mieux qu'un long discours, voici le code :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
/* Pour les constantes EXIT_SUCCESS et EXIT_FAILURE */
#include <stdlib.h>
/* Pour fprintf() */
#include <stdio.h>
/* Pour fork() */
#include <unistd.h>
/* Pour perror() et errno */
#include <errno.h>
/* Pour le type pid_t */
#include <sys/types.h>
/* Pour wait() */
#include <sys/wait.h>
 
/* La fonction create_process duplique le processus appelant et retourne
   le PID du processus fils ainsi créé */
pid_t create_process(void)
{
    /* On crée une nouvelle valeur de type pid_t */
    pid_t pid;
 
    /* On fork() tant que l'erreur est EAGAIN */
    do {
        pid = fork();
    } while ((pid == -1) && (errno == EAGAIN));
 
    /* On retourne le PID du processus ainsi créé */
    return pid;
}
 
/* La fonction child_process effectue les actions du processus fils */
void child_process(int flag)
{
        printf("%s %i\n","flag =",flag);
        if (flag) printf ("%s","Exécution du fils\n");
}
 
/* La fonction father_process effectue les actions du processus père */
int father_process(int child_pid,int flag)
{
    printf("%s","Exécution du père\n");
    flag = 1;
 
 
    if (wait(NULL) == -1) 
    {
        perror("wait :");
        exit(EXIT_FAILURE);
    }
    return flag;
}
 
int main(void)
{
 
 
    int flag = 0;
 
    pid_t pid = create_process();
 
    switch (pid) 
    {
        /* Si on a une erreur irrémédiable (ENOMEM dans notre cas) */
    case -1:
        perror("fork");
        return EXIT_FAILURE;
        break;
        /* Si on est dans le fils */
    case 0:
        {
        child_process(flag);
        break;
        }
        /* Si on est dans le père */
    default:
        {
        flag = father_process(pid,0);
        printf ("%s %i\n", "flag = ",flag);
        break;
        }
    }
 
    return EXIT_SUCCESS;
}

L'idée est que le père mette le flag à 1 pour autoriser l'exécution du fils.

Mais ce code ne marche pas.

De l'aide s.v.p

[LittleWhite]

Bonjour,

La solution "simple", c'est de faire le fork, uniquement lorsque la commande est prête, du coup, pas besoin de synchronisation.
Mais si la question est liée à un exercice quelconque, alors il faudra une communication inter processus. Dans le cas des forks (donc de processus distinct), il faut utiliser un socket (sur localhost), une message queue, ou un segment de mémoire partagé (mmap) (ou un fichier, mais les autres solutions sont plus propres).

Pourquoi cela ne fonctionne pas avec une variable : car le fork créé un nouveau processus (merci captain obvious), mais le nouveau processus ne partage pas sa mémoire avec l'ancien. Au moment du fork, la mémoire du processus père est complètement dupliquée pour le fils, faisant que si des changements dans la mémoire du processus arrive après, alors elles ne sont répercutées chez le fils (et inversement, les modifications dans la mémoire du fils ne sont pas répercutées chez le père). Par contre, avec les threads (aussi appelés processus légers), la mémoire est partagée et l'utilisation d'une variable aurait pu permettre d'arriver à votre objectif.

[WhiteCrow]

Du coup pourquoi faire un fork si on doit attendre la fin du père pour lancer le fils ? c'est séquentiel.
Ou alors, dans le code du père ne faire le fork que lorsqu'il est prêt et pas au début …
J'imagine qu'on est pas loin d'un problème XY.

Du coup une phrase comme :

[...]
En effet, je lance une commande système qui sera exécuter par le fils, mais construite par le père.
[...]

Me fait me demander : pour quoi le fork n'est-il pas effectué une fois la commande construite ?

[gangsoleil]

Bonjour,

il faudrait que le fils d'un fork s'exècute APRES que le père soit presque terminé

Soit je n'ai pas compris, soit c'est conceptuellement bancal : comment le fork pourrait être fait alors que le père est terminé ?

ou bien que celui-ci attende l'exécution du fils après que le père ait déroulé une bonne partie de son code.

Pourquoi faire le fork puis attendre ? Il suffit que ton appel à fork soit fait juste avant que le père ne meurt, et hop tu as résolu ton problème, non ?

je lance une commande système qui sera exécuter par le fils, mais construite par le père.

Justement, lance le fils lorsque la commande est prête !