Explanation of the program

The programs spawns n child process that are paused right after being created. After that, those child processes take turn to talk to the parent process via pipes.

They talk for a fixed amount of time (ex: should talk for a total of 20 times but stop when they've talked 7 times consecutively and pass to the next process)

Flow of the program

1. Forking all the childs


2. Pausing them right after their creation


3. Waking them up by sending a signal


4. Child write (for a fixed amount of time) to parent via pipe and then stop itself right after sending a signal to parent / Parent read content of pipe and write to STDOUT


5. When parent receive signal change pipe to read other child and signal wake up the following child

The problem

The problem i'm facing is that when it is time to transition to the next process in order to listen to it, I don't get anything from the pipe of the following child even though I do write on the write-end of the pipe in the child process. Is there something I'm missing about SIGSTOP and SIGCONT when reading.

NB: I did read the docs

Program

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <string.h>

#include <signal.h>



#define LOOP_SIZE 20;



/* SIG HANDLERS DEFINITION */

void parentsighandler(int);



/* GLOBAL VARIABLE DEFINITION */ 

pid_t n, ppid, wpid;

int nb_args,  read_return;



// array of pid_t to send signals to child

pid_t  *child_pids;     



volatile sig_atomic_t status = 0;

volatile sig_atomic_t compteur = 0;



int main(int argc, char *argv){   

    write(STDERR_FILENO, "** Begining the programn", 24); // debug

    nb_args = argc - 1; 

    if (nb_args >= 1 ){

        // Variable initialisation

        child_pids= malloc(nb_args * sizeof(pid_t)); 



        // String for sprintf

        char sstr[40]; 

        char rstr[40];

        char pidstr[23];

        char strichild[16];

        char strloopchild[10];



        // Initializing all the pipes for the processes

        int p[2 * nb_args];  



        // getting the pid of the parent process

        ppid = getpid();

        sprintf(pidstr, "Pid of parent is : %dn", ppid);

        write(STDERR_FILENO, pidstr, 23); // debug



        int i, j, stop_val;



        //Initializing all pipes

        write(STDERR_FILENO, "**Init pipesn", 13); // debug

        for (i = 0; i < nb_args; i++){

            if (pipe(&p[2*i]) == -1){

                perror("Error : pipe failed");

                _exit(EXIT_FAILURE);

            }

        }

        write(STDERR_FILENO, "**end init pipesn", 17); // debug

        write(STDERR_FILENO, "**Begin forkn", 15); // debug 

        for (i = 0; i <  nb_args; i ++){

            switch( n = fork()){

            case -1:

                perror("Error : fork failed");

                _exit(EXIT_FAILURE);

            case 0:

                /* CHILD */

                sprintf(strichild, "**In child n%dn", i); // debug

                write(STDERR_FILENO, strichild, strlen(strichild)); // debug

                if (0 == (stop_val = atoi(argv[i+1]))){

                    perror("atoi failed");

                    _exit(EXIT_FAILURE);

                }

                sprintf(strichild, "stop_val is : %dn", stop_val); // debug

                write(STDERR_FILENO, strichild, strlen(strichild)); // debug

                close(p[i*2]);

                for (j = 1; j <= 20 ; j++){

                    sprintf(strloopchild, "loop : %dn", j); // debug

                    write(STDERR_FILENO, strloopchild , strlen(strloopchild)); // debug

                    if (j % stop_val == 0){

                        write(STDERR_FILENO, "I am  pausedn", 15); // debug

                        if ( kill(ppid, SIGUSR1) == -1){

                            write(STDERR_FILENO, "Could not killn",15); // debug

                        }

                        write(STDERR_FILENO, "Sent a sigusr1n",15); // debug

                        kill(getpid(), SIGSTOP);



                    } 

                    write(STDERR_FILENO, "In child : ",11);  

                    sprintf(sstr, "J ecris sur l'entree %d du pipen", i*2+1);  

                    write(STDERR_FILENO, sstr, strlen(sstr));

                    sprintf(sstr, "Je suis le proc %d : message %dn", getpid(), j);

                    write(STDERR_FILENO, sstr, 40); // debug

                    write(p[i * 2 + 1], sstr, 40);

                    sleep(1);



                }   

                close(p[i*2+1]);

                write(STDERR_FILENO, "**Exiting the childn", 20); // debug

                _exit(EXIT_SUCCESS);



            default:

                /* PARENT - process scheduling */

                write(STDERR_FILENO, "**Parent - puting to sleep childsn", 34); // debug 

                child_pids[i] = n;

                kill(n, SIGSTOP);

                // Setting up the signal

                signal(SIGUSR1, parentsighandler); 

            } 

        }

        write(STDOUT_FILENO, "Debut de l'ordonnancementn",26);

        char strpids[20];

        for (i = 0; i < nb_args; i++){

            sprintf(strpids, "id processus : %dn", child_pids[i]);

            write(STDOUT_FILENO, strpids, 20);

        }

        char mystr[17];

        sprintf(mystr, "compteur : %dn", compteur); // debug

        write(STDOUT_FILENO, mystr, 17); // debug  

        kill(child_pids[compteur], SIGCONT);

        while(1){

            if (read(p[2 * compteur], rstr, 40) > 0) {

                write(STDOUT_FILENO,"P : ",5);

                write(STDOUT_FILENO, rstr, 40);

                sprintf(mystr, "compt value: %dn", compteur); // debug

                write(STDOUT_FILENO, mystr, 17); // debug 

            } else {

                write(STDERR_FILENO, "Erreur lecturen", 15);

            } 

            sleep(1);

        }





    } else {

        perror("Error : Not enough argsn");

        _exit(EXIT_FAILURE);

    }   

    return 0;

}



void parentsighandler(int sig){

    if (sig == SIGUSR1){

        write(STDOUT_FILENO, "*************n", 14);//debug

        write(STDOUT_FILENO, "P : going into sig handlern", 28); // debug

        if (compteur == (nb_args - 1)){

            compteur = 0;   

        } else {

            compteur ++;

        }

        kill(child_pids[compteur], SIGCONT);



        char strst[19];

        sprintf(strst, "P : compteur : %dn", compteur); // debug

        write(STDOUT_FILENO, strst, 19); // debug 

        write(STDOUT_FILENO, "*************n", 14);//debug

    }

}