Annotation of rpl/src/gestion_processus.c, revision 1.14

1.1       bertrand    1: /*
                      2: ================================================================================
1.12      bertrand    3:   RPL/2 (R) version 4.0.16
1.1       bertrand    4:   Copyright (C) 1989-2010 Dr. BERTRAND Joël
                      5: 
                      6:   This file is part of RPL/2.
                      7: 
                      8:   RPL/2 is free software; you can redistribute it and/or modify it
                      9:   under the terms of the CeCILL V2 License as published by the french
                     10:   CEA, CNRS and INRIA.
                     11:  
                     12:   RPL/2 is distributed in the hope that it will be useful, but WITHOUT
                     13:   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
                     14:   FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
                     15:   for more details.
                     16:  
                     17:   You should have received a copy of the CeCILL License
                     18:   along with RPL/2. If not, write to info@cecill.info.
                     19: ================================================================================
                     20: */
                     21: 
                     22: 
                     23: #include "rpl.conv.h"
                     24: 
                     25: 
                     26: /*
                     27: ================================================================================
                     28:   Fonction de surveillance d'un processus fils.
                     29:   Elle tourne dans un thread séparé et ferme les descripteurs lors
                     30:   de la mort du fils.
                     31: ================================================================================
                     32:   Entrées : pointeur sur une structure
                     33: --------------------------------------------------------------------------------
                     34:   Sorties :
                     35: --------------------------------------------------------------------------------
                     36:   Effets de bord : néant
                     37: ================================================================================
                     38: */
                     39: 
                     40: void *
                     41: surveillance_processus(void *argument)
                     42: {
                     43:    int                             iostat;
                     44:    int                             status;
                     45: 
                     46:    integer8                        nombre_donnees;
                     47: 
                     48:    logical1                        drapeau;
                     49:    logical1                        drapeau_fin;
                     50:    logical1                        drapeau_fin_scrutation;
                     51:    logical1                        drapeau_interruptions_traitees;
                     52:    logical1                        drapeau_objets_traites;
                     53: 
                     54:    pid_t                           pid;
                     55:    pid_t                           pid_candidat;
                     56: 
                     57:    pthread_t                       tid_candidat;
                     58: 
                     59:    sigset_t                        masque;
                     60: 
                     61:    ssize_t                         longueur_ecriture;
                     62: 
                     63:    struct_descripteur_thread       *s_argument_thread;
                     64: 
                     65:    struct_liste_chainee            *l_element_courant;
                     66:    struct_liste_chainee            *l_element_precedent;
                     67: 
                     68:    struct_processus                *s_etat_processus;
                     69: 
                     70:    struct timespec                 attente;
                     71: 
                     72:    unsigned char                   caractere;
                     73: 
                     74:    unsigned int                    tampon_erreur;
                     75: 
                     76:    sigemptyset(&masque);
                     77:    sigaddset(&masque, SIGINJECT);
                     78:    sigaddset(&masque, SIGFSTOP);
1.9       bertrand   79:    sigaddset(&masque, SIGFABORT);
1.1       bertrand   80:    sigaddset(&masque, SIGURG);
                     81:    sigaddset(&masque, SIGALRM);
                     82:    sigaddset(&masque, SIGCONT);
                     83:    sigaddset(&masque, SIGINT);
                     84:    pthread_sigmask(SIG_BLOCK, &masque, NULL);
                     85: 
                     86:    s_argument_thread = argument;
                     87:    s_etat_processus = (*s_argument_thread).s_etat_processus;
                     88:    insertion_thread_surveillance(s_etat_processus, s_argument_thread);
                     89: 
                     90:    attente.tv_sec = 0;
                     91:    attente.tv_nsec = GRANULARITE_us * 1000;
                     92: 
                     93:    status = 0;
                     94: 
                     95:    drapeau_interruptions_traitees = d_faux;
                     96:    drapeau_objets_traites = d_faux;
                     97: 
                     98:    if ((*s_etat_processus).debug == d_vrai)
                     99:        if (((*s_etat_processus).type_debug &
                    100:                d_debug_processus) != 0)
                    101:    {
                    102:        if ((*s_argument_thread).processus_detache == d_vrai)
                    103:        {
                    104:            if ((*s_etat_processus).langue == 'F')
                    105:            {
                    106:                printf("[%d] Lancement du thread de surveillance du"
                    107:                        " processus %d\n", (int) getpid(),
                    108:                        (int) (*s_argument_thread).pid);
                    109:            }
                    110:            else
                    111:            {
                    112:                printf("[%d] Start monitoring of process %d\n", (int) getpid(),
                    113:                        (int) (*s_argument_thread).pid);
                    114:            }
                    115:        }
                    116:        else
                    117:        {
                    118:            if ((*s_etat_processus).langue == 'F')
                    119:            {
                    120:                printf("[%d] Lancement du thread de surveillance du"
                    121:                        " thread %llu\n", (int) getpid(), (unsigned long long)
                    122:                        (*s_argument_thread).tid);
                    123:            }
                    124:            else
                    125:            {
                    126:                printf("[%d] Start monitoring of thread %llu\n",
                    127:                        (int) getpid(), (unsigned long long)
                    128:                        (*s_argument_thread).tid);
                    129:            }
                    130:        }
                    131: 
                    132:        fflush(stdout);
                    133:    }
                    134: 
                    135:    /*
                    136:     * On attend une donnée fictive pour être sûr que le processus fils
                    137:     * est bien démarré.
                    138:     */
                    139: 
                    140:    while(read_atomic(s_etat_processus,
                    141:            (*s_argument_thread).pipe_nombre_objets_attente[0],
                    142:            &caractere, sizeof(caractere)) == 0)
                    143:    {
                    144:        if ((*s_etat_processus).var_volatile_requete_arret != 0)
                    145:        {
                    146:            drapeau_objets_traites = d_vrai;
                    147:            drapeau_interruptions_traitees = d_vrai;
                    148:        }
                    149: 
                    150:        nanosleep(&attente, NULL);
                    151:    }
                    152: 
                    153:    do
                    154:    {
                    155:        if ((*s_argument_thread).processus_detache == d_vrai)
                    156:        {
                    157:            /*
                    158:             * Le processus est un processus détaché.
                    159:             */
                    160: 
                    161:            // Scrutation de l'envoi de données par le fils.
                    162: 
                    163:            pid_candidat = 0;
                    164: 
                    165:            if (drapeau_objets_traites == d_vrai)
                    166:            {
                    167:                nanosleep(&attente, NULL);
                    168:            }
                    169:            else if ((iostat = read_atomic(s_etat_processus,
                    170:                    (*s_argument_thread).pipe_nombre_objets_attente[0],
                    171:                    &pid_candidat, sizeof(pid_candidat))) == 0)
                    172:            {
                    173:                // Rien dans le pipe
                    174: 
                    175:                nanosleep(&attente, NULL);
                    176:            }
                    177:            else if (iostat != sizeof(pid_candidat))
                    178:            {
                    179:                (*s_etat_processus).erreur_systeme_processus_fils =
                    180:                        d_es_processus;
                    181:            }
                    182:            else
                    183:            {
                    184:                // Un pid est dans le pipe. On vérifie que les deux pids
                    185:                // correspondent.
                    186: 
                    187:                if (pid_candidat == -2)
                    188:                {
                    189:                    drapeau_objets_traites = d_vrai;
                    190:                }
                    191:                else if (pid_candidat == -1)
                    192:                {
                    193:                }
                    194:                else if ((iostat = read_atomic(s_etat_processus,
                    195:                        (*s_argument_thread).pipe_nombre_objets_attente[0],
                    196:                        &pid_candidat, sizeof(pid_candidat))) ==
                    197:                        sizeof(pid_candidat))
                    198:                {
                    199:                    if ((*s_argument_thread).pid != pid_candidat)
                    200:                    {
                    201:                        (*s_etat_processus).erreur_systeme_processus_fils =
                    202:                                d_es_processus;
                    203:                        BUG(1, printf("Spurious process identifier"));
                    204:                    }
                    205: 
                    206:                    // Un objet supplémentaire est dans le pipe correspondant
                    207:                    // au processus surveillé par ce thread.
                    208: 
                    209:                    if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
                    210:                    {
                    211:                        (*s_etat_processus).erreur_systeme_processus_fils =
                    212:                                d_es_processus;
                    213:                    }
                    214:                    else
                    215:                    {
                    216:                        l_element_courant = (struct_liste_chainee *)
                    217:                                (*s_etat_processus).l_base_pile_processus;
                    218: 
                    219:                        while(l_element_courant != NULL)
                    220:                        {
                    221:                            if ((*(*((struct_processus_fils *)
                    222:                                    (*(*l_element_courant).donnee).objet))
                    223:                                    .thread).processus_detache == d_faux)
                    224:                            {
                    225:                                l_element_courant = (*l_element_courant)
                    226:                                        .suivant;
                    227:                                continue;
                    228:                            }
                    229: 
                    230:                            if ((*(*((struct_processus_fils *)
                    231:                                    (*(*l_element_courant).donnee).objet))
                    232:                                    .thread).pid == pid_candidat)
                    233:                            {
                    234:                                if ((*s_etat_processus).debug == d_vrai)
                    235:                                    if (((*s_etat_processus).type_debug &
                    236:                                            d_debug_processus) != 0)
                    237:                                {
                    238:                                    if ((*s_etat_processus).langue == 'F')
                    239:                                    {
                    240:                                        printf("[%d] Données en provenance "
                    241:                                                "du processus %d\n",
                    242:                                                (int) getpid(),
                    243:                                                (int) (*s_argument_thread).pid);
                    244:                                        fflush(stdout);
                    245:                                    }
                    246:                                    else
                    247:                                    {
                    248:                                        printf("[%d] Data from process %d\n",
                    249:                                                (int) getpid(),
                    250:                                                (int) (*s_argument_thread).pid);
                    251:                                        fflush(stdout);
                    252:                                    }
                    253:                                }
                    254: 
                    255:                                if (pthread_mutex_lock(
                    256:                                        &((*(*((struct_processus_fils *)
                    257:                                        (*(*l_element_courant).donnee).objet))
                    258:                                        .thread).mutex)) != 0)
                    259:                                {
                    260:                                    (*s_etat_processus).erreur_systeme =
                    261:                                            d_es_processus;
                    262:                                }
                    263: 
                    264:                                (*(*((struct_processus_fils *)
                    265:                                        (*(*l_element_courant).donnee).objet))
                    266:                                        .thread).nombre_objets_dans_pipe++;
                    267: 
                    268:                                if (pthread_mutex_unlock(
                    269:                                        &((*(*((struct_processus_fils *)
                    270:                                        (*(*l_element_courant).donnee).objet))
                    271:                                        .thread).mutex)) != 0)
                    272:                                {
                    273:                                    (*s_etat_processus).erreur_systeme =
                    274:                                            d_es_processus;
                    275:                                }
                    276: 
                    277:                                while((longueur_ecriture =
                    278:                                        write_atomic(s_etat_processus,
                    279:                                        (*(*((struct_processus_fils *)
                    280:                                        (*(*l_element_courant).donnee).objet))
                    281:                                        .thread).pipe_acquittement[1], "-",
                    282:                                        sizeof(unsigned char))) !=
                    283:                                        sizeof(unsigned char))
                    284:                                {
                    285:                                    if (longueur_ecriture == -1)
                    286:                                    {
                    287:                                        (*s_etat_processus)
                    288:                                                .erreur_systeme_processus_fils =
                    289:                                                d_es_processus;
                    290:                                    }
                    291:                                }
                    292: 
                    293:                                if ((*s_etat_processus).debug == d_vrai)
                    294:                                    if (((*s_etat_processus).type_debug &
                    295:                                            d_debug_processus) != 0)
                    296:                                {
                    297:                                    if ((*s_etat_processus).langue == 'F')
                    298:                                    {
                    299:                                        printf("[%d] Données acquittées "
                    300:                                                "en provenance du "
                    301:                                                "processus %d\n",
                    302:                                                (int) getpid(),
                    303:                                                (int) (*s_argument_thread).pid);
                    304:                                        fflush(stdout);
                    305:                                    }
                    306:                                    else
                    307:                                    {
                    308:                                        printf("[%d] Data acknowklegment "
                    309:                                                "from process %d\n",
                    310:                                                (int) getpid(),
                    311:                                                (int) (*s_argument_thread).pid);
                    312:                                        fflush(stdout);
                    313:                                    }
                    314:                                }
                    315: 
                    316:                                break;
                    317:                            }
                    318: 
                    319:                            l_element_courant = (*l_element_courant).suivant;
                    320:                        }
                    321: 
                    322:                        BUG(l_element_courant == NULL,
                    323:                                printf("Process or thread not found"));
                    324: 
                    325:                        if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
                    326:                                != 0)
                    327:                        {
                    328:                            (*s_etat_processus).erreur_systeme_processus_fils =
                    329:                                    d_es_processus;
                    330:                        }
                    331: 
                    332:                        pthread_kill((*s_argument_thread).thread_pere,
                    333:                                SIGINJECT);
                    334:                    }
                    335:                }
                    336:                else
                    337:                {
                    338:                    (*s_etat_processus).erreur_systeme_processus_fils =
                    339:                            d_es_processus;
                    340:                }
                    341:            }
                    342: 
                    343:            // Scrutation de l'envoi d'interruptions par le fils.
                    344: 
                    345:            if (drapeau_interruptions_traitees == d_vrai)
                    346:            {
                    347:                nanosleep(&attente, NULL);
                    348:            }
                    349:            else if ((iostat = read_atomic(s_etat_processus,
                    350:                    (*s_argument_thread).pipe_nombre_interruptions_attente[0],
                    351:                    &pid_candidat, sizeof(pid_candidat))) == 0)
                    352:            {
                    353:                // Rien dans le pipe
                    354: 
                    355:                nanosleep(&attente, NULL);
                    356:            }
                    357:            else if (iostat != sizeof(pid_candidat))
                    358:            {
                    359:                (*s_etat_processus).erreur_systeme_processus_fils =
                    360:                        d_es_processus;
                    361:            }
                    362:            else
                    363:            {
                    364:                // Un pid est dans le pipe. On vérifie que les deux pids
                    365:                // correspondent.
                    366: 
                    367:                if (pid_candidat == -2)
                    368:                {
                    369:                    drapeau_interruptions_traitees = d_vrai;
                    370:                }
                    371:                else if (pid_candidat == -1)
                    372:                {
                    373:                }
                    374:                else if ((iostat = read_atomic(s_etat_processus,
                    375:                        (*s_argument_thread).pipe_nombre_interruptions_attente
                    376:                        [0], &pid_candidat, sizeof(pid_candidat)))
                    377:                        == sizeof(pid_candidat))
                    378:                {
                    379:                    if ((*s_argument_thread).pid != pid_candidat)
                    380:                    {
                    381:                        (*s_etat_processus).erreur_systeme_processus_fils =
                    382:                                d_es_processus;
                    383:                        BUG(1, printf("Spurious interrupt"));
                    384:                    }
                    385: 
                    386:                    // Une interruption supplémentaire est dans le pipe
                    387:                    // correspondant au processus surveillé par ce thread.
                    388: 
                    389:                    if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
                    390:                    {
                    391:                        (*s_etat_processus).erreur_systeme_processus_fils =
                    392:                                d_es_processus;
                    393:                    }
                    394:                    else
                    395:                    {
                    396:                        l_element_courant = (struct_liste_chainee *)
                    397:                                (*s_etat_processus).l_base_pile_processus;
                    398: 
                    399:                        while(l_element_courant != NULL)
                    400:                        {
                    401:                            if ((*(*((struct_processus_fils *)
                    402:                                    (*(*l_element_courant).donnee).objet))
                    403:                                    .thread).processus_detache == d_faux)
                    404:                            {
                    405:                                l_element_courant = (*l_element_courant)
                    406:                                        .suivant;
                    407:                                continue;
                    408:                            }
                    409: 
                    410:                            if ((*(*((struct_processus_fils *)
                    411:                                    (*(*l_element_courant).donnee).objet))
                    412:                                    .thread).pid == pid_candidat)
                    413:                            {
                    414:                                if ((*s_etat_processus).debug == d_vrai)
                    415:                                    if (((*s_etat_processus).type_debug &
                    416:                                            d_traitement_interruption) != 0)
                    417:                                {
                    418:                                    if ((*s_etat_processus).langue == 'F')
                    419:                                    {
                    420:                                        printf("[%d] Interrution logicielle "
                    421:                                                "en provenance du processus "
                    422:                                                "%d\n", (int) getpid(),
                    423:                                                (int) (*s_argument_thread).pid);
                    424:                                        fflush(stdout);
                    425:                                    }
                    426:                                    else
                    427:                                    {
                    428:                                        printf("[%d] Software interrupt "
                    429:                                                "from process %d\n",
                    430:                                                (int) getpid(),
                    431:                                                (int) (*s_argument_thread).pid);
                    432:                                        fflush(stdout);
                    433:                                    }
                    434:                                }
                    435: 
                    436:                                if (pthread_mutex_lock(
                    437:                                        &((*(*((struct_processus_fils *)
                    438:                                        (*(*l_element_courant).donnee).objet))
                    439:                                        .thread).mutex)) != 0)
                    440:                                {
                    441:                                    (*s_etat_processus).erreur_systeme =
                    442:                                            d_es_processus;
                    443:                                }
                    444: 
                    445:                                (*(*((struct_processus_fils *)
                    446:                                        (*(*l_element_courant).donnee)
                    447:                                        .objet)).thread)
                    448:                                        .nombre_interruptions_dans_pipe++;
                    449: 
                    450:                                if (pthread_mutex_unlock(
                    451:                                        &((*(*((struct_processus_fils *)
                    452:                                        (*(*l_element_courant).donnee).objet))
                    453:                                        .thread).mutex)) != 0)
                    454:                                {
                    455:                                    (*s_etat_processus).erreur_systeme =
                    456:                                            d_es_processus;
                    457:                                }
                    458: 
                    459:                                (*s_etat_processus)
                    460:                                        .nombre_interruptions_non_affectees++;
                    461: 
                    462:                                while((longueur_ecriture =
                    463:                                        write_atomic(s_etat_processus,
                    464:                                        (*(*((struct_processus_fils *)
                    465:                                        (*(*l_element_courant).donnee).objet))
                    466:                                        .thread).pipe_acquittement[1], "-",
                    467:                                        sizeof(unsigned char))) !=
                    468:                                        sizeof(unsigned char))
                    469:                                {
                    470:                                    if (longueur_ecriture == -1)
                    471:                                    {
                    472:                                        (*s_etat_processus)
                    473:                                                .erreur_systeme_processus_fils =
                    474:                                                d_es_processus;
                    475:                                    }
                    476:                                }
                    477: 
                    478:                                if ((*s_etat_processus).debug == d_vrai)
                    479:                                    if (((*s_etat_processus).type_debug &
                    480:                                            d_traitement_interruption) != 0)
                    481:                                {
                    482:                                    if ((*s_etat_processus).langue == 'F')
                    483:                                    {
                    484:                                        printf("[%d] Interruption logicielle "
                    485:                                                "acquittée en provenance "
                    486:                                                "du processus %d\n",
                    487:                                                (int) getpid(),
                    488:                                                (int) (*s_argument_thread).pid);
                    489:                                        fflush(stdout);
                    490:                                    }
                    491:                                    else
                    492:                                    {
                    493:                                        printf("[%d] Software interrupt "
                    494:                                                "acknowklegment from "
                    495:                                                "process %d\n",
                    496:                                                (int) getpid(),
                    497:                                                (int) (*s_argument_thread).pid);
                    498:                                        fflush(stdout);
                    499:                                    }
                    500:                                }
                    501: 
                    502:                                break;
                    503:                            }
                    504: 
                    505:                            l_element_courant = (*l_element_courant).suivant;
                    506:                        }
                    507: 
                    508:                        BUG(l_element_courant == NULL,
                    509:                                printf("Process or thread not found"));
                    510: 
                    511:                        if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
                    512:                                != 0)
                    513:                        {
                    514:                            (*s_etat_processus).erreur_systeme_processus_fils =
                    515:                                    d_es_processus;
                    516:                        }
                    517: 
                    518:                        pthread_kill((*s_argument_thread).thread_pere,
                    519:                                SIGINJECT);
                    520:                    }
                    521:                }
                    522:                else
                    523:                {
                    524:                    (*s_etat_processus).erreur_systeme_processus_fils =
                    525:                            d_es_processus;
                    526:                }
                    527:            }
                    528: 
                    529:            if ((pid = waitpid((*s_argument_thread).pid, &status, WNOHANG)) < 0)
                    530:            {
                    531:                break;
                    532:            }
                    533: 
                    534:            drapeau_fin_scrutation = (!WIFEXITED(status)) ||
                    535:                    (!WIFSIGNALED(status)) || (pid == 0);
                    536: 
                    537:            if (WIFEXITED(status))
                    538:            {
                    539:                if (WEXITSTATUS(status) == (0xFF & EXIT_FAILURE))
                    540:                {
                    541:                    (*s_etat_processus).erreur_systeme = d_es_processus;
                    542:                }
                    543:            }
                    544:        }
                    545:        else
                    546:        {
                    547:            /*
                    548:             * Le processus n'est pas détaché.
                    549:             */
                    550: 
                    551:            // Scrutation de l'envoi de données par le fils.
                    552: 
                    553:            tid_candidat = (pthread_t) 0;
                    554: 
                    555:            if (drapeau_objets_traites == d_vrai)
                    556:            {
                    557:                nanosleep(&attente, NULL);
                    558:            }
                    559:            else if ((iostat = read_atomic(s_etat_processus,
                    560:                    (*s_argument_thread).pipe_nombre_objets_attente[0],
                    561:                    &tid_candidat, sizeof(tid_candidat))) == 0)
                    562:            {
                    563:                // Rien dans le pipe
                    564: 
                    565:                nanosleep(&attente, NULL);
                    566:            }
                    567:            else if (iostat != sizeof(tid_candidat))
                    568:            {
                    569:                (*s_etat_processus).erreur_systeme_processus_fils =
                    570:                        d_es_processus;
                    571:            }
                    572:            else
                    573:            {
                    574:                // Un pid est dans le pipe. On vérifie que les deux pids
                    575:                // correspondent.
                    576: 
                    577:                if (tid_candidat == (pthread_t) -2)
                    578:                {
                    579:                    drapeau_objets_traites = d_vrai;
                    580:                }
                    581:                else if (tid_candidat == (pthread_t) -1)
                    582:                {
                    583:                }
                    584:                else if ((iostat = read_atomic(s_etat_processus,
                    585:                        (*s_argument_thread).pipe_nombre_objets_attente[0],
                    586:                        &tid_candidat, sizeof(tid_candidat))) ==
                    587:                        sizeof(tid_candidat))
                    588:                {
                    589:                    if (pthread_equal((*s_argument_thread).tid,
                    590:                                tid_candidat) == 0)
                    591:                    {
                    592:                        (*s_etat_processus).erreur_systeme_processus_fils =
                    593:                                d_es_processus;
                    594:                        BUG(1, printf("Spurious thread identifier"));
                    595:                    }
                    596: 
                    597:                    // Un objet supplémentaire est dans le pipe correspondant
                    598:                    // au processus surveillé par ce thread.
                    599: 
                    600:                    if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
                    601:                    {
                    602:                        (*s_etat_processus).erreur_systeme_processus_fils =
                    603:                                d_es_processus;
                    604:                    }
                    605:                    else
                    606:                    {
                    607:                        l_element_courant = (struct_liste_chainee *)
                    608:                                (*s_etat_processus).l_base_pile_processus;
                    609: 
                    610:                        while(l_element_courant != NULL)
                    611:                        {
                    612:                            if ((*(*((struct_processus_fils *)
                    613:                                    (*(*l_element_courant).donnee).objet))
                    614:                                    .thread).processus_detache == d_vrai)
                    615:                            {
                    616:                                l_element_courant = (*l_element_courant)
                    617:                                        .suivant;
                    618:                                continue;
                    619:                            }
                    620: 
                    621:                            if (pthread_equal((*(*((struct_processus_fils *)
                    622:                                    (*(*l_element_courant).donnee).objet))
                    623:                                    .thread).tid, tid_candidat) != 0)
                    624:                            {
                    625:                                if ((*s_etat_processus).debug == d_vrai)
                    626:                                    if (((*s_etat_processus).type_debug &
                    627:                                            d_debug_processus) != 0)
                    628:                                {
                    629:                                    if ((*s_etat_processus).langue == 'F')
                    630:                                    {
                    631:                                        printf("[%d] Données en provenance "
                    632:                                                "du thread %llu\n",
                    633:                                                (int) getpid(),
                    634:                                                (unsigned long long)
                    635:                                                (*s_argument_thread).tid);
                    636:                                        fflush(stdout);
                    637:                                    }
                    638:                                    else
                    639:                                    {
                    640:                                        printf("[%d] Data from thread %llu\n",
                    641:                                                (int) getpid(),
                    642:                                                (unsigned long long)
                    643:                                                (*s_argument_thread).tid);
                    644:                                        fflush(stdout);
                    645:                                    }
                    646:                                }
                    647: 
                    648:                                if (pthread_mutex_lock(
                    649:                                        &((*(*((struct_processus_fils *)
                    650:                                        (*(*l_element_courant).donnee).objet))
                    651:                                        .thread).mutex)) != 0)
                    652:                                {
                    653:                                    (*s_etat_processus).erreur_systeme =
                    654:                                            d_es_processus;
                    655:                                }
                    656: 
                    657:                                (*(*((struct_processus_fils *)
                    658:                                        (*(*l_element_courant).donnee).objet))
                    659:                                        .thread).nombre_objets_dans_pipe++;
                    660: 
                    661:                                if (pthread_mutex_unlock(
                    662:                                        &((*(*((struct_processus_fils *)
                    663:                                        (*(*l_element_courant).donnee).objet))
                    664:                                        .thread).mutex)) != 0)
                    665:                                {
                    666:                                    (*s_etat_processus).erreur_systeme =
                    667:                                            d_es_processus;
                    668:                                }
                    669: 
                    670:                                while((longueur_ecriture =
                    671:                                        write_atomic(s_etat_processus,
                    672:                                        (*(*((struct_processus_fils *)
                    673:                                        (*(*l_element_courant).donnee).objet))
                    674:                                        .thread).pipe_acquittement[1], "-",
                    675:                                        sizeof(unsigned char))) !=
                    676:                                        sizeof(unsigned char))
                    677:                                {
                    678:                                    if (longueur_ecriture == -1)
                    679:                                    {
                    680:                                        (*s_etat_processus)
                    681:                                                .erreur_systeme_processus_fils =
                    682:                                                d_es_processus;
                    683:                                    }
                    684:                                }
                    685: 
                    686:                                if ((*s_etat_processus).debug == d_vrai)
                    687:                                    if (((*s_etat_processus).type_debug &
                    688:                                            d_debug_processus) != 0)
                    689:                                {
                    690:                                    if ((*s_etat_processus).langue == 'F')
                    691:                                    {
                    692:                                        printf("[%d] Données acquittées "
                    693:                                                "en provenance du thread "
                    694:                                                "%llu\n", (int) getpid(),
                    695:                                                (unsigned long long)
                    696:                                                (*s_argument_thread).tid);
                    697:                                        fflush(stdout);
                    698:                                    }
                    699:                                    else
                    700:                                    {
                    701:                                        printf("[%d] Data acknowklegment "
                    702:                                                "from thread %llu\n",
                    703:                                                (int) getpid(),
                    704:                                                (unsigned long long)
                    705:                                                (*s_argument_thread).tid);
                    706:                                        fflush(stdout);
                    707:                                    }
                    708:                                }
                    709: 
                    710:                                break;
                    711:                            }
                    712: 
                    713:                            l_element_courant = (*l_element_courant).suivant;
                    714:                        }
                    715: 
                    716:                        BUG(l_element_courant == NULL,
1.11      bertrand  717:                                printf("Process or thread not found\n"));
1.1       bertrand  718: 
                    719:                        if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
                    720:                                != 0)
                    721:                        {
                    722:                            (*s_etat_processus).erreur_systeme_processus_fils =
                    723:                                    d_es_processus;
                    724:                        }
                    725:                    }
                    726:                }
                    727:                else
                    728:                {
                    729:                    (*s_etat_processus).erreur_systeme_processus_fils =
                    730:                            d_es_processus;
                    731:                }
                    732:            }
                    733: 
                    734:            // Scrutation de l'envoi d'interruptions par le fils.
                    735: 
                    736:            if (drapeau_interruptions_traitees == d_vrai)
                    737:            {
                    738:                nanosleep(&attente, NULL);
                    739:            }
                    740:            else if ((iostat = read_atomic(s_etat_processus,
                    741:                    (*s_argument_thread).pipe_nombre_interruptions_attente[0],
                    742:                    &tid_candidat, sizeof(tid_candidat))) == 0)
                    743:            {
                    744:                // Rien dans le pipe
                    745: 
                    746:                nanosleep(&attente, NULL);
                    747:            }
                    748:            else if (iostat != sizeof(tid_candidat))
                    749:            {
                    750:                (*s_etat_processus).erreur_systeme_processus_fils =
                    751:                        d_es_processus;
                    752:            }
                    753:            else
                    754:            {
                    755:                // Un pid est dans le pipe. On vérifie que les deux pids
                    756:                // correspondent.
                    757: 
                    758:                if (tid_candidat == (pthread_t) -2)
                    759:                {
                    760:                    drapeau_interruptions_traitees = d_vrai;
                    761:                }
                    762:                else if (tid_candidat == (pthread_t) -1)
                    763:                {
                    764:                }
                    765:                else if ((iostat = read_atomic(s_etat_processus,
                    766:                        (*s_argument_thread).pipe_nombre_interruptions_attente
                    767:                        [0], &tid_candidat, sizeof(tid_candidat))) ==
                    768:                        sizeof(tid_candidat))
                    769:                {
                    770:                    if (pthread_equal((*s_argument_thread).tid,
                    771:                            tid_candidat) == 0)
                    772:                    {
                    773:                        (*s_etat_processus).erreur_systeme_processus_fils =
                    774:                                d_es_processus;
                    775:                        BUG(1, printf("Spurious interrupt"));
                    776:                    }
                    777: 
                    778:                    // Une interruption supplémentaire est dans le pipe
                    779:                    // correspondant au processus surveillé par ce thread.
                    780: 
                    781:                    if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
                    782:                    {
                    783:                        (*s_etat_processus).erreur_systeme_processus_fils =
                    784:                                d_es_processus;
                    785:                    }
                    786:                    else
                    787:                    {
                    788:                        l_element_courant = (struct_liste_chainee *)
                    789:                                (*s_etat_processus).l_base_pile_processus;
                    790: 
                    791:                        while(l_element_courant != NULL)
                    792:                        {
                    793:                            if ((*(*((struct_processus_fils *)
                    794:                                    (*(*l_element_courant).donnee).objet))
                    795:                                    .thread).processus_detache == d_vrai)
                    796:                            {
                    797:                                l_element_courant = (*l_element_courant)
                    798:                                        .suivant;
                    799:                                continue;
                    800:                            }
                    801: 
                    802:                            if (pthread_equal((*(*((struct_processus_fils *)
                    803:                                    (*(*l_element_courant).donnee).objet))
                    804:                                    .thread).tid, tid_candidat) != 0)
                    805:                            {
                    806:                                if ((*s_etat_processus).debug == d_vrai)
                    807:                                    if (((*s_etat_processus).type_debug &
                    808:                                            d_debug_processus) != 0)
                    809:                                {
                    810:                                    if ((*s_etat_processus).langue == 'F')
                    811:                                    {
                    812:                                        printf("[%d] Interrution logicielle "
                    813:                                                "en provenance du thread "
                    814:                                                "%llu\n", (int) getpid(),
                    815:                                                (unsigned long long)
                    816:                                                (*s_argument_thread).tid);
                    817:                                        fflush(stdout);
                    818:                                    }
                    819:                                    else
                    820:                                    {
                    821:                                        printf("[%d] Software interrupt "
                    822:                                                "from thread %llu\n",
                    823:                                                (int) getpid(),
                    824:                                                (unsigned long long)
                    825:                                                (*s_argument_thread).tid);
                    826:                                        fflush(stdout);
                    827:                                    }
                    828:                                }
                    829: 
                    830:                                if (pthread_mutex_lock(
                    831:                                        &((*(*((struct_processus_fils *)
                    832:                                        (*(*l_element_courant).donnee).objet))
                    833:                                        .thread).mutex)) != 0)
                    834:                                {
                    835:                                    (*s_etat_processus).erreur_systeme =
                    836:                                            d_es_processus;
                    837:                                }
                    838: 
                    839:                                (*(*((struct_processus_fils *)
                    840:                                        (*(*l_element_courant).donnee)
                    841:                                        .objet)).thread)
                    842:                                        .nombre_interruptions_dans_pipe++;
                    843: 
                    844:                                if (pthread_mutex_unlock(
                    845:                                        &((*(*((struct_processus_fils *)
                    846:                                        (*(*l_element_courant).donnee).objet))
                    847:                                        .thread).mutex)) != 0)
                    848:                                {
                    849:                                    (*s_etat_processus).erreur_systeme =
                    850:                                            d_es_processus;
                    851:                                }
                    852: 
                    853:                                (*s_etat_processus)
                    854:                                        .nombre_interruptions_non_affectees++;
                    855: 
                    856:                                while((longueur_ecriture =
                    857:                                        write_atomic(s_etat_processus,
                    858:                                        (*(*((struct_processus_fils *)
                    859:                                        (*(*l_element_courant).donnee).objet))
                    860:                                        .thread).pipe_acquittement[1], "-",
                    861:                                        sizeof(unsigned char))) !=
                    862:                                        sizeof(unsigned char))
                    863:                                {
                    864:                                    if (longueur_ecriture == -1)
                    865:                                    {
                    866:                                        (*s_etat_processus)
                    867:                                                .erreur_systeme_processus_fils =
                    868:                                                d_es_processus;
                    869:                                    }
                    870:                                }
                    871: 
                    872:                                if ((*s_etat_processus).debug == d_vrai)
                    873:                                    if (((*s_etat_processus).type_debug &
                    874:                                            d_traitement_interruption) != 0)
                    875:                                {
                    876:                                    if ((*s_etat_processus).langue == 'F')
                    877:                                    {
                    878:                                        printf("[%d] Interruption logicielle "
                    879:                                                "acquittée en provenance "
                    880:                                                "du thread %llu\n",
                    881:                                                (int) getpid(),
                    882:                                                (unsigned long long)
                    883:                                                (*s_argument_thread).tid);
                    884:                                        fflush(stdout);
                    885:                                    }
                    886:                                    else
                    887:                                    {
                    888:                                        printf("[%d] Software interrupt "
                    889:                                                "acknowklegment from "
                    890:                                                "thread %llu\n",
                    891:                                                (int) getpid(),
                    892:                                                (unsigned long long)
                    893:                                                (*s_argument_thread).tid);
                    894:                                        fflush(stdout);
                    895:                                    }
                    896:                                }
                    897: 
                    898:                                break;
                    899:                            }
                    900: 
                    901:                            l_element_courant = (*l_element_courant).suivant;
                    902:                        }
                    903: 
                    904:                        BUG(l_element_courant == NULL,
                    905:                                printf("Process or thread not found"));
                    906: 
                    907:                        if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
                    908:                                != 0)
                    909:                        {
                    910:                            (*s_etat_processus).erreur_systeme_processus_fils =
                    911:                                    d_es_processus;
                    912:                        }
                    913:                    }
                    914:                }
                    915:                else
                    916:                {
                    917:                    (*s_etat_processus).erreur_systeme_processus_fils =
                    918:                            d_es_processus;
                    919:                }
                    920:            }
                    921: 
                    922:            if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)
                    923:            {
                    924:                (*s_etat_processus).erreur_systeme = d_es_processus;
                    925:            }
                    926: 
                    927:            if ((*s_argument_thread).thread_actif == d_faux)
                    928:            {
                    929:                if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
                    930:                {
                    931:                    (*s_etat_processus).erreur_systeme = d_es_processus;
                    932:                }
                    933: 
                    934:                pthread_join((*s_argument_thread).tid, NULL);
                    935:                drapeau_fin_scrutation = (0 != 0);
                    936:            }
                    937:            else
                    938:            {
                    939:                if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
                    940:                {
                    941:                    (*s_etat_processus).erreur_systeme = d_es_processus;
                    942:                }
                    943: 
                    944:                drapeau_fin_scrutation = (0 == 0);
                    945:            }
                    946:        }
                    947:    } while(drapeau_fin_scrutation);
                    948: 
                    949:    /*
                    950:     * Le processus fils est terminé. On s'assure qu'il ne
                    951:     * reste plus rien dans les tuyaux...
                    952:     */
                    953: 
                    954:    if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
                    955:    {
                    956:        (*s_etat_processus).erreur_systeme_processus_fils =
                    957:                d_es_processus;
                    958:    }
                    959:    else
                    960:    {
                    961:        if ((*s_etat_processus).debug == d_vrai)
                    962:            if (((*s_etat_processus).type_debug &
                    963:                    d_debug_processus) != 0)
                    964:        {
                    965:            if ((*s_argument_thread).processus_detache == d_vrai)
                    966:            {
                    967:                if ((*s_etat_processus).langue == 'F')
                    968:                {
                    969:                    printf("[%d] Surveillance des tuyaux du processus %d\n",
                    970:                            (int) getpid(), (int) (*s_argument_thread).pid);
                    971:                    fflush(stdout);
                    972:                }
                    973:                else
                    974:                {
                    975:                    printf("[%d] Check remaining pipes of process %d\n",
                    976:                            (int) getpid(), (int) (*s_argument_thread).pid);
                    977:                    fflush(stdout);
                    978:                }
                    979:            }
                    980:            else
                    981:            {
                    982:                if ((*s_etat_processus).langue == 'F')
                    983:                {
                    984:                    printf("[%d] Surveillance des tuyaux du thread %llu\n",
                    985:                            (int) getpid(), (unsigned long long)
                    986:                            (*s_argument_thread).tid);
                    987:                    fflush(stdout);
                    988:                }
                    989:                else
                    990:                {
                    991:                    printf("[%d] Check remaining pipes of thread %llu\n",
                    992:                            (int) getpid(), (unsigned long long)
                    993:                            (*s_argument_thread).tid);
                    994:                    fflush(stdout);
                    995:                }
                    996:            }
                    997:        }
                    998: 
                    999:        l_element_courant = (struct_liste_chainee *)
                   1000:                (*s_etat_processus).l_base_pile_processus;
                   1001: 
                   1002:        if (drapeau_objets_traites == d_faux)
                   1003:        {
                   1004:            if ((*s_argument_thread).processus_detache == d_vrai)
                   1005:            {
                   1006:                while(l_element_courant != NULL)
                   1007:                {
                   1008:                    if ((*(*((struct_processus_fils *) (*(*l_element_courant)
                   1009:                            .donnee).objet)).thread).processus_detache
                   1010:                            == d_faux)
                   1011:                    {
                   1012:                        l_element_courant = (*l_element_courant).suivant;
                   1013:                        continue;
                   1014:                    }
                   1015: 
                   1016:                    if ((*(*((struct_processus_fils *) (*(*l_element_courant)
                   1017:                            .donnee).objet)).thread).pid ==
                   1018:                            (*s_argument_thread).pid)
                   1019:                    {
                   1020:                        while(read_atomic(s_etat_processus, (*s_argument_thread)
                   1021:                                .pipe_nombre_objets_attente[0],
                   1022:                                &pid_candidat, sizeof(pid_candidat)) ==
                   1023:                                sizeof(pid_candidat))
                   1024:                        {
                   1025:                            /*
                   1026:                             * -1 est renvoyé par l'instruction SWI
                   1027:                             */
                   1028: 
                   1029:                            if (pid_candidat == -2)
                   1030:                            {
                   1031:                                break;
                   1032:                            }
                   1033:                            else if (pid_candidat == -1)
                   1034:                            {
                   1035:                            }
                   1036:                            else if (read_atomic(s_etat_processus,
                   1037:                                    (*s_argument_thread)
                   1038:                                    .pipe_nombre_objets_attente[0],
                   1039:                                    &pid_candidat, sizeof(pid_candidat)) ==
                   1040:                                    sizeof(pid_candidat))
                   1041:                            {
                   1042:                                if ((*s_etat_processus).debug == d_vrai)
                   1043:                                    if (((*s_etat_processus).type_debug &
                   1044:                                            d_debug_processus) != 0)
                   1045:                                {
                   1046:                                    if ((*s_etat_processus).langue == 'F')
                   1047:                                    {
                   1048:                                        printf("[%d] Données en provenance du "
                   1049:                                                "processus %d (processus "
                   1050:                                                "arrêté)\n", (int) getpid(),
                   1051:                                                (int) (*s_argument_thread).pid);
                   1052:                                        fflush(stdout);
                   1053:                                    }
                   1054:                                    else
                   1055:                                    {
                   1056:                                        printf("[%d] Data from process %d "
                   1057:                                                "(processus stopped)\n",
                   1058:                                                (int) getpid(),
                   1059:                                                (int) (*s_argument_thread).pid);
                   1060:                                        fflush(stdout);
                   1061:                                    }
                   1062:                                }
                   1063: 
                   1064:                                if (pthread_mutex_lock(
                   1065:                                        &((*(*((struct_processus_fils *)
                   1066:                                        (*(*l_element_courant).donnee).objet))
                   1067:                                        .thread).mutex)) != 0)
                   1068:                                {
                   1069:                                    (*s_etat_processus).erreur_systeme =
                   1070:                                            d_es_processus;
                   1071:                                }
                   1072: 
                   1073:                                (*(*((struct_processus_fils *)
                   1074:                                        (*(*l_element_courant).donnee).objet))
                   1075:                                        .thread).nombre_objets_dans_pipe++;
                   1076: 
                   1077:                                if (pthread_mutex_unlock(
                   1078:                                        &((*(*((struct_processus_fils *)
                   1079:                                        (*(*l_element_courant).donnee).objet))
                   1080:                                        .thread).mutex)) != 0)
                   1081:                                {
                   1082:                                    (*s_etat_processus).erreur_systeme =
                   1083:                                            d_es_processus;
                   1084:                                }
                   1085:                            }
                   1086:                        }
                   1087: 
                   1088:                        break;
                   1089:                    }
                   1090: 
                   1091:                    l_element_courant = (*l_element_courant).suivant;
                   1092:                }
                   1093:            }
                   1094:            else
                   1095:            {
                   1096:                while(l_element_courant != NULL)
                   1097:                {
                   1098:                    if ((*(*((struct_processus_fils *) (*(*l_element_courant)
                   1099:                            .donnee).objet)).thread).processus_detache
                   1100:                            == d_vrai)
                   1101:                    {
                   1102:                        l_element_courant = (*l_element_courant).suivant;
                   1103:                        continue;
                   1104:                    }
                   1105: 
                   1106:                    if (pthread_equal((*(*((struct_processus_fils *)
                   1107:                            (*(*l_element_courant).donnee).objet)).thread).tid,
                   1108:                            (*s_argument_thread).tid) != 0)
                   1109:                    {
                   1110:                        while(read_atomic(s_etat_processus, (*s_argument_thread)
                   1111:                                .pipe_nombre_objets_attente[0],
                   1112:                                &tid_candidat, sizeof(tid_candidat)) ==
                   1113:                                sizeof(tid_candidat))
                   1114:                        {
                   1115:                            /*
                   1116:                             * -1 est renvoyé par l'instruction SWI
                   1117:                             */
                   1118: 
                   1119:                            if (tid_candidat == (pthread_t) -2)
                   1120:                            {
                   1121:                                break;
                   1122:                            }
                   1123:                            else if (tid_candidat == (pthread_t) -1)
                   1124:                            {
                   1125:                            }
                   1126:                            else if (read_atomic(s_etat_processus,
                   1127:                                    (*s_argument_thread)
                   1128:                                    .pipe_nombre_objets_attente[0],
                   1129:                                    &tid_candidat, sizeof(tid_candidat)) ==
                   1130:                                    sizeof(tid_candidat))
                   1131:                            {
                   1132:                                if ((*s_etat_processus).debug == d_vrai)
                   1133:                                    if (((*s_etat_processus).type_debug &
                   1134:                                            d_debug_processus) != 0)
                   1135:                                {
                   1136:                                    if ((*s_etat_processus).langue == 'F')
                   1137:                                    {
                   1138:                                        printf("[%d] Données en provenance du "
                   1139:                                                "thread %llu (thread "
                   1140:                                                "arrêté)\n", (int) getpid(),
                   1141:                                                (unsigned long long)
                   1142:                                                (*s_argument_thread).tid);
                   1143:                                        fflush(stdout);
                   1144:                                    }
                   1145:                                    else
                   1146:                                    {
                   1147:                                        printf("[%d] Data from thread %llu "
                   1148:                                                "(thread stopped)\n",
                   1149:                                                (int) getpid(),
                   1150:                                                (unsigned long long)
                   1151:                                                (*s_argument_thread).tid);
                   1152:                                        fflush(stdout);
                   1153:                                    }
                   1154:                                }
                   1155: 
                   1156:                                if (pthread_mutex_lock(
                   1157:                                        &((*(*((struct_processus_fils *)
                   1158:                                        (*(*l_element_courant).donnee).objet))
                   1159:                                        .thread).mutex)) != 0)
                   1160:                                {
                   1161:                                    (*s_etat_processus).erreur_systeme =
                   1162:                                            d_es_processus;
                   1163:                                }
                   1164: 
                   1165:                                (*(*((struct_processus_fils *)
                   1166:                                        (*(*l_element_courant).donnee).objet))
                   1167:                                        .thread).nombre_objets_dans_pipe++;
                   1168: 
                   1169:                                if (pthread_mutex_unlock(
                   1170:                                        &((*(*((struct_processus_fils *)
                   1171:                                        (*(*l_element_courant).donnee).objet))
                   1172:                                        .thread).mutex)) != 0)
                   1173:                                {
                   1174:                                    (*s_etat_processus).erreur_systeme =
                   1175:                                            d_es_processus;
                   1176:                                }
                   1177:                            }
                   1178:                        }
                   1179: 
                   1180:                        break;
                   1181:                    }
                   1182: 
                   1183:                    l_element_courant = (*l_element_courant).suivant;
                   1184:                }
                   1185:            }
                   1186:        }
                   1187: 
                   1188:        l_element_courant = (struct_liste_chainee *)
                   1189:                (*s_etat_processus).l_base_pile_processus;
                   1190: 
                   1191:        if (drapeau_interruptions_traitees == d_faux)
                   1192:        {
                   1193:            if ((*s_argument_thread).processus_detache == d_vrai)
                   1194:            {
                   1195:                while(l_element_courant != NULL)
                   1196:                {
                   1197:                    if ((*(*((struct_processus_fils *) (*(*l_element_courant)
                   1198:                            .donnee).objet)).thread).processus_detache
                   1199:                            == d_faux)
                   1200:                    {
                   1201:                        l_element_courant = (*l_element_courant).suivant;
                   1202:                        continue;
                   1203:                    }
                   1204: 
                   1205:                    if ((*(*((struct_processus_fils *) (*(*l_element_courant)
                   1206:                            .donnee).objet)).thread).pid ==
                   1207:                            (*s_argument_thread).pid)
                   1208:                    {
                   1209:                        while(read_atomic(s_etat_processus, (*s_argument_thread)
                   1210:                                .pipe_nombre_interruptions_attente[0],
                   1211:                                &pid_candidat, sizeof(pid_candidat)) ==
                   1212:                                sizeof(pid_candidat))
                   1213:                        {
                   1214:                            if (pid_candidat == -2)
                   1215:                            {
                   1216:                                break;
                   1217:                            }
                   1218:                            else if (pid_candidat == -1)
                   1219:                            {
                   1220:                            }
                   1221:                            else if (read_atomic(s_etat_processus,
                   1222:                                    (*s_argument_thread)
                   1223:                                    .pipe_nombre_interruptions_attente[0],
                   1224:                                    &pid_candidat, sizeof(pid_candidat)) ==
                   1225:                                    sizeof(pid_candidat))
                   1226:                            {
                   1227:                                if ((*s_etat_processus).debug == d_vrai)
                   1228:                                    if (((*s_etat_processus).type_debug &
                   1229:                                            d_traitement_interruption) != 0)
                   1230:                                {
                   1231:                                    if ((*s_etat_processus).langue == 'F')
                   1232:                                    {
                   1233:                                        printf("[%d] Interruption logicielle "
                   1234:                                                "en provenance du processus %d"
                   1235:                                                " (processus arrêté)\n",
                   1236:                                                (int) getpid(),
                   1237:                                                (int) (*s_argument_thread).pid);
                   1238:                                        fflush(stdout);
                   1239:                                    }
                   1240:                                    else
                   1241:                                    {
                   1242:                                        printf("[%d] Software interrupt "
                   1243:                                                "from process %d (processus "
                   1244:                                                "stopped)\n", (int) getpid(),
                   1245:                                                (int) (*s_argument_thread).pid);
                   1246:                                        fflush(stdout);
                   1247:                                    }
                   1248:                                }
                   1249: 
                   1250:                                if (pthread_mutex_lock(
                   1251:                                        &((*(*((struct_processus_fils *)
                   1252:                                        (*(*l_element_courant).donnee).objet))
                   1253:                                        .thread).mutex)) != 0)
                   1254:                                {
                   1255:                                    (*s_etat_processus).erreur_systeme =
                   1256:                                            d_es_processus;
                   1257:                                }
                   1258: 
                   1259:                                (*(*((struct_processus_fils *)
                   1260:                                        (*(*l_element_courant).donnee)
                   1261:                                        .objet)).thread)
                   1262:                                        .nombre_interruptions_dans_pipe++;
                   1263: 
                   1264:                                if (pthread_mutex_unlock(
                   1265:                                        &((*(*((struct_processus_fils *)
                   1266:                                        (*(*l_element_courant).donnee).objet))
                   1267:                                        .thread).mutex)) != 0)
                   1268:                                {
                   1269:                                    (*s_etat_processus).erreur_systeme =
                   1270:                                            d_es_processus;
                   1271:                                }
                   1272: 
                   1273:                                (*s_etat_processus)
                   1274:                                        .nombre_interruptions_non_affectees++;
                   1275:                            }
                   1276:                        }
                   1277: 
                   1278:                        break;
                   1279:                    }
                   1280: 
                   1281:                    l_element_courant = (*l_element_courant).suivant;
                   1282:                }
                   1283:            }
                   1284:            else
                   1285:            {
                   1286:                while(l_element_courant != NULL)
                   1287:                {
                   1288:                    if ((*(*((struct_processus_fils *) (*(*l_element_courant)
                   1289:                            .donnee).objet)).thread).processus_detache
                   1290:                            == d_vrai)
                   1291:                    {
                   1292:                        l_element_courant = (*l_element_courant).suivant;
                   1293:                        continue;
                   1294:                    }
                   1295: 
                   1296:                    if (pthread_equal((*(*((struct_processus_fils *)
                   1297:                            (*(*l_element_courant).donnee).objet)).thread).tid,
                   1298:                            (*s_argument_thread).tid) != 0)
                   1299:                    {
                   1300:                        while(read_atomic(s_etat_processus, (*s_argument_thread)
                   1301:                                .pipe_nombre_interruptions_attente[0],
                   1302:                                &tid_candidat, sizeof(tid_candidat)) ==
                   1303:                                sizeof(tid_candidat))
                   1304:                        {
                   1305:                            if (tid_candidat == (pthread_t) -2)
                   1306:                            {
                   1307:                                break;
                   1308:                            }
                   1309:                            else if (tid_candidat == (pthread_t) -1)
                   1310:                            {
                   1311:                            }
                   1312:                            else if (read_atomic(s_etat_processus,
                   1313:                                    (*s_argument_thread)
                   1314:                                    .pipe_nombre_interruptions_attente[0],
                   1315:                                    &tid_candidat, sizeof(tid_candidat)) ==
                   1316:                                    sizeof(tid_candidat))
                   1317:                            {
                   1318:                                if ((*s_etat_processus).debug == d_vrai)
                   1319:                                    if (((*s_etat_processus).type_debug &
                   1320:                                            d_traitement_interruption) != 0)
                   1321:                                {
                   1322:                                    if ((*s_etat_processus).langue == 'F')
                   1323:                                    {
                   1324:                                        printf("[%d] Interruption logicielle "
                   1325:                                                "en provenance du thread %llu"
                   1326:                                                " (thread arrêté)\n",
                   1327:                                                (int) getpid(),
                   1328:                                                (unsigned long long)
                   1329:                                                (*s_argument_thread).tid);
                   1330:                                        fflush(stdout);
                   1331:                                    }
                   1332:                                    else
                   1333:                                    {
                   1334:                                        printf("[%d] Software interrupt "
                   1335:                                                "from thread %llu (thread "
                   1336:                                                "stopped)\n", (int) getpid(),
                   1337:                                                (unsigned long long)
                   1338:                                                (*s_argument_thread).tid);
                   1339:                                        fflush(stdout);
                   1340:                                    }
                   1341:                                }
                   1342: 
                   1343:                                if (pthread_mutex_lock(
                   1344:                                        &((*(*((struct_processus_fils *)
                   1345:                                        (*(*l_element_courant).donnee).objet))
                   1346:                                        .thread).mutex)) != 0)
                   1347:                                {
                   1348:                                    (*s_etat_processus).erreur_systeme =
                   1349:                                            d_es_processus;
                   1350:                                }
                   1351: 
                   1352:                                (*(*((struct_processus_fils *)
                   1353:                                        (*(*l_element_courant).donnee)
                   1354:                                        .objet)).thread)
                   1355:                                        .nombre_interruptions_dans_pipe++;
                   1356: 
                   1357:                                if (pthread_mutex_unlock(
                   1358:                                        &((*(*((struct_processus_fils *)
                   1359:                                        (*(*l_element_courant).donnee).objet))
                   1360:                                        .thread).mutex)) != 0)
                   1361:                                {
                   1362:                                    (*s_etat_processus).erreur_systeme =
                   1363:                                            d_es_processus;
                   1364:                                }
                   1365: 
                   1366:                                (*s_etat_processus)
                   1367:                                        .nombre_interruptions_non_affectees++;
                   1368:                            }
                   1369:                        }
                   1370: 
                   1371:                        break;
                   1372:                    }
                   1373: 
                   1374:                    l_element_courant = (*l_element_courant).suivant;
                   1375:                }
                   1376:            }
                   1377:        }
                   1378: 
                   1379:        if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
                   1380:        {
                   1381:            (*s_etat_processus).erreur_systeme_processus_fils =
                   1382:                    d_es_processus;
                   1383:        }
                   1384:    }
                   1385: 
                   1386:    /*
                   1387:     * Traitement des interruptions et des erreurs.
                   1388:     */
                   1389: 
                   1390:    if ((*s_etat_processus).debug == d_vrai)
                   1391:        if (((*s_etat_processus).type_debug &
                   1392:                d_debug_processus) != 0)
                   1393:    {
                   1394:        if ((*s_argument_thread).processus_detache == d_vrai)
                   1395:        {
                   1396:            if ((*s_etat_processus).langue == 'F')
                   1397:            {
                   1398:                printf("[%d] Récupération des erreurs du processus "
                   1399:                        "%d\n", (int) getpid(),
                   1400:                        (int) (*s_argument_thread).pid);
                   1401:                fflush(stdout);
                   1402:            }
                   1403:            else
                   1404:            {
                   1405:                printf("[%d] Check errors from process %d\n", (int) getpid(),
                   1406:                        (int) (*s_argument_thread).pid);
                   1407:                fflush(stdout);
                   1408:            }
                   1409:        }
                   1410:        else
                   1411:        {
                   1412:            if ((*s_etat_processus).langue == 'F')
                   1413:            {
                   1414:                printf("[%d] Récupération des erreurs du thread "
                   1415:                        "%llu\n", (int) getpid(), (unsigned long long)
                   1416:                        (*s_argument_thread).tid);
                   1417:                fflush(stdout);
                   1418:            }
                   1419:            else
                   1420:            {
                   1421:                printf("[%d] Check errors from process %llu\n", (int) getpid(),
                   1422:                        (unsigned long long) (*s_argument_thread).tid);
                   1423:                fflush(stdout);
                   1424:            }
                   1425:        }
                   1426:    }
                   1427: 
                   1428:    attente.tv_sec = 0;
                   1429:    attente.tv_nsec = GRANULARITE_us * 1000;
                   1430: 
                   1431:    while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],
                   1432:            &((*s_etat_processus).erreur_execution_processus_fils),
                   1433:            sizeof((*s_etat_processus).erreur_execution_processus_fils)) !=
                   1434:            sizeof((*s_etat_processus).erreur_execution_processus_fils))
                   1435:    {
                   1436:        nanosleep(&attente, NULL);
                   1437:        INCR_GRANULARITE(attente.tv_nsec);
                   1438:    }
                   1439: 
                   1440:    attente.tv_sec = 0;
                   1441:    attente.tv_nsec = GRANULARITE_us * 1000;
                   1442: 
                   1443:    while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],
                   1444:            &tampon_erreur,
                   1445:            sizeof((*s_etat_processus).erreur_systeme_processus_fils)) !=
                   1446:            sizeof((*s_etat_processus).erreur_systeme_processus_fils))
                   1447:    {
                   1448:        nanosleep(&attente, NULL);
                   1449:        INCR_GRANULARITE(attente.tv_nsec);
                   1450:    }
                   1451: 
                   1452:    (*s_etat_processus).erreur_systeme_processus_fils = tampon_erreur;
                   1453: 
                   1454:    attente.tv_sec = 0;
                   1455:    attente.tv_nsec = GRANULARITE_us * 1000;
                   1456: 
                   1457:    while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],
                   1458:            &((*s_etat_processus).pid_erreur_processus_fils),
                   1459:            sizeof((*s_etat_processus).pid_erreur_processus_fils)) !=
                   1460:            sizeof((*s_etat_processus).pid_erreur_processus_fils))
                   1461:    {
                   1462:        nanosleep(&attente, NULL);
                   1463:        INCR_GRANULARITE(attente.tv_nsec);
                   1464:    }
                   1465: 
                   1466:    /*
                   1467:     * Si une erreur est déclarée dans le processus fils, le message
                   1468:     * d'erreur a déjà été affiché.
                   1469:     */
                   1470: 
                   1471:    if (((*s_etat_processus).erreur_systeme_processus_fils != d_es) ||
                   1472:            ((*s_etat_processus).erreur_execution_processus_fils != d_ex))
                   1473:    {
                   1474:        (*s_etat_processus).erreur_processus_fils = d_vrai;
                   1475:        (*s_etat_processus).invalidation_message_erreur = d_vrai;
                   1476:    }
                   1477: 
                   1478:    /*
                   1479:     * Retrait du processus de la pile des processus
                   1480:     */
                   1481: 
                   1482:    if (close((*s_argument_thread).pipe_erreurs[0]) != 0)
                   1483:    {
                   1484:        (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
                   1485:    }
                   1486: 
                   1487:    if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
                   1488:    {
                   1489:        (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
                   1490:    }
                   1491:    else
                   1492:    {
                   1493:        do
                   1494:        {
                   1495:            drapeau_fin = d_faux;
                   1496:            l_element_courant = (struct_liste_chainee *)
                   1497:                    (*s_etat_processus).l_base_pile_processus;
                   1498:            nombre_donnees = -1;
                   1499: 
                   1500:            while(l_element_courant != NULL)
                   1501:            {
                   1502:                if ((*s_argument_thread).processus_detache == d_vrai)
                   1503:                {
                   1504:                    if ((*(*((struct_processus_fils *) (*(*l_element_courant)
                   1505:                                .donnee).objet)).thread).processus_detache
                   1506:                                == d_vrai)
                   1507:                    {
                   1508:                        if ((*s_argument_thread).pid ==
                   1509:                                (*(*((struct_processus_fils *)
                   1510:                                (*(*l_element_courant)
                   1511:                                .donnee).objet)).thread).pid)
                   1512:                        {
                   1513:                            if (pthread_mutex_lock(
                   1514:                                    &((*(*((struct_processus_fils *)
                   1515:                                    (*(*l_element_courant).donnee).objet))
                   1516:                                    .thread).mutex)) != 0)
                   1517:                            {
                   1518:                                (*s_etat_processus).erreur_systeme =
                   1519:                                        d_es_processus;
                   1520:                            }
                   1521: 
                   1522:                            nombre_donnees = (*(*((struct_processus_fils *)
                   1523:                                    (*(*l_element_courant).donnee).objet))
                   1524:                                    .thread).nombre_objets_dans_pipe +
                   1525:                                    (*(*((struct_processus_fils *)
                   1526:                                    (*(*l_element_courant).donnee).objet))
                   1527:                                    .thread).nombre_interruptions_dans_pipe;
                   1528: 
                   1529:                            if (pthread_mutex_unlock(
                   1530:                                    &((*(*((struct_processus_fils *)
                   1531:                                    (*(*l_element_courant).donnee).objet))
                   1532:                                    .thread).mutex)) != 0)
                   1533:                            {
                   1534:                                (*s_etat_processus).erreur_systeme =
                   1535:                                        d_es_processus;
                   1536:                            }
                   1537: 
                   1538:                            break;
                   1539:                        }
                   1540:                    }
                   1541:                }
                   1542:                else
                   1543:                {
                   1544:                    if ((*(*((struct_processus_fils *) (*(*l_element_courant)
                   1545:                                .donnee).objet)).thread).processus_detache
                   1546:                                == d_faux)
                   1547:                    {
                   1548:                        if (pthread_equal((*s_argument_thread).tid,
                   1549:                                (*(*((struct_processus_fils *)
                   1550:                                (*(*l_element_courant)
                   1551:                                .donnee).objet)).thread).tid) != 0)
                   1552:                        {
                   1553:                            if (pthread_mutex_lock(
                   1554:                                    &((*(*((struct_processus_fils *)
                   1555:                                    (*(*l_element_courant).donnee).objet))
                   1556:                                    .thread).mutex)) != 0)
                   1557:                            {
                   1558:                                (*s_etat_processus).erreur_systeme =
                   1559:                                        d_es_processus;
                   1560:                            }
                   1561: 
                   1562:                            nombre_donnees = (*(*((struct_processus_fils *)
                   1563:                                    (*(*l_element_courant).donnee).objet))
                   1564:                                    .thread).nombre_objets_dans_pipe +
                   1565:                                    (*(*((struct_processus_fils *)
                   1566:                                    (*(*l_element_courant).donnee).objet))
                   1567:                                    .thread).nombre_interruptions_dans_pipe;
                   1568: 
                   1569:                            if (pthread_mutex_unlock(
                   1570:                                    &((*(*((struct_processus_fils *)
                   1571:                                    (*(*l_element_courant).donnee).objet))
                   1572:                                    .thread).mutex)) != 0)
                   1573:                            {
                   1574:                                (*s_etat_processus).erreur_systeme =
                   1575:                                        d_es_processus;
                   1576:                            }
                   1577: 
                   1578:                            break;
                   1579:                        }
                   1580:                    }
                   1581:                }
                   1582: 
                   1583:                l_element_courant = (*l_element_courant).suivant;
                   1584:            }
                   1585: 
                   1586:            if (nombre_donnees == -1)
                   1587:            {
                   1588:                (*s_etat_processus).erreur_systeme_processus_fils =
                   1589:                        d_es_processus;
                   1590:                drapeau_fin = d_vrai;
                   1591:                BUG(1, printf("Process or thread not found"));
                   1592:            }
                   1593:            else if ((nombre_donnees == 0) ||
                   1594:                    ((*s_etat_processus).var_volatile_requete_arret == -1))
                   1595:            {
                   1596:                if ((*s_etat_processus).debug == d_vrai)
                   1597:                    if (((*s_etat_processus).type_debug &
                   1598:                            d_debug_processus) != 0)
                   1599:                {
                   1600:                    if ((*s_argument_thread).processus_detache == d_vrai)
                   1601:                    {
                   1602:                        if ((*s_etat_processus).langue == 'F')
                   1603:                        {
                   1604:                            printf("[%d] Fermeture des tuyaux du processus "
                   1605:                                    "%d\n", (int) getpid(), (int)
                   1606:                                    (*s_argument_thread).pid);
                   1607:                            fflush(stdout);
                   1608:                        }
                   1609:                        else
                   1610:                        {
                   1611:                            printf("[%d] Close remaining pipes "
                   1612:                                    "of process %d\n", (int) getpid(),
                   1613:                                    (int) (*s_argument_thread).pid);
                   1614:                            fflush(stdout);
                   1615:                        }
                   1616:                    }
                   1617:                    else
                   1618:                    {
                   1619:                        if ((*s_etat_processus).langue == 'F')
                   1620:                        {
                   1621:                            printf("[%d] Fermeture des tuyaux du thread "
                   1622:                                    "%llu\n", (int) getpid(),
                   1623:                                    (unsigned long long)
                   1624:                                    (*s_argument_thread).tid);
                   1625:                            fflush(stdout);
                   1626:                        }
                   1627:                        else
                   1628:                        {
                   1629:                            printf("[%d] Close remaining pipes "
                   1630:                                    "of thread %llu\n", (int) getpid(),
                   1631:                                    (unsigned long long) (*s_argument_thread)
                   1632:                                    .tid);
                   1633:                            fflush(stdout);
                   1634:                        }
                   1635:                    }
                   1636:                }
                   1637: 
                   1638:                if (close((*s_argument_thread).pipe_objets[0]) != 0)
                   1639:                {
                   1640:                    (*s_etat_processus).erreur_systeme_processus_fils =
                   1641:                            d_es_processus;
                   1642:                }
                   1643: 
                   1644:                if (close((*s_argument_thread).pipe_acquittement[1]) != 0)
                   1645:                {
                   1646:                    (*s_etat_processus).erreur_systeme_processus_fils =
                   1647:                            d_es_processus;
                   1648:                }
                   1649: 
                   1650:                if (close((*s_argument_thread).pipe_injections[1]) != 0)
                   1651:                {
                   1652:                    (*s_etat_processus).erreur_systeme_processus_fils =
                   1653:                            d_es_processus;
                   1654:                }
                   1655: 
                   1656:                if (close((*s_argument_thread).pipe_nombre_injections[1]) != 0)
                   1657:                {
                   1658:                    (*s_etat_processus).erreur_systeme_processus_fils =
                   1659:                            d_es_processus;
                   1660:                }
                   1661: 
                   1662:                if (close((*s_argument_thread)
                   1663:                        .pipe_nombre_objets_attente[0]) != 0)
                   1664:                {
                   1665:                    (*s_etat_processus).erreur_systeme_processus_fils =
                   1666:                            d_es_processus;
                   1667:                }
                   1668: 
                   1669:                if (close((*s_argument_thread)
                   1670:                        .pipe_interruptions[0]) != 0)
                   1671:                {
                   1672:                    (*s_etat_processus).erreur_systeme_processus_fils =
                   1673:                            d_es_processus;
                   1674:                }
                   1675: 
                   1676:                if (close((*s_argument_thread)
                   1677:                        .pipe_nombre_interruptions_attente[0]) != 0)
                   1678:                {
                   1679:                    (*s_etat_processus).erreur_systeme_processus_fils =
                   1680:                            d_es_processus;
                   1681:                }
                   1682: 
                   1683:                drapeau_fin = d_vrai;
                   1684:            }
                   1685:            else
                   1686:            {
                   1687:                if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
                   1688:                {
                   1689:                    (*s_etat_processus).erreur_systeme_processus_fils =
                   1690:                            d_es_processus;
                   1691:                    drapeau_fin = d_vrai;
                   1692:                }
                   1693: 
                   1694:                nanosleep(&attente, NULL);
                   1695:                INCR_GRANULARITE(attente.tv_nsec);
                   1696: 
                   1697:                if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
                   1698:                {
                   1699:                    (*s_etat_processus).erreur_systeme_processus_fils =
                   1700:                            d_es_processus;
                   1701:                    drapeau_fin = d_vrai;
                   1702:                }
                   1703:            }
                   1704:        } while(drapeau_fin == d_faux);
                   1705: 
                   1706:        l_element_courant = (struct_liste_chainee *)
                   1707:                (*s_etat_processus).l_base_pile_processus;
                   1708:        l_element_precedent = NULL;
                   1709: 
                   1710:        while(l_element_courant != NULL)
                   1711:        {
                   1712:            drapeau = d_faux;
                   1713: 
                   1714:            if ((*s_argument_thread).processus_detache ==
                   1715:                    (*(*((struct_processus_fils *) (*(*l_element_courant)
                   1716:                    .donnee).objet)).thread).processus_detache)
                   1717:            {
                   1718:                if ((*s_argument_thread).processus_detache == d_vrai)
                   1719:                {
                   1720:                    if ((*(*((struct_processus_fils *)
                   1721:                            (*(*l_element_courant).donnee).objet))
                   1722:                            .thread).pid == (*s_argument_thread).pid)
                   1723:                    {
                   1724:                        drapeau = d_vrai;
                   1725:                    }
                   1726:                    else
                   1727:                    {
                   1728:                        drapeau = d_faux;
                   1729:                    }
                   1730:                }
                   1731:                else
                   1732:                {
                   1733:                    if (pthread_equal((*(*((struct_processus_fils *)
                   1734:                            (*(*l_element_courant).donnee).objet))
                   1735:                            .thread).tid, (*s_argument_thread).tid) != 0)
                   1736:                    {
                   1737:                        drapeau = d_vrai;
                   1738:                    }
                   1739:                    else
                   1740:                    {
                   1741:                        drapeau = d_faux;
                   1742:                    }
                   1743:                }
                   1744:            }
                   1745:            else
                   1746:            {
                   1747:                drapeau = d_faux;
                   1748:            }
                   1749: 
                   1750:            if (drapeau == d_vrai)
                   1751:            {
                   1752:                if (l_element_precedent == NULL)
                   1753:                {
                   1754:                    (*s_etat_processus).l_base_pile_processus =
                   1755:                            (*l_element_courant).suivant;
                   1756: 
1.13      bertrand 1757:                    free((*(*l_element_courant).donnee).objet);
                   1758:                    free((*l_element_courant).donnee);
1.1       bertrand 1759:                    free(l_element_courant);
                   1760: 
                   1761:                    l_element_courant = (struct_liste_chainee *)
                   1762:                            (*s_etat_processus).l_base_pile_processus;
                   1763:                }
                   1764:                else
                   1765:                {
                   1766:                    (*l_element_precedent).suivant =
                   1767:                            (*l_element_courant).suivant;
1.13      bertrand 1768: 
                   1769:                    free((*(*l_element_courant).donnee).objet);
                   1770:                    free((*l_element_courant).donnee);
1.1       bertrand 1771:                    free(l_element_courant);
                   1772:                }
                   1773: 
                   1774:                break;
                   1775:            }
                   1776:            else
                   1777:            {
                   1778:                l_element_precedent = l_element_courant;
                   1779:                l_element_courant = (*l_element_courant).suivant;
                   1780:            }
                   1781:        }
                   1782: 
1.14    ! bertrand 1783:        if ((*s_etat_processus).debug == d_vrai)
        !          1784:            if (((*s_etat_processus).type_debug &
        !          1785:                    d_debug_processus) != 0)
1.1       bertrand 1786:        {
1.14    ! bertrand 1787:            if ((*s_argument_thread).processus_detache == d_vrai)
1.1       bertrand 1788:            {
1.14    ! bertrand 1789:                if ((*s_etat_processus).langue == 'F')
        !          1790:                {
        !          1791:                    printf("[%d] Arrêt du thread de surveillance du"
        !          1792:                            " processus %d\n", (int) getpid(),
        !          1793:                            (int) (*s_argument_thread).pid);
        !          1794:                }
        !          1795:                else
        !          1796:                {
        !          1797:                    printf("[%d] Stop monitoring of process %d", (int) getpid(),
        !          1798:                            (int) (*s_argument_thread).pid);
        !          1799:                }
1.1       bertrand 1800:            }
                   1801:            else
                   1802:            {
1.14    ! bertrand 1803:                if ((*s_etat_processus).langue == 'F')
        !          1804:                {
        !          1805:                    printf("[%d] Arrêt du thread de surveillance du"
        !          1806:                            " thread %llu\n", (int) getpid(),
        !          1807:                            (unsigned long long) (*s_argument_thread)
        !          1808:                            .tid);
        !          1809:                }
        !          1810:                else
        !          1811:                {
        !          1812:                    printf("[%d] Stop monitoring of thread %llu",
        !          1813:                            (int) getpid(),
        !          1814:                            (unsigned long long) (*s_argument_thread)
        !          1815:                            .tid);
        !          1816:                }
1.1       bertrand 1817:            }
1.14    ! bertrand 1818: 
        !          1819:            fflush(stdout);
1.1       bertrand 1820:        }
1.14    ! bertrand 1821: 
        !          1822:        retrait_thread_surveillance(s_etat_processus, s_argument_thread);
        !          1823: 
        !          1824:        if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
1.1       bertrand 1825:        {
1.14    ! bertrand 1826:            (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
1.1       bertrand 1827:        }
                   1828:    }
                   1829: 
                   1830:    pthread_exit(NULL);
                   1831: }
                   1832: 
                   1833: 
                   1834: /*
                   1835: ================================================================================
                   1836:   Fonction d'écriture dans un pipe
                   1837: ================================================================================
                   1838:   Entrées : pointeur sur une structure de description du processus,
                   1839:   numéro du pipe et objet à écrire
                   1840: --------------------------------------------------------------------------------
                   1841:   Sorties :
                   1842: --------------------------------------------------------------------------------
                   1843:   Effets de bord : néant
                   1844: ================================================================================
                   1845: */
                   1846: 
                   1847: logical1
                   1848: ecriture_pipe(struct_processus *s_etat_processus, int pipe,
                   1849:        struct_objet *s_objet)
                   1850: {
                   1851:    struct_liste_chainee            *l_element_courant;
                   1852: 
                   1853:    struct timespec                 attente;
                   1854: 
                   1855:    unsigned long                   i;
                   1856:    unsigned long                   j;
                   1857: 
                   1858:    size_t                          longueur;
                   1859:    ssize_t                         longueur_ecriture;
                   1860: 
                   1861:    if ((*s_objet).type == INT)
                   1862:    {
                   1863:        attente.tv_sec = 0;
                   1864:        attente.tv_nsec = GRANULARITE_us * 1000;
                   1865: 
                   1866:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   1867:                pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
                   1868:                sizeof((*s_objet).type))
                   1869:        {
                   1870:            if (longueur_ecriture == -1)
                   1871:            {
                   1872:                return(d_erreur);
                   1873:            }
                   1874: 
                   1875:            nanosleep(&attente, NULL);
                   1876:            INCR_GRANULARITE(attente.tv_nsec);
                   1877:        }
                   1878: 
                   1879:        attente.tv_sec = 0;
                   1880:        attente.tv_nsec = GRANULARITE_us * 1000;
                   1881: 
                   1882:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   1883:                pipe, (integer8 *)
                   1884:                (*s_objet).objet, sizeof(integer8))) != sizeof(integer8))
                   1885:        {
                   1886:            if (longueur_ecriture == -1)
                   1887:            {
                   1888:                return(d_erreur);
                   1889:            }
                   1890: 
                   1891:            nanosleep(&attente, NULL);
                   1892:            INCR_GRANULARITE(attente.tv_nsec);
                   1893:        }
                   1894:    }
                   1895:    else if ((*s_objet).type == REL)
                   1896:    {
                   1897:        attente.tv_sec = 0;
                   1898:        attente.tv_nsec = GRANULARITE_us * 1000;
                   1899: 
                   1900:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   1901:                pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
                   1902:                sizeof((*s_objet).type))
                   1903:        {
                   1904:            if (longueur_ecriture == -1)
                   1905:            {
                   1906:                return(d_erreur);
                   1907:            }
                   1908: 
                   1909:            nanosleep(&attente, NULL);
                   1910:            INCR_GRANULARITE(attente.tv_nsec);
                   1911:        }
                   1912: 
                   1913:        attente.tv_sec = 0;
                   1914:        attente.tv_nsec = GRANULARITE_us * 1000;
                   1915: 
                   1916:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   1917:                pipe, (real8 *) (*s_objet).objet, sizeof(real8))) !=
                   1918:                sizeof(real8))
                   1919:        {
                   1920:            if (longueur_ecriture == -1)
                   1921:            {
                   1922:                return(d_erreur);
                   1923:            }
                   1924: 
                   1925:            nanosleep(&attente, NULL);
                   1926:            INCR_GRANULARITE(attente.tv_nsec);
                   1927:        }
                   1928:    }
                   1929:    else if ((*s_objet).type == CPL)
                   1930:    {
                   1931:        attente.tv_sec = 0;
                   1932:        attente.tv_nsec = GRANULARITE_us * 1000;
                   1933: 
                   1934:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   1935:                pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
                   1936:                sizeof((*s_objet).type))
                   1937:        {
                   1938:            if (longueur_ecriture == -1)
                   1939:            {
                   1940:                return(d_erreur);
                   1941:            }
                   1942: 
                   1943:            nanosleep(&attente, NULL);
                   1944:            INCR_GRANULARITE(attente.tv_nsec);
                   1945:        }
                   1946: 
                   1947:        attente.tv_sec = 0;
                   1948:        attente.tv_nsec = GRANULARITE_us * 1000;
                   1949: 
                   1950:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   1951:                pipe, (real8 *) (*s_objet).objet, sizeof(complex16)))
                   1952:                != sizeof(complex16))
                   1953:        {
                   1954:            if (longueur_ecriture == -1)
                   1955:            {
                   1956:                return(d_erreur);
                   1957:            }
                   1958: 
                   1959:            nanosleep(&attente, NULL);
                   1960:            INCR_GRANULARITE(attente.tv_nsec);
                   1961:        }
                   1962:    }
                   1963:    else if ((*s_objet).type == VIN)
                   1964:    {
                   1965:        attente.tv_sec = 0;
                   1966:        attente.tv_nsec = GRANULARITE_us * 1000;
                   1967: 
                   1968:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   1969:                pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
                   1970:                sizeof((*s_objet).type))
                   1971:        {
                   1972:            if (longueur_ecriture == -1)
                   1973:            {
                   1974:                return(d_erreur);
                   1975:            }
                   1976: 
                   1977:            nanosleep(&attente, NULL);
                   1978:            INCR_GRANULARITE(attente.tv_nsec);
                   1979:        }
                   1980: 
                   1981:        attente.tv_sec = 0;
                   1982:        attente.tv_nsec = GRANULARITE_us * 1000;
                   1983: 
                   1984:        while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   1985:                &((*((struct_vecteur *) (*s_objet).objet))
                   1986:                .taille), sizeof(unsigned long))) != sizeof(unsigned long))
                   1987:        {
                   1988:            if (longueur_ecriture == -1)
                   1989:            {
                   1990:                return(d_erreur);
                   1991:            }
                   1992: 
                   1993:            nanosleep(&attente, NULL);
                   1994:            INCR_GRANULARITE(attente.tv_nsec);
                   1995:        }
                   1996: 
                   1997:        for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
                   1998:        {
                   1999:            attente.tv_sec = 0;
                   2000:            attente.tv_nsec = GRANULARITE_us * 1000;
                   2001: 
                   2002:            while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2003:                    &(((integer8 *) (*((struct_vecteur *) (*s_objet).objet))
                   2004:                    .tableau)[i]), sizeof(integer8))) != sizeof(integer8))
                   2005:            {
                   2006:                if (longueur_ecriture == -1)
                   2007:                {
                   2008:                    return(d_erreur);
                   2009:                }
                   2010: 
                   2011:                nanosleep(&attente, NULL);
                   2012:                INCR_GRANULARITE(attente.tv_nsec);
                   2013:            }
                   2014:        }
                   2015:    }
                   2016:    else if ((*s_objet).type == VRL)
                   2017:    {
                   2018:        attente.tv_sec = 0;
                   2019:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2020: 
                   2021:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   2022:                pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
                   2023:                sizeof((*s_objet).type))
                   2024:        {
                   2025:            if (longueur_ecriture == -1)
                   2026:            {
                   2027:                return(d_erreur);
                   2028:            }
                   2029: 
                   2030:            nanosleep(&attente, NULL);
                   2031:            INCR_GRANULARITE(attente.tv_nsec);
                   2032:        }
                   2033: 
                   2034:        attente.tv_sec = 0;
                   2035:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2036: 
                   2037:        while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2038:                &((*((struct_vecteur *) (*s_objet).objet))
                   2039:                .taille), sizeof(unsigned long))) != sizeof(unsigned long))
                   2040:        {
                   2041:            if (longueur_ecriture == -1)
                   2042:            {
                   2043:                return(d_erreur);
                   2044:            }
                   2045: 
                   2046:            nanosleep(&attente, NULL);
                   2047:            INCR_GRANULARITE(attente.tv_nsec);
                   2048:        }
                   2049: 
                   2050:        for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
                   2051:        {
                   2052:            attente.tv_sec = 0;
                   2053:            attente.tv_nsec = GRANULARITE_us * 1000;
                   2054: 
                   2055:            while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2056:                    &(((real8 *) (*((struct_vecteur *) (*s_objet).objet))
                   2057:                    .tableau)[i]), sizeof(real8))) != sizeof(real8))
                   2058:            {
                   2059:                if (longueur_ecriture == -1)
                   2060:                {
                   2061:                    return(d_erreur);
                   2062:                }
                   2063: 
                   2064:                nanosleep(&attente, NULL);
                   2065:                INCR_GRANULARITE(attente.tv_nsec);
                   2066:            }
                   2067:        }
                   2068:    }
                   2069:    else if ((*s_objet).type == VCX)
                   2070:    {
                   2071:        attente.tv_sec = 0;
                   2072:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2073: 
                   2074:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   2075:                pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
                   2076:                sizeof((*s_objet).type))
                   2077:        {
                   2078:            if (longueur_ecriture == -1)
                   2079:            {
                   2080:                return(d_erreur);
                   2081:            }
                   2082: 
                   2083:            nanosleep(&attente, NULL);
                   2084:            INCR_GRANULARITE(attente.tv_nsec);
                   2085:        }
                   2086: 
                   2087:        attente.tv_sec = 0;
                   2088:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2089: 
                   2090:        while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2091:                &((*((struct_vecteur *) (*s_objet).objet))
                   2092:                .taille), sizeof(unsigned long))) != sizeof(unsigned long))
                   2093:        {
                   2094:            if (longueur_ecriture == -1)
                   2095:            {
                   2096:                return(d_erreur);
                   2097:            }
                   2098: 
                   2099:            nanosleep(&attente, NULL);
                   2100:            INCR_GRANULARITE(attente.tv_nsec);
                   2101:        }
                   2102: 
                   2103:        for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
                   2104:        {
                   2105:            attente.tv_sec = 0;
                   2106:            attente.tv_nsec = GRANULARITE_us * 1000;
                   2107: 
                   2108:            while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2109:                    &(((complex16 *) (*((struct_vecteur *) (*s_objet).objet))
                   2110:                    .tableau)[i]), sizeof(complex16))) != sizeof(complex16))
                   2111:            {
                   2112:                if (longueur_ecriture == -1)
                   2113:                {
                   2114:                    return(d_erreur);
                   2115:                }
                   2116: 
                   2117:                nanosleep(&attente, NULL);
                   2118:                INCR_GRANULARITE(attente.tv_nsec);
                   2119:            }
                   2120:        }
                   2121:    }
                   2122:    else if ((*s_objet).type == MIN)
                   2123:    {
                   2124:        attente.tv_sec = 0;
                   2125:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2126: 
                   2127:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   2128:                pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
                   2129:                sizeof((*s_objet).type))
                   2130:        {
                   2131:            if (longueur_ecriture == -1)
                   2132:            {
                   2133:                return(d_erreur);
                   2134:            }
                   2135: 
                   2136:            nanosleep(&attente, NULL);
                   2137:            INCR_GRANULARITE(attente.tv_nsec);
                   2138:        }
                   2139: 
                   2140:        attente.tv_sec = 0;
                   2141:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2142: 
                   2143:        while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2144:                &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
                   2145:                sizeof(unsigned long))) != sizeof(unsigned long))
                   2146:        {
                   2147:            if (longueur_ecriture == -1)
                   2148:            {
                   2149:                return(d_erreur);
                   2150:            }
                   2151: 
                   2152:            nanosleep(&attente, NULL);
                   2153:            INCR_GRANULARITE(attente.tv_nsec);
                   2154:        }
                   2155: 
                   2156:        attente.tv_sec = 0;
                   2157:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2158: 
                   2159:        while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2160:                &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
                   2161:                sizeof(unsigned long))) != sizeof(unsigned long))
                   2162:        {
                   2163:            if (longueur_ecriture == -1)
                   2164:            {
                   2165:                return(d_erreur);
                   2166:            }
                   2167: 
                   2168:            nanosleep(&attente, NULL);
                   2169:            INCR_GRANULARITE(attente.tv_nsec);
                   2170:        }
                   2171: 
                   2172:        for(i = 0; i < (*((struct_matrice *)
                   2173:                (*s_objet).objet)).nombre_lignes; i++)
                   2174:        {
                   2175:            for(j = 0; j < (*((struct_matrice *)
                   2176:                    (*s_objet).objet)).nombre_colonnes; j++)
                   2177:            {
                   2178:                attente.tv_sec = 0;
                   2179:                attente.tv_nsec = GRANULARITE_us * 1000;
                   2180: 
                   2181:                while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2182:                        &(((integer8 **) (*((struct_matrice *)
                   2183:                        (*s_objet).objet)).tableau)[i][j]),
                   2184:                        sizeof(integer8))) != sizeof(integer8))
                   2185:                {
                   2186:                    if (longueur_ecriture == -1)
                   2187:                    {
                   2188:                        return(d_erreur);
                   2189:                    }
                   2190: 
                   2191:                    nanosleep(&attente, NULL);
                   2192:                    INCR_GRANULARITE(attente.tv_nsec);
                   2193:                }
                   2194:            }
                   2195:        }
                   2196:    }
                   2197:    else if ((*s_objet).type == MRL)
                   2198:    {
                   2199:        attente.tv_sec = 0;
                   2200:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2201: 
                   2202:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   2203:                pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
                   2204:                sizeof((*s_objet).type))
                   2205:        {
                   2206:            if (longueur_ecriture == -1)
                   2207:            {
                   2208:                return(d_erreur);
                   2209:            }
                   2210: 
                   2211:            nanosleep(&attente, NULL);
                   2212:            INCR_GRANULARITE(attente.tv_nsec);
                   2213:        }
                   2214: 
                   2215:        attente.tv_sec = 0;
                   2216:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2217: 
                   2218:        while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2219:                &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
                   2220:                sizeof(unsigned long))) != sizeof(unsigned long))
                   2221:        {
                   2222:            if (longueur_ecriture == -1)
                   2223:            {
                   2224:                return(d_erreur);
                   2225:            }
                   2226: 
                   2227:            nanosleep(&attente, NULL);
                   2228:            INCR_GRANULARITE(attente.tv_nsec);
                   2229:        }
                   2230: 
                   2231:        attente.tv_sec = 0;
                   2232:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2233: 
                   2234:        while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2235:                &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
                   2236:                sizeof(unsigned long))) != sizeof(unsigned long))
                   2237:        {
                   2238:            if (longueur_ecriture == -1)
                   2239:            {
                   2240:                return(d_erreur);
                   2241:            }
                   2242: 
                   2243:            nanosleep(&attente, NULL);
                   2244:            INCR_GRANULARITE(attente.tv_nsec);
                   2245:        }
                   2246: 
                   2247:        for(i = 0; i < (*((struct_matrice *)
                   2248:                (*s_objet).objet)).nombre_lignes; i++)
                   2249:        {
                   2250:            for(j = 0; j < (*((struct_matrice *)
                   2251:                    (*s_objet).objet)).nombre_colonnes; j++)
                   2252:            {
                   2253:                attente.tv_sec = 0;
                   2254:                attente.tv_nsec = GRANULARITE_us * 1000;
                   2255: 
                   2256:                while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2257:                        &(((real8 **) (*((struct_matrice *)
                   2258:                        (*s_objet).objet)).tableau)[i][j]),
                   2259:                        sizeof(real8))) != sizeof(real8))
                   2260:                {
                   2261:                    if (longueur_ecriture == -1)
                   2262:                    {
                   2263:                        return(d_erreur);
                   2264:                    }
                   2265: 
                   2266:                    nanosleep(&attente, NULL);
                   2267:                    INCR_GRANULARITE(attente.tv_nsec);
                   2268:                }
                   2269:            }
                   2270:        }
                   2271:    }
                   2272:    else if ((*s_objet).type == MCX)
                   2273:    {
                   2274:        attente.tv_sec = 0;
                   2275:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2276: 
                   2277:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   2278:                pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
                   2279:                sizeof((*s_objet).type))
                   2280:        {
                   2281:            if (longueur_ecriture == -1)
                   2282:            {
                   2283:                return(d_erreur);
                   2284:            }
                   2285: 
                   2286:            nanosleep(&attente, NULL);
                   2287:            INCR_GRANULARITE(attente.tv_nsec);
                   2288:        }
                   2289: 
                   2290:        attente.tv_sec = 0;
                   2291:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2292: 
                   2293:        while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2294:                &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
                   2295:                sizeof(unsigned long))) != sizeof(unsigned long))
                   2296:        {
                   2297:            if (longueur_ecriture == -1)
                   2298:            {
                   2299:                return(d_erreur);
                   2300:            }
                   2301: 
                   2302:            nanosleep(&attente, NULL);
                   2303:            INCR_GRANULARITE(attente.tv_nsec);
                   2304:        }
                   2305: 
                   2306:        attente.tv_sec = 0;
                   2307:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2308: 
                   2309:        while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2310:                &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
                   2311:                sizeof(unsigned long))) != sizeof(unsigned long))
                   2312:        {
                   2313:            if (longueur_ecriture == -1)
                   2314:            {
                   2315:                return(d_erreur);
                   2316:            }
                   2317: 
                   2318:            nanosleep(&attente, NULL);
                   2319:            INCR_GRANULARITE(attente.tv_nsec);
                   2320:        }
                   2321: 
                   2322:        for(i = 0; i < (*((struct_matrice *)
                   2323:                (*s_objet).objet)).nombre_lignes; i++)
                   2324:        {
                   2325:            for(j = 0; j < (*((struct_matrice *)
                   2326:                    (*s_objet).objet)).nombre_colonnes; j++)
                   2327:            {
                   2328:                attente.tv_sec = 0;
                   2329:                attente.tv_nsec = GRANULARITE_us * 1000;
                   2330: 
                   2331:                while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2332:                        &(((complex16 **) (*((struct_matrice *)
                   2333:                        (*s_objet).objet)).tableau)[i][j]),
                   2334:                        sizeof(complex16))) != sizeof(complex16))
                   2335:                {
                   2336:                    if (longueur_ecriture == -1)
                   2337:                    {
                   2338:                        return(d_erreur);
                   2339:                    }
                   2340: 
                   2341:                    nanosleep(&attente, NULL);
                   2342:                    INCR_GRANULARITE(attente.tv_nsec);
                   2343:                }
                   2344:            }
                   2345:        }
                   2346:    }
                   2347:    else if ((*s_objet).type == BIN)
                   2348:    {
                   2349:        attente.tv_sec = 0;
                   2350:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2351: 
                   2352:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   2353:                pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
                   2354:                sizeof((*s_objet).type))
                   2355:        {
                   2356:            if (longueur_ecriture == -1)
                   2357:            {
                   2358:                return(d_erreur);
                   2359:            }
                   2360: 
                   2361:            nanosleep(&attente, NULL);
                   2362:            INCR_GRANULARITE(attente.tv_nsec);
                   2363:        }
                   2364: 
                   2365:        attente.tv_sec = 0;
                   2366:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2367: 
                   2368:        while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2369:                (integer8 *) (*s_objet).objet,
                   2370:                sizeof(integer8))) != sizeof(integer8))
                   2371:        {
                   2372:            if (longueur_ecriture == -1)
                   2373:            {
                   2374:                return(d_erreur);
                   2375:            }
                   2376: 
                   2377:            nanosleep(&attente, NULL);
                   2378:            INCR_GRANULARITE(attente.tv_nsec);
                   2379:        }
                   2380:    }
                   2381:    else if ((*s_objet).type == NOM)
                   2382:    {
                   2383:        attente.tv_sec = 0;
                   2384:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2385: 
                   2386:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   2387:                pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
                   2388:                sizeof((*s_objet).type))
                   2389:        {
                   2390:            if (longueur_ecriture == -1)
                   2391:            {
                   2392:                return(d_erreur);
                   2393:            }
                   2394: 
                   2395:            nanosleep(&attente, NULL);
                   2396:            INCR_GRANULARITE(attente.tv_nsec);
                   2397:        }
                   2398: 
                   2399:        longueur = strlen((*((struct_nom *) (*s_objet).objet)).nom) + 1;
                   2400: 
                   2401:        attente.tv_sec = 0;
                   2402:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2403: 
                   2404:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   2405:                pipe, &longueur, sizeof(size_t))) != sizeof(size_t))
                   2406:        {
                   2407:            if (longueur_ecriture == -1)
                   2408:            {
                   2409:                return(d_erreur);
                   2410:            }
                   2411: 
                   2412:            nanosleep(&attente, NULL);
                   2413:            INCR_GRANULARITE(attente.tv_nsec);
                   2414:        }
                   2415: 
                   2416:        attente.tv_sec = 0;
                   2417:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2418: 
                   2419:        while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2420:                (*((struct_nom *) (*s_objet).objet)).nom,
                   2421:                longueur)) != (ssize_t) longueur)
                   2422:        {
                   2423:            if (longueur_ecriture == -1)
                   2424:            {
                   2425:                return(d_erreur);
                   2426:            }
                   2427: 
                   2428:            nanosleep(&attente, NULL);
                   2429:            INCR_GRANULARITE(attente.tv_nsec);
                   2430:        }
                   2431: 
                   2432:        attente.tv_sec = 0;
                   2433:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2434: 
                   2435:        while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2436:                &((*((struct_nom *) (*s_objet).objet))
                   2437:                .symbole), sizeof(logical1))) != sizeof(logical1))
                   2438:        {
                   2439:            if (longueur_ecriture == -1)
                   2440:            {
                   2441:                return(d_erreur);
                   2442:            }
                   2443: 
                   2444:            nanosleep(&attente, NULL);
                   2445:            INCR_GRANULARITE(attente.tv_nsec);
                   2446:        }
                   2447:    }
                   2448:    else if ((*s_objet).type == FCT)
                   2449:    {
                   2450:        attente.tv_sec = 0;
                   2451:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2452: 
                   2453:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   2454:                pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
                   2455:                sizeof((*s_objet).type))
                   2456:        {
                   2457:            if (longueur_ecriture == -1)
                   2458:            {
                   2459:                return(d_erreur);
                   2460:            }
                   2461: 
                   2462:            nanosleep(&attente, NULL);
                   2463:            INCR_GRANULARITE(attente.tv_nsec);
                   2464:        }
                   2465: 
                   2466:        longueur = strlen((*((struct_fonction *)
                   2467:                (*s_objet).objet)).nom_fonction) + 1;
                   2468: 
                   2469:        attente.tv_sec = 0;
                   2470:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2471: 
                   2472:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   2473:                pipe, &longueur, sizeof(size_t))) != sizeof(size_t))
                   2474:        {
                   2475:            if (longueur_ecriture == -1)
                   2476:            {
                   2477:                return(d_erreur);
                   2478:            }
                   2479: 
                   2480:            nanosleep(&attente, NULL);
                   2481:            INCR_GRANULARITE(attente.tv_nsec);
                   2482:        }
                   2483: 
                   2484:        attente.tv_sec = 0;
                   2485:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2486: 
                   2487:        while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2488:                (*((struct_fonction *) (*s_objet).objet))
                   2489:                .nom_fonction, longueur)) != (ssize_t) longueur)
                   2490:        {
                   2491:            if (longueur_ecriture == -1)
                   2492:            {
                   2493:                return(d_erreur);
                   2494:            }
                   2495: 
                   2496:            nanosleep(&attente, NULL);
                   2497:            INCR_GRANULARITE(attente.tv_nsec);
                   2498:        }
                   2499: 
                   2500:        attente.tv_sec = 0;
                   2501:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2502: 
                   2503:        while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2504:                &((*((struct_fonction *) (*s_objet).objet)).nombre_arguments),
                   2505:                sizeof(unsigned long))) != sizeof(unsigned long))
                   2506:        {
                   2507:            if (longueur_ecriture == -1)
                   2508:            {
                   2509:                return(d_erreur);
                   2510:            }
                   2511: 
                   2512:            nanosleep(&attente, NULL);
                   2513:            INCR_GRANULARITE(attente.tv_nsec);
                   2514:        }
                   2515:    }
                   2516:    else if ((*s_objet).type == CHN)
                   2517:    {
                   2518:        attente.tv_sec = 0;
                   2519:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2520: 
                   2521:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   2522:                pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
                   2523:                sizeof((*s_objet).type))
                   2524:        {
                   2525:            if (longueur_ecriture == -1)
                   2526:            {
                   2527:                return(d_erreur);
                   2528:            }
                   2529: 
                   2530:            nanosleep(&attente, NULL);
                   2531:            INCR_GRANULARITE(attente.tv_nsec);
                   2532:        }
                   2533: 
                   2534:        longueur = strlen((unsigned char *) (*s_objet).objet) + 1;
                   2535: 
                   2536:        attente.tv_sec = 0;
                   2537:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2538: 
                   2539:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   2540:                pipe, &longueur, sizeof(size_t))) != sizeof(size_t))
                   2541:        {
                   2542:            if (longueur_ecriture == -1)
                   2543:            {
                   2544:                return(d_erreur);
                   2545:            }
                   2546: 
                   2547:            nanosleep(&attente, NULL);
                   2548:            INCR_GRANULARITE(attente.tv_nsec);
                   2549:        }
                   2550: 
                   2551:        attente.tv_sec = 0;
                   2552:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2553: 
                   2554:        while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2555:                (unsigned char *) (*s_objet).objet,
                   2556:                longueur)) != (ssize_t) longueur)
                   2557:        {
                   2558:            if (longueur_ecriture == -1)
                   2559:            {
                   2560:                return(d_erreur);
                   2561:            }
                   2562: 
                   2563:            nanosleep(&attente, NULL);
                   2564:            INCR_GRANULARITE(attente.tv_nsec);
                   2565:        }
                   2566:    }
                   2567:    else if (((*s_objet).type == LST) ||
                   2568:            ((*s_objet).type == ALG) ||
                   2569:            ((*s_objet).type == RPN))
                   2570:    {
                   2571:        attente.tv_sec = 0;
                   2572:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2573: 
                   2574:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   2575:                pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
                   2576:                sizeof((*s_objet).type))
                   2577:        {
                   2578:            if (longueur_ecriture == -1)
                   2579:            {
                   2580:                return(d_erreur);
                   2581:            }
                   2582: 
                   2583:            nanosleep(&attente, NULL);
                   2584:            INCR_GRANULARITE(attente.tv_nsec);
                   2585:        }
                   2586: 
                   2587:        l_element_courant = (*s_objet).objet;
                   2588:        i = 0;
                   2589: 
                   2590:        while(l_element_courant != NULL)
                   2591:        {
                   2592:            i++;
                   2593:            l_element_courant = (*l_element_courant).suivant;
                   2594:        }
                   2595: 
                   2596:        attente.tv_sec = 0;
                   2597:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2598: 
                   2599:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   2600:                pipe, &i, sizeof(i))) != sizeof(i))
                   2601:        {
                   2602:            if (longueur_ecriture == -1)
                   2603:            {
                   2604:                return(d_erreur);
                   2605:            }
                   2606: 
                   2607:            nanosleep(&attente, NULL);
                   2608:            INCR_GRANULARITE(attente.tv_nsec);
                   2609:        }
                   2610: 
                   2611:        l_element_courant = (*s_objet).objet;
                   2612: 
                   2613:        while(l_element_courant != NULL)
                   2614:        {
                   2615:            if (ecriture_pipe(s_etat_processus, pipe,
                   2616:                    (*l_element_courant).donnee) == d_erreur)
                   2617:            {
                   2618:                return(d_erreur);
                   2619:            }
                   2620: 
                   2621:            l_element_courant = (*l_element_courant).suivant;
                   2622:        }
                   2623:    }
                   2624:    else if ((*s_objet).type == TBL)
                   2625:    {
                   2626:        attente.tv_sec = 0;
                   2627:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2628: 
                   2629:        while((longueur_ecriture = write_atomic(s_etat_processus,
                   2630:                pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
                   2631:                sizeof((*s_objet).type))
                   2632:        {
                   2633:            if (longueur_ecriture == -1)
                   2634:            {
                   2635:                return(d_erreur);
                   2636:            }
                   2637: 
                   2638:            nanosleep(&attente, NULL);
                   2639:            INCR_GRANULARITE(attente.tv_nsec);
                   2640:        }
                   2641: 
                   2642:        attente.tv_sec = 0;
                   2643:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2644: 
                   2645:        while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                   2646:                &((*((struct_tableau *) (*s_objet).objet)).nombre_elements),
                   2647:                sizeof(unsigned long))) != sizeof(unsigned long))
                   2648:        {
                   2649:            if (longueur_ecriture == -1)
                   2650:            {
                   2651:                return(d_erreur);
                   2652:            }
                   2653: 
                   2654:            nanosleep(&attente, NULL);
                   2655:            INCR_GRANULARITE(attente.tv_nsec);
                   2656:        }
                   2657: 
                   2658:        for(i = 0; i < (*((struct_tableau *)
                   2659:                (*s_objet).objet)).nombre_elements; i++)
                   2660:        {
                   2661:            if (ecriture_pipe(s_etat_processus, pipe,
                   2662:                    (*((struct_tableau *) (*s_objet).objet)).elements[i])
                   2663:                    == d_erreur)
                   2664:            {
                   2665:                return(d_erreur);
                   2666:            }
                   2667:        }
                   2668:    }
                   2669:    else
                   2670:    {
                   2671:        (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
                   2672:        return(d_erreur);
                   2673:    }
                   2674: 
                   2675:    return(d_absence_erreur);
                   2676: }
                   2677: 
                   2678: 
                   2679: /*
                   2680: ================================================================================
                   2681:   Fonction de lecture dans un pipe
                   2682: ================================================================================
                   2683:   Entrées : pointeur sur une structure de description du processus,
                   2684:   numéro du pipe et objet à écrire
                   2685: --------------------------------------------------------------------------------
                   2686:   Sorties :
                   2687: --------------------------------------------------------------------------------
                   2688:   Effets de bord : néant
                   2689: ================================================================================
                   2690: */
                   2691: 
                   2692: struct_objet *
                   2693: lecture_pipe(struct_processus *s_etat_processus, int pipe)
                   2694: {
                   2695:    size_t                  longueur;
                   2696: 
                   2697:    struct_liste_chainee    *l_element_courant;
                   2698: 
                   2699:    struct_objet            *s_objet;
                   2700: 
                   2701:    struct timespec         attente;
                   2702: 
                   2703:    unsigned long           i;
                   2704:    unsigned long           j;
                   2705: 
                   2706:    if ((s_objet = allocation(s_etat_processus, NON)) == NULL)
                   2707:    {
                   2708:        (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2709:        return(NULL);
                   2710:    }
                   2711: 
                   2712:    attente.tv_sec = 0;
                   2713:    attente.tv_nsec = GRANULARITE_us * 1000;
                   2714: 
                   2715:    while(read_atomic(s_etat_processus, pipe, &((*s_objet).type),
                   2716:            sizeof((*s_objet).type)) != sizeof((*s_objet).type))
                   2717:    {
                   2718:        nanosleep(&attente, NULL);
                   2719:        INCR_GRANULARITE(attente.tv_nsec);
                   2720:    }
                   2721: 
                   2722:    if ((*s_objet).type == INT)
                   2723:    {
                   2724:        if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
                   2725:        {
                   2726:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2727:            return(NULL);
                   2728:        }
                   2729: 
                   2730:        attente.tv_sec = 0;
                   2731:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2732: 
                   2733:        while(read_atomic(s_etat_processus, pipe,
                   2734:                (*s_objet).objet, sizeof(integer8)) != sizeof(integer8))
                   2735:        {
                   2736:            nanosleep(&attente, NULL);
                   2737:            INCR_GRANULARITE(attente.tv_nsec);
                   2738:        }
                   2739:    }
                   2740:    else if ((*s_objet).type == REL)
                   2741:    {
                   2742:        if (((*s_objet).objet = malloc(sizeof(real8))) == NULL)
                   2743:        {
                   2744:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2745:            return(NULL);
                   2746:        }
                   2747: 
                   2748:        attente.tv_sec = 0;
                   2749:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2750: 
                   2751:        while(read_atomic(s_etat_processus, pipe,
                   2752:                (*s_objet).objet, sizeof(real8)) != sizeof(real8))
                   2753:        {
                   2754:            nanosleep(&attente, NULL);
                   2755:            INCR_GRANULARITE(attente.tv_nsec);
                   2756:        }
                   2757:    }
                   2758:    else if ((*s_objet).type == CPL)
                   2759:    {
                   2760:        if (((*s_objet).objet = malloc(sizeof(complex16))) == NULL)
                   2761:        {
                   2762:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2763:            return(NULL);
                   2764:        }
                   2765: 
                   2766:        attente.tv_sec = 0;
                   2767:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2768: 
                   2769:        while(read_atomic(s_etat_processus, pipe,
                   2770:                (*s_objet).objet, sizeof(complex16)) != sizeof(complex16))
                   2771:        {
                   2772:            nanosleep(&attente, NULL);
                   2773:            INCR_GRANULARITE(attente.tv_nsec);
                   2774:        }
                   2775:    }
                   2776:    else if ((*s_objet).type == VIN)
                   2777:    {
                   2778:        if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
                   2779:        {
                   2780:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2781:            return(NULL);
                   2782:        }
                   2783: 
                   2784:        (*((struct_vecteur *) (*s_objet).objet)).type = 'I';
                   2785: 
                   2786:        attente.tv_sec = 0;
                   2787:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2788: 
                   2789:        while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
                   2790:                (*s_objet).objet)).taille),
                   2791:                sizeof(unsigned long)) != sizeof(unsigned long))
                   2792:        {
                   2793:            nanosleep(&attente, NULL);
                   2794:            INCR_GRANULARITE(attente.tv_nsec);
                   2795:        }
                   2796: 
                   2797:        if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
                   2798:                malloc((*((struct_vecteur *) (*s_objet).objet)).taille *
                   2799:                sizeof(integer8))) == NULL)
                   2800:        {
                   2801:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2802:            return(NULL);
                   2803:        }
                   2804: 
                   2805:        for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
                   2806:        {
                   2807:            attente.tv_sec = 0;
                   2808:            attente.tv_nsec = GRANULARITE_us * 1000;
                   2809: 
                   2810:            while(read_atomic(s_etat_processus, pipe,
                   2811:                    &(((integer8 *) (*((struct_vecteur *)
                   2812:                    (*s_objet).objet)).tableau)[i]), sizeof(integer8)) !=
                   2813:                    sizeof(integer8))
                   2814:            {
                   2815:                nanosleep(&attente, NULL);
                   2816:                INCR_GRANULARITE(attente.tv_nsec);
                   2817:            }
                   2818:        }
                   2819:    }
                   2820:    else if ((*s_objet).type == VRL)
                   2821:    {
                   2822:        if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
                   2823:        {
                   2824:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2825:            return(NULL);
                   2826:        }
                   2827: 
                   2828:        (*((struct_vecteur *) (*s_objet).objet)).type = 'R';
                   2829: 
                   2830:        attente.tv_sec = 0;
                   2831:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2832: 
                   2833:        while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
                   2834:                (*s_objet).objet)).taille),
                   2835:                sizeof(unsigned long)) != sizeof(unsigned long))
                   2836:        {
                   2837:            nanosleep(&attente, NULL);
                   2838:            INCR_GRANULARITE(attente.tv_nsec);
                   2839:        }
                   2840: 
                   2841:        if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
                   2842:                malloc((*((struct_vecteur *) (*s_objet).objet)).taille *
                   2843:                sizeof(real8))) == NULL)
                   2844:        {
                   2845:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2846:            return(NULL);
                   2847:        }
                   2848: 
                   2849:        for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
                   2850:        {
                   2851:            attente.tv_sec = 0;
                   2852:            attente.tv_nsec = GRANULARITE_us * 1000;
                   2853: 
                   2854:            while(read_atomic(s_etat_processus, pipe,
                   2855:                    &(((real8 *) (*((struct_vecteur *)
                   2856:                    (*s_objet).objet)).tableau)[i]), sizeof(real8)) !=
                   2857:                    sizeof(real8))
                   2858:            {
                   2859:                nanosleep(&attente, NULL);
                   2860:                INCR_GRANULARITE(attente.tv_nsec);
                   2861:            }
                   2862:        }
                   2863:    }
                   2864:    else if ((*s_objet).type == VCX)
                   2865:    {
                   2866:        if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
                   2867:        {
                   2868:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2869:            return(NULL);
                   2870:        }
                   2871: 
                   2872:        (*((struct_vecteur *) (*s_objet).objet)).type = 'C';
                   2873: 
                   2874:        attente.tv_sec = 0;
                   2875:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2876: 
                   2877:        while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
                   2878:                (*s_objet).objet)).taille),
                   2879:                sizeof(unsigned long)) != sizeof(unsigned long))
                   2880:        {
                   2881:            nanosleep(&attente, NULL);
                   2882:            INCR_GRANULARITE(attente.tv_nsec);
                   2883:        }
                   2884: 
                   2885:        if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
                   2886:                malloc((*((struct_vecteur *) (*s_objet).objet)).taille *
                   2887:                sizeof(complex16))) == NULL)
                   2888:        {
                   2889:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2890:            return(NULL);
                   2891:        }
                   2892: 
                   2893:        for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
                   2894:        {
                   2895:            attente.tv_sec = 0;
                   2896:            attente.tv_nsec = GRANULARITE_us * 1000;
                   2897: 
                   2898:            while(read_atomic(s_etat_processus, pipe,
                   2899:                    &(((complex16 *) (*((struct_vecteur *)
                   2900:                    (*s_objet).objet)).tableau)[i]), sizeof(complex16)) !=
                   2901:                    sizeof(complex16))
                   2902:            {
                   2903:                nanosleep(&attente, NULL);
                   2904:                INCR_GRANULARITE(attente.tv_nsec);
                   2905:            }
                   2906:        }
                   2907:    }
                   2908:    else if ((*s_objet).type == MIN)
                   2909:    {
                   2910:        if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
                   2911:        {
                   2912:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2913:            return(NULL);
                   2914:        }
                   2915: 
                   2916:        (*((struct_matrice *) (*s_objet).objet)).type = 'I';
                   2917: 
                   2918:        attente.tv_sec = 0;
                   2919:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2920: 
                   2921:        while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
                   2922:                (*s_objet).objet)).nombre_lignes),
                   2923:                sizeof(unsigned long)) != sizeof(unsigned long))
                   2924:        {
                   2925:            nanosleep(&attente, NULL);
                   2926:            INCR_GRANULARITE(attente.tv_nsec);
                   2927:        }
                   2928: 
                   2929:        attente.tv_sec = 0;
                   2930:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2931: 
                   2932:        while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
                   2933:                (*s_objet).objet)).nombre_colonnes),
                   2934:                sizeof(unsigned long)) != sizeof(unsigned long))
                   2935:        {
                   2936:            nanosleep(&attente, NULL);
                   2937:            INCR_GRANULARITE(attente.tv_nsec);
                   2938:        }
                   2939: 
                   2940:        if (((*((struct_matrice *) (*s_objet).objet)).tableau =
                   2941:                malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
                   2942:                sizeof(integer8 *))) == NULL)
                   2943:        {
                   2944:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2945:            return(NULL);
                   2946:        }
                   2947: 
                   2948:        for(i = 0; i < (*((struct_matrice *)
                   2949:                (*s_objet).objet)).nombre_lignes; i++)
                   2950:        {
                   2951:            if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
                   2952:                    malloc((*((struct_matrice *) (*s_objet).objet))
                   2953:                    .nombre_colonnes * sizeof(integer8))) == NULL)
                   2954:            {
                   2955:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2956:                return(NULL);
                   2957:            }
                   2958: 
                   2959:            for(j = 0; j < (*((struct_matrice *)
                   2960:                    (*s_objet).objet)).nombre_colonnes; j++)
                   2961:            {
                   2962:                attente.tv_sec = 0;
                   2963:                attente.tv_nsec = GRANULARITE_us * 1000;
                   2964: 
                   2965:                while(read_atomic(s_etat_processus,
                   2966:                        pipe, &(((integer8 **) (*((struct_matrice *)
                   2967:                        (*s_objet).objet)).tableau)[i][j]),
                   2968:                        sizeof(integer8)) != sizeof(integer8))
                   2969:                {
                   2970:                    nanosleep(&attente, NULL);
                   2971:                    INCR_GRANULARITE(attente.tv_nsec);
                   2972:                }
                   2973:            }
                   2974:        }
                   2975:    }
                   2976:    else if ((*s_objet).type == MRL)
                   2977:    {
                   2978:        if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
                   2979:        {
                   2980:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2981:            return(NULL);
                   2982:        }
                   2983: 
                   2984:        (*((struct_matrice *) (*s_objet).objet)).type = 'R';
                   2985: 
                   2986:        attente.tv_sec = 0;
                   2987:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2988: 
                   2989:        while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
                   2990:                (*s_objet).objet)).nombre_lignes),
                   2991:                sizeof(unsigned long)) != sizeof(unsigned long))
                   2992:        {
                   2993:            nanosleep(&attente, NULL);
                   2994:            INCR_GRANULARITE(attente.tv_nsec);
                   2995:        }
                   2996: 
                   2997:        attente.tv_sec = 0;
                   2998:        attente.tv_nsec = GRANULARITE_us * 1000;
                   2999: 
                   3000:        while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
                   3001:                (*s_objet).objet)).nombre_colonnes),
                   3002:                sizeof(unsigned long)) != sizeof(unsigned long))
                   3003:        {
                   3004:            nanosleep(&attente, NULL);
                   3005:            INCR_GRANULARITE(attente.tv_nsec);
                   3006:        }
                   3007: 
                   3008:        if (((*((struct_matrice *) (*s_objet).objet)).tableau =
                   3009:                malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
                   3010:                sizeof(real8 *))) == NULL)
                   3011:        {
                   3012:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3013:            return(NULL);
                   3014:        }
                   3015: 
                   3016:        for(i = 0; i < (*((struct_matrice *)
                   3017:                (*s_objet).objet)).nombre_lignes; i++)
                   3018:        {
                   3019:            if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
                   3020:                    malloc((*((struct_matrice *) (*s_objet).objet))
                   3021:                    .nombre_colonnes * sizeof(real8))) == NULL)
                   3022:            {
                   3023:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3024:                return(NULL);
                   3025:            }
                   3026: 
                   3027:            for(j = 0; j < (*((struct_matrice *)
                   3028:                    (*s_objet).objet)).nombre_colonnes; j++)
                   3029:            {
                   3030:                attente.tv_sec = 0;
                   3031:                attente.tv_nsec = GRANULARITE_us * 1000;
                   3032: 
                   3033:                while(read_atomic(s_etat_processus,
                   3034:                        pipe, &(((real8 **) (*((struct_matrice *)
                   3035:                        (*s_objet).objet)).tableau)[i][j]),
                   3036:                        sizeof(real8)) != sizeof(real8))
                   3037:                {
                   3038:                    nanosleep(&attente, NULL);
                   3039:                    INCR_GRANULARITE(attente.tv_nsec);
                   3040:                }
                   3041:            }
                   3042:        }
                   3043:    }
                   3044:    else if ((*s_objet).type == MCX)
                   3045:    {
                   3046:        if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
                   3047:        {
                   3048:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3049:            return(NULL);
                   3050:        }
                   3051: 
                   3052:        (*((struct_matrice *) (*s_objet).objet)).type = 'C';
                   3053: 
                   3054:        attente.tv_sec = 0;
                   3055:        attente.tv_nsec = GRANULARITE_us * 1000;
                   3056: 
                   3057:        while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
                   3058:                (*s_objet).objet)).nombre_lignes),
                   3059:                sizeof(unsigned long)) != sizeof(unsigned long))
                   3060:        {
                   3061:            nanosleep(&attente, NULL);
                   3062:            INCR_GRANULARITE(attente.tv_nsec);
                   3063:        }
                   3064: 
                   3065:        attente.tv_sec = 0;
                   3066:        attente.tv_nsec = GRANULARITE_us * 1000;
                   3067: 
                   3068:        while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
                   3069:                (*s_objet).objet)).nombre_colonnes),
                   3070:                sizeof(unsigned long)) != sizeof(unsigned long))
                   3071:        {
                   3072:            nanosleep(&attente, NULL);
                   3073:            INCR_GRANULARITE(attente.tv_nsec);
                   3074:        }
                   3075: 
                   3076:        if (((*((struct_matrice *) (*s_objet).objet)).tableau =
                   3077:                malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
                   3078:                sizeof(complex16 *))) == NULL)
                   3079:        {
                   3080:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3081:            return(NULL);
                   3082:        }
                   3083: 
                   3084:        for(i = 0; i < (*((struct_matrice *)
                   3085:                (*s_objet).objet)).nombre_lignes; i++)
                   3086:        {
                   3087:            if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
                   3088:                    malloc((*((struct_matrice *) (*s_objet).objet))
                   3089:                    .nombre_colonnes * sizeof(complex16))) == NULL)
                   3090:            {
                   3091:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3092:                return(NULL);
                   3093:            }
                   3094: 
                   3095:            for(j = 0; j < (*((struct_matrice *)
                   3096:                    (*s_objet).objet)).nombre_colonnes; j++)
                   3097:            {
                   3098:                attente.tv_sec = 0;
                   3099:                attente.tv_nsec = GRANULARITE_us * 1000;
                   3100: 
                   3101:                while(read_atomic(s_etat_processus, pipe,
                   3102:                        &(((complex16 **) (*((struct_matrice *)
                   3103:                        (*s_objet).objet)).tableau)[i][j]),
                   3104:                        sizeof(complex16)) != sizeof(complex16))
                   3105:                {
                   3106:                    nanosleep(&attente, NULL);
                   3107:                    INCR_GRANULARITE(attente.tv_nsec);
                   3108:                }
                   3109:            }
                   3110:        }
                   3111:    }
                   3112:    else if ((*s_objet).type == BIN)
                   3113:    {
                   3114:        if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
                   3115:        {
                   3116:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3117:            return(NULL);
                   3118:        }
                   3119: 
                   3120:        attente.tv_sec = 0;
                   3121:        attente.tv_nsec = GRANULARITE_us * 1000;
                   3122: 
                   3123:        while(read_atomic(s_etat_processus, pipe,
                   3124:                (*s_objet).objet, sizeof(integer8)) != sizeof(integer8))
                   3125:        {
                   3126:            nanosleep(&attente, NULL);
                   3127:            INCR_GRANULARITE(attente.tv_nsec);
                   3128:        }
                   3129:    }
                   3130:    else if ((*s_objet).type == NOM)
                   3131:    {
                   3132:        if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL)
                   3133:        {
                   3134:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3135:            return(NULL);
                   3136:        }
                   3137: 
                   3138:        attente.tv_sec = 0;
                   3139:        attente.tv_nsec = GRANULARITE_us * 1000;
                   3140: 
                   3141:        while(read_atomic(s_etat_processus,
                   3142:                pipe, &longueur, sizeof(size_t)) != sizeof(size_t))
                   3143:        {
                   3144:            nanosleep(&attente, NULL);
                   3145:            INCR_GRANULARITE(attente.tv_nsec);
                   3146:        }
                   3147: 
                   3148:        if (((*((struct_nom *) (*s_objet).objet)).nom = malloc(longueur *
                   3149:                sizeof(unsigned char))) == NULL)
                   3150:        {
                   3151:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3152:            return(NULL);
                   3153:        }
                   3154: 
                   3155:        attente.tv_sec = 0;
                   3156:        attente.tv_nsec = GRANULARITE_us * 1000;
                   3157: 
                   3158:        while(read_atomic(s_etat_processus, pipe, (*((struct_nom *)
                   3159:                (*s_objet).objet)).nom, longueur) != (ssize_t) longueur)
                   3160:        {
                   3161:            nanosleep(&attente, NULL);
                   3162:            INCR_GRANULARITE(attente.tv_nsec);
                   3163:        }
                   3164: 
                   3165:        attente.tv_sec = 0;
                   3166:        attente.tv_nsec = GRANULARITE_us * 1000;
                   3167: 
                   3168:        while(read_atomic(s_etat_processus, pipe,
                   3169:                &((*((struct_nom *) (*s_objet).objet)).symbole),
                   3170:                sizeof(logical1)) != sizeof(logical1))
                   3171:        {
                   3172:            nanosleep(&attente, NULL);
                   3173:            INCR_GRANULARITE(attente.tv_nsec);
                   3174:        }
                   3175:    }
                   3176:    else if ((*s_objet).type == FCT)
                   3177:    {
                   3178:        if (((*s_objet).objet = allocation(s_etat_processus, FCT)) == NULL)
                   3179:        {
                   3180:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3181:            return(NULL);
                   3182:        }
                   3183: 
                   3184:        attente.tv_sec = 0;
                   3185:        attente.tv_nsec = GRANULARITE_us * 1000;
                   3186: 
                   3187:        while(read_atomic(s_etat_processus, pipe,
                   3188:                &longueur, sizeof(size_t)) != sizeof(size_t))
                   3189:        {
                   3190:            nanosleep(&attente, NULL);
                   3191:            INCR_GRANULARITE(attente.tv_nsec);
                   3192:        }
                   3193: 
                   3194:        if (((*((struct_fonction *) (*s_objet).objet)).nom_fonction =
                   3195:                malloc(longueur * sizeof(unsigned char))) == NULL)
                   3196:        {
                   3197:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3198:            return(NULL);
                   3199:        }
                   3200: 
                   3201:        attente.tv_sec = 0;
                   3202:        attente.tv_nsec = GRANULARITE_us * 1000;
                   3203: 
                   3204:        while(read_atomic(s_etat_processus, pipe,
                   3205:                (*((struct_fonction *) (*s_objet).objet))
                   3206:                .nom_fonction, longueur) != (ssize_t) longueur)
                   3207:        {
                   3208:            nanosleep(&attente, NULL);
                   3209:            INCR_GRANULARITE(attente.tv_nsec);
                   3210:        }
                   3211: 
                   3212:        attente.tv_sec = 0;
                   3213:        attente.tv_nsec = GRANULARITE_us * 1000;
                   3214: 
                   3215:        while(read_atomic(s_etat_processus, pipe,
                   3216:                &((*((struct_fonction *) (*s_objet).objet))
                   3217:                .nombre_arguments), sizeof(unsigned long)) !=
                   3218:                sizeof(unsigned long))
                   3219:        {
                   3220:            nanosleep(&attente, NULL);
                   3221:            INCR_GRANULARITE(attente.tv_nsec);
                   3222:        }
                   3223: 
                   3224:        (*((struct_fonction *) (*s_objet).objet)).fonction = NULL;
                   3225:        (*((struct_fonction *) (*s_objet).objet)).prediction_saut = NULL;
                   3226:        (*((struct_fonction *) (*s_objet).objet)).prediction_execution = d_faux;
                   3227:    }
                   3228:    else if ((*s_objet).type == CHN)
                   3229:    {
                   3230:        attente.tv_sec = 0;
                   3231:        attente.tv_nsec = GRANULARITE_us * 1000;
                   3232: 
                   3233:        while(read_atomic(s_etat_processus, pipe,
                   3234:                &longueur, sizeof(size_t)) != sizeof(size_t))
                   3235:        {
                   3236:            nanosleep(&attente, NULL);
                   3237:            INCR_GRANULARITE(attente.tv_nsec);
                   3238:        }
                   3239: 
                   3240:        if (((*s_objet).objet = malloc(longueur *
                   3241:                sizeof(unsigned char))) == NULL)
                   3242:        {
                   3243:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3244:            return(NULL);
                   3245:        }
                   3246: 
                   3247:        attente.tv_sec = 0;
                   3248:        attente.tv_nsec = GRANULARITE_us * 1000;
                   3249: 
                   3250:        while(read_atomic(s_etat_processus, pipe, (unsigned char *)
                   3251:                (*s_objet).objet, longueur) != (ssize_t) longueur)
                   3252:        {
                   3253:            nanosleep(&attente, NULL);
                   3254:            INCR_GRANULARITE(attente.tv_nsec);
                   3255:        }
                   3256:    }
                   3257:    else if (((*s_objet).type == LST) ||
                   3258:            ((*s_objet).type == ALG) ||
                   3259:            ((*s_objet).type == RPN))
                   3260:    {
                   3261:        attente.tv_sec = 0;
                   3262:        attente.tv_nsec = GRANULARITE_us * 1000;
                   3263: 
                   3264:        while(read_atomic(s_etat_processus, pipe, &j, sizeof(j)) != sizeof(j))
                   3265:        {
                   3266:            nanosleep(&attente, NULL);
                   3267:            INCR_GRANULARITE(attente.tv_nsec);
                   3268:        }
                   3269: 
                   3270:        l_element_courant = NULL;
                   3271: 
                   3272:        for(i = 0; i < j; i++)
                   3273:        {
                   3274:            if (l_element_courant == NULL)
                   3275:            {
                   3276:                if ((l_element_courant =
                   3277:                        malloc(sizeof(struct_liste_chainee))) == NULL)
                   3278:                {
                   3279:                    (*s_etat_processus).erreur_systeme =
                   3280:                            d_es_allocation_memoire;
                   3281:                    return(NULL);
                   3282:                }
                   3283: 
                   3284:                (*s_objet).objet = l_element_courant;
                   3285:            }
                   3286:            else
                   3287:            {
                   3288:                if (((*l_element_courant).suivant =
                   3289:                        malloc(sizeof(struct_liste_chainee))) == NULL)
                   3290:                {
                   3291:                    (*s_etat_processus).erreur_systeme =
                   3292:                            d_es_allocation_memoire;
                   3293:                    return(NULL);
                   3294:                }
                   3295: 
                   3296:                l_element_courant = (*l_element_courant).suivant;
                   3297:                (*l_element_courant).suivant = NULL;
                   3298:            }
                   3299: 
                   3300:            attente.tv_sec = 0;
                   3301:            attente.tv_nsec = GRANULARITE_us * 1000;
                   3302: 
                   3303:            while(((*l_element_courant).donnee = lecture_pipe(s_etat_processus,
                   3304:                    pipe)) == NULL)
                   3305:            {
                   3306:                if ((*s_etat_processus).erreur_systeme != d_es)
                   3307:                {
                   3308:                    return(NULL);
                   3309:                }
                   3310: 
                   3311:                nanosleep(&attente, NULL);
                   3312:                INCR_GRANULARITE(attente.tv_nsec);
                   3313:            }
                   3314:        }
                   3315: 
                   3316:        if (l_element_courant == NULL)
                   3317:        {
                   3318:            (*s_objet).objet = NULL;
                   3319:        }
                   3320:        else
                   3321:        {
                   3322:            (*l_element_courant).suivant = NULL;
                   3323:        }
                   3324:    }
                   3325:    else if ((*s_objet).type == TBL)
                   3326:    {
                   3327:        if (((*s_objet).objet = malloc(sizeof(struct_tableau))) == NULL)
                   3328:        {
                   3329:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3330:            return(NULL);
                   3331:        }
                   3332: 
                   3333:        attente.tv_sec = 0;
                   3334:        attente.tv_nsec = GRANULARITE_us * 1000;
                   3335: 
                   3336:        while(read_atomic(s_etat_processus, pipe, &((*((struct_tableau *)
                   3337:                (*s_objet).objet)).nombre_elements),
                   3338:                sizeof(unsigned long)) != sizeof(unsigned long))
                   3339:        {
                   3340:            nanosleep(&attente, NULL);
                   3341:            INCR_GRANULARITE(attente.tv_nsec);
                   3342:        }
                   3343: 
                   3344:        if (((*((struct_tableau *) (*s_objet).objet)).elements = malloc(
                   3345:                (*((struct_tableau *) (*s_objet).objet)).nombre_elements *
                   3346:                sizeof(struct_objet *))) == NULL)
                   3347:        {
                   3348:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3349:            return(NULL);
                   3350:        }
                   3351: 
                   3352:        for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)).nombre_elements;
                   3353:                i++)
                   3354:        {
                   3355:            attente.tv_sec = 0;
                   3356:            attente.tv_nsec = GRANULARITE_us * 1000;
                   3357: 
                   3358:            while(((*((struct_tableau *) (*s_objet).objet)).elements[i] =
                   3359:                    lecture_pipe(s_etat_processus, pipe)) == NULL)
                   3360:            {
                   3361:                if ((*s_etat_processus).erreur_systeme != d_es)
                   3362:                {
                   3363:                    return(NULL);
                   3364:                }
                   3365: 
                   3366:                nanosleep(&attente, NULL);
                   3367:                INCR_GRANULARITE(attente.tv_nsec);
                   3368:            }
                   3369:        }
                   3370:    }
                   3371: 
                   3372:    return(s_objet);
                   3373: }
                   3374: 
                   3375: 
                   3376: /*
                   3377: ================================================================================
                   3378:   Fonction de scrutation des données injectées par le processus père
                   3379: ================================================================================
                   3380:   Entrées : pointeur sur une structure
                   3381: --------------------------------------------------------------------------------
                   3382:   Sorties :
                   3383: --------------------------------------------------------------------------------
                   3384:   Effets de bord : néant
                   3385: ================================================================================
                   3386: */
                   3387: 
