poly.c

#include <stdnoreturn.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <unistd.h>
#include <fcntl.h>
#include <wait.h>
#include <signal.h>

#define CHK(op) do { if ((op) == -1) raler(1, #op); } while (0)

noreturn void raler(int syserror, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    vfprintf(stderr, fmt, ap);
    fprintf(stderr, "\n");
    va_end(ap);
    if (syserror)
        perror("");
    exit(1);
}
// declaration des variables globales   
volatile sig_atomic_t usr_1 = 0;
volatile sig_atomic_t usr_2 = 0;
// fonction qui gere les signaux
void handler(int signum)
{
    if (signum == SIGUSR1)
        usr_1 = 1;
    else if (signum == SIGUSR2)
        usr_2 = 1;
}
// fonction qui prepare les signaux
void Sigaction_sig(void)
{
    struct sigaction sa;
    sa.sa_handler = handler;
    sa.sa_flags = 0;
    CHK(sigemptyset(&sa.sa_mask));
    CHK(sigaction(SIGUSR1, &sa, NULL));
    CHK(sigaction(SIGUSR2, &sa, NULL));
}
// fonction qui attend les signaux
void Fonc_attendre(int signum)
{
    // printf("Attente signal %d\n", signum);
    sigset_t new, tmp, old;

    CHK(sigemptyset(&new));
    CHK(sigemptyset(&tmp));
    CHK(sigaddset(&new, signum));
    CHK(sigprocmask(SIG_BLOCK, &new, &old)); 

    if (signum == SIGUSR1)
    {
        if (!usr_1)
        {
            sigsuspend(&tmp);
        }
    }
    CHK(sigprocmask(SIG_SETMASK, &old, NULL)); // fin de la section critique
}
// fonction qui calcule le polynome
void Polynome_expr(int fd, char *ai)
{
   
    int tab[4];
    int raison;
    // 12 est la taille maximale d'un entier coder sur 32 bits
    char x[12]={0};
    off_t dec = 0;
    ssize_t read_I;
    while(!usr_2)
    {
    // attendre le signal SIGUSR1
    Fonc_attendre(SIGUSR1);
    if(usr_1)
    {
    usr_1 = 0;
    // positionner le curseur au debut du fichier
    CHK(lseek(fd, 0, SEEK_SET));
    // lire le contenu du fichier
    CHK(read_I = read(fd, &tab, sizeof(tab)));
    // convertir le contenu du fichier en chaine de caractere
    CHK(snprintf(x, sizeof x, "%d", tab[2]));
    char *args[2*tab[1]+5];
    args[0] = "expr";
        args[1] = ai;
        args[2]= "*";
        args[3] = "1";
        for(int j = 1; j <= tab[1]; j++)
        {
            args[2*j+2] = "*";
            args[2*j+3] = x;
        }
        args[2*tab[1]+4] = NULL;
    int tube[2];
    CHK(pipe(tube));

    // creer le petit fils
    pid_t pid = fork();
    switch (pid)
    {
    case -1:
        raler(1, "fork");
        break;
    case 0:
    {
        CHK(close(tube[0]));
        CHK(dup2(tube[1], 1));
        CHK(close(tube[1]));
        execvp("expr", args);
        raler(1, "execvp");
    }   
    default:
    {
        CHK(close(tube[1]));
        char buf[12];
        // lire le resultat du petit fils
        ssize_t read_p;
        CHK(read_p = read(tube[0], buf, sizeof buf));
        CHK(close(tube[0]));
        int resultat = atoi(buf);
        tab[3] += resultat;
        tab[1]++;
        CHK(lseek(fd, 0, SEEK_SET));
        // ecrire le resultat dans le fichier
        CHK(write(fd, tab, sizeof(tab)));
    }
        break;
    }
    // decalage du curseur pour lire le pid du fils suivant
    dec = 4 * sizeof(int) + (tab[1] - 1) * sizeof(pid_t);
    CHK(lseek(fd, dec, SEEK_SET));
    CHK(read(fd, &pid, sizeof(pid)));
    // envoyer un signal au fils suivant
    CHK(kill(pid, SIGUSR1));
    }
    }
     // Attendre la terminaison des fils
        CHK(wait(&raison));
        if (!((WIFEXITED(raison) && WEXITSTATUS(raison) == 0))) {
            if (WIFEXITED(raison))
                raler(0, "fils mal terminé exit %d", WEXITSTATUS(raison));
            else if (WIFSIGNALED(raison))
                raler(0, "fils mal terminé signal %d", WTERMSIG(raison));
            else
                raler(0, "fils mal terminé raison inconnue");
        }
   //CHK(close(fd));
}
int main(int argc, char *argv[])
{
    Sigaction_sig();
    if (argc < 4)
        raler(0, "usage: poly, k , f ,a0, ... , an");
    int k = atoi(argv[1]);
    if (k <= 0)
        raler(0, "k doit être un entier positif non nul");
    int n = argc - 4;
    int raison;
    int a[4];
    // ouvrir le fichier
    char *f = argv[2];
    // creation du fichier
    int fd = open(f, O_CREAT | O_RDWR | O_TRUNC, 0666);
    CHK(fd);
    pid_t fils_Id[n + 1];
    pid_t pere = getpid();
    for (int j = 0; j <= n; j++)
    {
        pid_t pid = fork();
        CHK(pid);
        // on stocke les pid des fils
        fils_Id[j] = pid;
        switch (pid)
        {
        case -1:
            raler(1, "fork");
            break;
        case 0:
        // appel de la fonction Polynome_expr
            Polynome_expr(fd, argv[j + 3]);
            //printf("Processus fils terminé\n");
            exit(0);
            break;
        default:
            break;
        }
    }
    
    // ecrire les valeurs dans le fichier et envoyer un signal au premier fils
    for(int x=1;x<=k;x++)
    {
        a[0] = n;
        a[1] = 0;
        a[2] = x;
        a[3] = 0;
        CHK(write(fd, a, sizeof a));
        CHK(write(fd, fils_Id + 1, sizeof(pid_t) * n));
        CHK(write(fd, &pere, sizeof(pere)));
        CHK(kill(fils_Id[0], SIGUSR1));
        Fonc_attendre(SIGUSR1);
        if(usr_1)
        {
        usr_1 = 0;
        CHK(lseek(fd, 0, SEEK_SET));
        CHK(read(fd, a , sizeof a));
        printf("%d\n",a[3]);
        CHK(lseek(fd, 0, SEEK_SET));
        }

    }
    
    // envoyer un signal a tous les fils pour qu'ils s'arretent
    for (int i = 0; i <= n; i++)
    {
        CHK(kill(fils_Id[i], SIGUSR2));
    }

  // Attendre la terminaison des fils
    for (int i = 0; i <= n; i++) {
        CHK(wait(&raison));
        if (!((WIFEXITED(raison) && WEXITSTATUS(raison) == 0))) {
            if (WIFEXITED(raison))
                raler(0, "fils mal terminé exit %d", WEXITSTATUS(raison));
            else if (WIFSIGNALED(raison))
                raler(0, "fils mal terminé signal %d", WTERMSIG(raison));
            else
                raler(0, "fils mal terminé raison inconnue");
        }
    }

    // on ferme le fichier
    CHK(close(fd));
    // on supprime le fichier
    CHK(unlink(f));

    
    exit(0);
}