1.10      bertrand 3388: extern inline void
1.1       bertrand 3389: scrutation_injection(struct_processus *s_etat_processus)
                   3390: {
                   3391:    fd_set                          ensemble_descripteurs;
                   3392: 
1.7       bertrand 3393: #  ifndef OpenBSD
                   3394:        struct timespec             timeout;
                   3395: #  else
                   3396:        struct timeval              timeout;
                   3397: #  endif
1.1       bertrand 3398: 
                   3399:    unsigned char                   tampon;
                   3400: 
                   3401:    // Si on est dans le processus père, il n'y a rien à surveiller.
                   3402: 
                   3403:    if ((*s_etat_processus).var_volatile_processus_pere == 0)
                   3404:    {
                   3405:        FD_ZERO(&ensemble_descripteurs);
                   3406:        FD_SET((*s_etat_processus).pipe_nombre_injections,
                   3407:                &ensemble_descripteurs);
                   3408: 
1.7       bertrand 3409: #      ifndef OpenBSD
1.1       bertrand 3410:        timeout.tv_sec = 0;
                   3411:        timeout.tv_nsec = 0;
                   3412: 
                   3413:        if (pselect((*s_etat_processus).pipe_nombre_injections + 1,
                   3414:                &ensemble_descripteurs, NULL, NULL, &timeout, NULL) > 0)
1.7       bertrand 3415: #      else
                   3416:        timeout.tv_sec = 0;
                   3417:        timeout.tv_usec = 0;
                   3418: 
                   3419:        if (select((*s_etat_processus).pipe_nombre_injections + 1,
                   3420:                &ensemble_descripteurs, NULL, NULL, &timeout) > 0)
                   3421: #      endif
1.1       bertrand 3422:        {
                   3423:            if (read_atomic(s_etat_processus,
                   3424:                    (*s_etat_processus).pipe_nombre_injections,
                   3425:                    &tampon, sizeof(unsigned char)) == sizeof(unsigned char))
                   3426:            {
                   3427:                if (tampon == '-')
                   3428:                {
                   3429:                    (*s_etat_processus).nombre_objets_injectes++;
                   3430:                }
                   3431:                else if (tampon == '+')
                   3432:                {
                   3433:                    (*s_etat_processus).nombre_objets_envoyes_non_lus--;
                   3434: 
                   3435:                    BUG((*s_etat_processus).nombre_objets_envoyes_non_lus < 0,
                   3436:                            printf("(*s_etat_processus).nombre_objets_envoyes_"
                   3437:                            "non_lus=%d\n", (*s_etat_processus)
                   3438:                            .nombre_objets_envoyes_non_lus));
                   3439:                }
                   3440:                else
                   3441:                {
                   3442:                    BUG(1, printf("tampon='%c' (%d)\n", tampon, tampon));
                   3443:                }
                   3444:            }
                   3445:        }
                   3446:    }
                   3447: 
                   3448:    return;
                   3449: }
                   3450: 
                   3451: 
                   3452: /*
                   3453: ================================================================================
1.9       bertrand 3454:   Fonction de test du drapeau d'arrêt
1.1       bertrand 3455: ================================================================================
                   3456:   Entrées : pointeur sur une structure
                   3457: --------------------------------------------------------------------------------
                   3458:   Sorties :
                   3459: --------------------------------------------------------------------------------
                   3460:   Effets de bord : néant
                   3461: ================================================================================
                   3462: */
                   3463: 
                   3464: inline int test_arret(struct_processus *s_etat_processus)
                   3465: {
                   3466:    return((int) (*s_etat_processus).var_volatile_requete_arret);
                   3467: }
                   3468: 
                   3469: // vim: ts=4

CVSweb interface <joel.bertrand@systella.fr>