Annotation of rpl/src/interruptions.c, revision 1.92

1.1       bertrand    1: /*
                      2: ================================================================================
1.92    ! bertrand    3:   RPL/2 (R) version 4.1.7
1.90      bertrand    4:   Copyright (C) 1989-2012 Dr. BERTRAND Joël
1.1       bertrand    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: 
1.27      bertrand   23: #include "rpl-conv.h"
1.1       bertrand   24: 
                     25: 
                     26: /*
                     27: ================================================================================
                     28:   Procédures de gestion par thread des variables issues des gestionnaires
                     29:   de signaux
                     30: ================================================================================
                     31:   Entrée : variable globale
                     32: --------------------------------------------------------------------------------
                     33:   Sortie : variable globale modifiée
                     34: --------------------------------------------------------------------------------
                     35:   Effets de bord : néant
                     36: ================================================================================
                     37: */
                     38: 
                     39: typedef struct thread
                     40: {
                     41:    pid_t               pid;
                     42:    pthread_t           tid;
                     43: 
                     44:    logical1            thread_principal;
                     45: 
                     46:    struct_processus    *s_etat_processus;
                     47: } struct_thread;
                     48: 
                     49: typedef struct liste_chainee_volatile
                     50: {
                     51:    volatile struct liste_chainee_volatile  *suivant;
                     52:    volatile void                           *donnee;
                     53: } struct_liste_chainee_volatile;
                     54: 
                     55: 
                     56: static volatile struct_liste_chainee_volatile  *liste_threads
                     57:        = NULL;
                     58: static volatile struct_liste_chainee_volatile  *liste_threads_surveillance
                     59:        = NULL;
1.68      bertrand   60: static volatile int                                code_erreur_gsl = 0;
                     61: 
1.75      bertrand   62: unsigned char                                  *racine_segment;
1.69      bertrand   63: 
1.68      bertrand   64: static pthread_mutex_t                         mutex_interruptions
                     65:        = PTHREAD_MUTEX_INITIALIZER;
1.1       bertrand   66: 
                     67: void
                     68: modification_pid_thread_pere(struct_processus *s_etat_processus)
                     69: {
                     70:    // La variable existe toujours et aucun thread concurrent ne peut
                     71:    // la modifier puisque cette routine ne peut être appelée que depuis
                     72:    // DAEMON.
                     73: 
                     74:    (*((struct_thread *) (*liste_threads).donnee)).pid =
                     75:            (*s_etat_processus).pid_processus_pere;
                     76: 
                     77:    return;
                     78: }
                     79: 
                     80: void
                     81: insertion_thread(struct_processus *s_etat_processus, logical1 thread_principal)
                     82: {
                     83:    volatile struct_liste_chainee_volatile      *l_nouvel_objet;
                     84: 
                     85:    if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
                     86:            == NULL)
                     87:    {
                     88:        (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                     89:        return;
                     90:    }
                     91: 
                     92:    if (((*l_nouvel_objet).donnee = malloc(sizeof(struct_thread))) == NULL)
                     93:    {
                     94:        (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                     95:        return;
                     96:    }
                     97: 
                     98:    (*((struct_thread *) (*l_nouvel_objet).donnee)).pid = getpid();
                     99:    (*((struct_thread *) (*l_nouvel_objet).donnee)).tid = pthread_self();
                    100:    (*((struct_thread *) (*l_nouvel_objet).donnee)).thread_principal =
                    101:            thread_principal;
                    102:    (*((struct_thread *) (*l_nouvel_objet).donnee)).s_etat_processus =
                    103:            s_etat_processus;
                    104: 
1.68      bertrand  105:    if (pthread_mutex_lock(&mutex_liste_threads) != 0)
1.13      bertrand  106:    {
1.68      bertrand  107:        (*s_etat_processus).erreur_systeme = d_es_processus;
                    108:        return;
1.13      bertrand  109:    }
                    110: 
                    111:    (*l_nouvel_objet).suivant = liste_threads;
1.1       bertrand  112:    liste_threads = l_nouvel_objet;
                    113: 
1.68      bertrand  114:    if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
1.1       bertrand  115:    {
                    116:        (*s_etat_processus).erreur_systeme = d_es_processus;
                    117:        return;
                    118:    }
                    119: 
                    120:    return;
                    121: }
                    122: 
                    123: void
                    124: insertion_thread_surveillance(struct_processus *s_etat_processus,
                    125:        struct_descripteur_thread *s_argument_thread)
                    126: {
                    127:    volatile struct_liste_chainee_volatile      *l_nouvel_objet;
                    128: 
1.13      bertrand  129:    if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
                    130:            == NULL)
                    131:    {
                    132:        (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    133:        return;
                    134:    }
                    135: 
1.68      bertrand  136:    if (pthread_mutex_lock(&mutex_liste_threads) != 0)
1.1       bertrand  137:    {
1.68      bertrand  138:        (*s_etat_processus).erreur_systeme = d_es_processus;
                    139:        return;
1.1       bertrand  140:    }
                    141: 
1.40      bertrand  142:    pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references));
1.21      bertrand  143:    (*s_argument_thread).nombre_references++;
1.40      bertrand  144:    pthread_mutex_unlock(&((*s_argument_thread).mutex_nombre_references));
1.22      bertrand  145: 
1.1       bertrand  146:    (*l_nouvel_objet).suivant = liste_threads_surveillance;
                    147:    (*l_nouvel_objet).donnee = (void *) s_argument_thread;
                    148: 
                    149:    liste_threads_surveillance = l_nouvel_objet;
                    150: 
1.68      bertrand  151:    if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
1.1       bertrand  152:    {
                    153:        (*s_etat_processus).erreur_systeme = d_es_processus;
                    154:        return;
                    155:    }
                    156: 
                    157:    return;
                    158: }
                    159: 
                    160: void
                    161: retrait_thread(struct_processus *s_etat_processus)
                    162: {
                    163:    volatile struct_liste_chainee_volatile  *l_element_precedent;
                    164:    volatile struct_liste_chainee_volatile  *l_element_courant;
                    165: 
1.68      bertrand  166:    if (pthread_mutex_lock(&mutex_liste_threads) != 0)
1.1       bertrand  167:    {
1.68      bertrand  168:        (*s_etat_processus).erreur_systeme = d_es_processus;
                    169:        return;
1.1       bertrand  170:    }
                    171: 
                    172:    l_element_precedent = NULL;
                    173:    l_element_courant = liste_threads;
                    174: 
                    175:    while(l_element_courant != NULL)
                    176:    {
                    177:        if (((*((struct_thread *) (*l_element_courant).donnee)).pid
                    178:                == getpid()) && (pthread_equal((*((struct_thread *)
                    179:                (*l_element_courant).donnee)).tid, pthread_self()) != 0))
                    180:        {
                    181:            break;
                    182:        }
                    183: 
                    184:        l_element_precedent = l_element_courant;
                    185:        l_element_courant = (*l_element_courant).suivant;
                    186:    }
                    187: 
                    188:    if (l_element_courant == NULL)
                    189:    {
1.68      bertrand  190:        pthread_mutex_unlock(&mutex_liste_threads);
1.1       bertrand  191:        (*s_etat_processus).erreur_systeme = d_es_processus;
                    192:        return;
                    193:    }
                    194: 
                    195:    if (l_element_precedent == NULL)
                    196:    {
                    197:        liste_threads = (*l_element_courant).suivant;
                    198:    }
                    199:    else
                    200:    {
                    201:        (*l_element_precedent).suivant = (*l_element_courant).suivant;
                    202:    }
                    203: 
1.68      bertrand  204:    if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
1.1       bertrand  205:    {
                    206:        (*s_etat_processus).erreur_systeme = d_es_processus;
                    207:        return;
                    208:    }
                    209: 
1.13      bertrand  210:    free((void *) (*l_element_courant).donnee);
                    211:    free((struct_liste_chainee_volatile *) l_element_courant);
                    212: 
1.1       bertrand  213:    return;
                    214: }
                    215: 
                    216: void
                    217: retrait_thread_surveillance(struct_processus *s_etat_processus,
                    218:        struct_descripteur_thread *s_argument_thread)
                    219: {
                    220:    volatile struct_liste_chainee_volatile  *l_element_precedent;
                    221:    volatile struct_liste_chainee_volatile  *l_element_courant;
                    222: 
1.68      bertrand  223:    if (pthread_mutex_lock(&mutex_liste_threads) != 0)
1.1       bertrand  224:    {
1.68      bertrand  225:        (*s_etat_processus).erreur_systeme = d_es_processus;
                    226:        return;
1.1       bertrand  227:    }
                    228: 
                    229:    l_element_precedent = NULL;
                    230:    l_element_courant = liste_threads_surveillance;
                    231: 
                    232:    while(l_element_courant != NULL)
                    233:    {
                    234:        if ((*l_element_courant).donnee == (void *) s_argument_thread)
                    235:        {
                    236:            break;
                    237:        }
                    238: 
                    239:        l_element_precedent = l_element_courant;
                    240:        l_element_courant = (*l_element_courant).suivant;
                    241:    }
                    242: 
                    243:    if (l_element_courant == NULL)
                    244:    {
1.68      bertrand  245:        pthread_mutex_unlock(&mutex_liste_threads);
1.1       bertrand  246:        (*s_etat_processus).erreur_systeme = d_es_processus;
                    247:        return;
                    248:    }
                    249: 
                    250:    if (l_element_precedent == NULL)
                    251:    {
                    252:        liste_threads_surveillance = (*l_element_courant).suivant;
                    253:    }
                    254:    else
                    255:    {
                    256:        (*l_element_precedent).suivant = (*l_element_courant).suivant;
                    257:    }
                    258: 
1.40      bertrand  259:    if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references))
                    260:            != 0)
1.1       bertrand  261:    {
1.68      bertrand  262:        pthread_mutex_unlock(&mutex_liste_threads);
1.1       bertrand  263:        (*s_etat_processus).erreur_systeme = d_es_processus;
                    264:        return;
                    265:    }
                    266: 
                    267:    (*s_argument_thread).nombre_references--;
                    268: 
                    269:    BUG((*s_argument_thread).nombre_references < 0,
                    270:            printf("(*s_argument_thread).nombre_references = %d\n",
                    271:            (int) (*s_argument_thread).nombre_references));
                    272: 
                    273:    if ((*s_argument_thread).nombre_references == 0)
                    274:    {
1.40      bertrand  275:        if (pthread_mutex_unlock(&((*s_argument_thread)
                    276:                .mutex_nombre_references)) != 0)
1.1       bertrand  277:        {
1.68      bertrand  278:            pthread_mutex_unlock(&mutex_liste_threads);
1.1       bertrand  279:            (*s_etat_processus).erreur_systeme = d_es_processus;
                    280:            return;
                    281:        }
                    282: 
                    283:        pthread_mutex_destroy(&((*s_argument_thread).mutex));
1.40      bertrand  284:        pthread_mutex_destroy(&((*s_argument_thread).mutex_nombre_references));
1.1       bertrand  285:        free(s_argument_thread);
                    286:    }
                    287:    else
                    288:    {
1.40      bertrand  289:        if (pthread_mutex_unlock(&((*s_argument_thread)
                    290:                .mutex_nombre_references)) != 0)
1.1       bertrand  291:        {
1.68      bertrand  292:            pthread_mutex_unlock(&mutex_liste_threads);
1.1       bertrand  293:            (*s_etat_processus).erreur_systeme = d_es_processus;
                    294:            return;
                    295:        }
                    296:    }
                    297: 
1.68      bertrand  298:    if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
1.1       bertrand  299:    {
                    300:        (*s_etat_processus).erreur_systeme = d_es_processus;
                    301:        return;
                    302:    }
                    303: 
1.13      bertrand  304:    free((struct_liste_chainee_volatile *) l_element_courant);
1.1       bertrand  305:    return;
                    306: }
                    307: 
                    308: void
                    309: verrouillage_threads_concurrents(struct_processus *s_etat_processus)
                    310: {
                    311:    volatile struct_liste_chainee_volatile  *l_element_courant;
                    312: 
1.68      bertrand  313:    if (pthread_mutex_lock(&mutex_liste_threads) != 0)
1.1       bertrand  314:    {
1.68      bertrand  315:        (*s_etat_processus).erreur_systeme = d_es_processus;
                    316:        return;
1.1       bertrand  317:    }
                    318: 
                    319:    l_element_courant = liste_threads;
                    320: 
                    321:    while(l_element_courant != NULL)
                    322:    {
                    323:        if (((*((struct_thread *) (*l_element_courant).donnee)).pid
                    324:                == getpid()) && (pthread_equal((*((struct_thread *)
                    325:                (*l_element_courant).donnee)).tid, pthread_self()) == 0))
                    326:        {
1.79      bertrand  327: #          ifndef SEMAPHORES_NOMMES
                    328:                while(sem_wait(&((*(*((struct_thread *) (*l_element_courant)
                    329:                        .donnee)).s_etat_processus).semaphore_fork)) == -1)
                    330: #          else
                    331:                while(sem_wait((*(*((struct_thread *) (*l_element_courant)
                    332:                        .donnee)).s_etat_processus).semaphore_fork) == -1)
                    333: #          endif
1.1       bertrand  334:            {
1.68      bertrand  335:                (*s_etat_processus).erreur_systeme = d_es_processus;
                    336:                return;
1.1       bertrand  337:            }
                    338:        }
                    339: 
                    340:        l_element_courant = (*l_element_courant).suivant;
                    341:    }
                    342: 
                    343:    return;
                    344: }
                    345: 
                    346: void
                    347: deverrouillage_threads_concurrents(struct_processus *s_etat_processus)
                    348: {
                    349:    volatile struct_liste_chainee_volatile  *l_element_courant;
                    350: 
                    351:    l_element_courant = liste_threads;
                    352: 
                    353:    while(l_element_courant != NULL)
                    354:    {
                    355:        if (((*((struct_thread *) (*l_element_courant).donnee)).pid
                    356:                == getpid()) && (pthread_equal((*((struct_thread *)
                    357:                (*l_element_courant).donnee)).tid, pthread_self()) == 0))
                    358:        {
1.79      bertrand  359: #          ifndef SEMAPHORES_NOMMES
                    360:                if (sem_post(&((*(*((struct_thread *)
                    361:                        (*l_element_courant).donnee)).s_etat_processus)
                    362:                        .semaphore_fork)) != 0)
                    363: #          else
                    364:                if (sem_post((*(*((struct_thread *)
                    365:                        (*l_element_courant).donnee)).s_etat_processus)
                    366:                        .semaphore_fork) != 0)
                    367: #          endif
1.1       bertrand  368:            {
1.68      bertrand  369:                if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
1.8       bertrand  370:                {
                    371:                    (*s_etat_processus).erreur_systeme = d_es_processus;
                    372:                    return;
                    373:                }
1.1       bertrand  374: 
                    375:                (*s_etat_processus).erreur_systeme = d_es_processus;
                    376:                return;
                    377:            }
                    378:        }
                    379: 
                    380:        l_element_courant = (*l_element_courant).suivant;
                    381:    }
                    382: 
1.68      bertrand  383:    if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
1.1       bertrand  384:    {
                    385:        (*s_etat_processus).erreur_systeme = d_es_processus;
                    386:        return;
                    387:    }
                    388: 
                    389:    return;
                    390: }
                    391: 
                    392: void
                    393: liberation_threads(struct_processus *s_etat_processus)
                    394: {
                    395:    logical1                                    suppression_variables_partagees;
                    396: 
                    397:    struct_descripteur_thread                   *s_argument_thread;
                    398: 
                    399:    struct_processus                            *candidat;
                    400: 
                    401:    unsigned long                               i;
                    402: 
                    403:    void                                        *element_candidat;
                    404:    void                                        *element_courant;
                    405:    void                                        *element_suivant;
                    406: 
                    407:    volatile struct_liste_chainee_volatile      *l_element_courant;
                    408:    volatile struct_liste_chainee_volatile      *l_element_suivant;
                    409: 
1.68      bertrand  410:    if (pthread_mutex_lock(&mutex_liste_threads) == -1)
1.1       bertrand  411:    {
1.68      bertrand  412:        (*s_etat_processus).erreur_systeme = d_es_processus;
                    413:        return;
1.1       bertrand  414:    }
                    415: 
                    416:    l_element_courant = liste_threads;
                    417:    suppression_variables_partagees = d_faux;
                    418: 
                    419:    while(l_element_courant != NULL)
                    420:    {
                    421:        if ((*((struct_thread *) (*l_element_courant).donnee)).s_etat_processus
                    422:                != s_etat_processus)
                    423:        {
                    424:            candidat = s_etat_processus;
                    425:            s_etat_processus = (*((struct_thread *)
                    426:                    (*l_element_courant).donnee)).s_etat_processus;
                    427:            free((*s_etat_processus).localisation);
                    428: 
                    429:            // (*s_etat_processus).instruction_courante peut pointer sur
                    430:            // n'importe quoi (une instruction courante ou un champ d'une
                    431:            // structure objet). On ne le libère pas quitte à avoir une
                    432:            // petite fuite mémoire dans le processus fils.
                    433: 
                    434:            if ((*s_etat_processus).instruction_courante != NULL)
                    435:            {
                    436:                //free((*s_etat_processus).instruction_courante);
                    437:            }
                    438: 
                    439:            close((*s_etat_processus).pipe_acquittement);
                    440:            close((*s_etat_processus).pipe_donnees);
                    441:            close((*s_etat_processus).pipe_injections);
                    442:            close((*s_etat_processus).pipe_nombre_injections);
                    443:            close((*s_etat_processus).pipe_interruptions);
                    444:            close((*s_etat_processus).pipe_nombre_objets_attente);
                    445:            close((*s_etat_processus).pipe_nombre_interruptions_attente);
                    446: 
1.13      bertrand  447:            liberation(s_etat_processus, (*s_etat_processus).at_exit);
                    448: 
1.1       bertrand  449:            if ((*s_etat_processus).nom_fichier_impression != NULL)
                    450:            {
                    451:                free((*s_etat_processus).nom_fichier_impression);
                    452:            }
                    453: 
                    454:            while((*s_etat_processus).fichiers_graphiques != NULL)
                    455:            {
                    456:                free((*(*s_etat_processus).fichiers_graphiques).nom);
                    457: 
                    458:                if ((*(*s_etat_processus).fichiers_graphiques).legende != NULL)
                    459:                {
                    460:                    free((*(*s_etat_processus).fichiers_graphiques).legende);
                    461:                }
                    462: 
                    463:                element_courant = (*s_etat_processus).fichiers_graphiques;
                    464:                (*s_etat_processus).fichiers_graphiques =
                    465:                        (*(*s_etat_processus).fichiers_graphiques).suivant;
                    466: 
                    467:                free(element_courant);
                    468:            }
                    469: 
                    470:            if ((*s_etat_processus).entree_standard != NULL)
                    471:            {
                    472:                pclose((*s_etat_processus).entree_standard);
                    473:            }
                    474: 
                    475:            if ((*s_etat_processus).generateur_aleatoire != NULL)
                    476:            {
                    477:                liberation_generateur_aleatoire(s_etat_processus);
                    478:            }
                    479: 
                    480:            if ((*s_etat_processus).instruction_derniere_erreur != NULL)
                    481:            {
                    482:                free((*s_etat_processus).instruction_derniere_erreur);
                    483:                (*s_etat_processus).instruction_derniere_erreur = NULL;
                    484:            }
                    485: 
                    486:            element_courant = (void *) (*s_etat_processus)
                    487:                    .l_base_pile_processus;
                    488:            while(element_courant != NULL)
                    489:            {
1.20      bertrand  490:                s_argument_thread = (struct_descripteur_thread *)
                    491:                        (*((struct_liste_chainee *) element_courant)).donnee;
                    492: 
1.40      bertrand  493:                if (pthread_mutex_lock(&((*s_argument_thread)
                    494:                        .mutex_nombre_references)) != 0)
1.20      bertrand  495:                {
                    496:                    (*s_etat_processus).erreur_systeme = d_es_processus;
1.68      bertrand  497:                    pthread_mutex_unlock(&mutex_liste_threads);
1.20      bertrand  498:                    return;
                    499:                }
                    500: 
                    501:                (*s_argument_thread).nombre_references--;
                    502: 
                    503:                BUG((*s_argument_thread).nombre_references < 0,
                    504:                        printf("(*s_argument_thread).nombre_references = %d\n",
                    505:                        (int) (*s_argument_thread).nombre_references));
                    506: 
                    507:                if ((*s_argument_thread).nombre_references == 0)
                    508:                {
                    509:                    close((*s_argument_thread).pipe_objets[0]);
                    510:                    close((*s_argument_thread).pipe_acquittement[1]);
                    511:                    close((*s_argument_thread).pipe_injections[1]);
                    512:                    close((*s_argument_thread).pipe_nombre_injections[1]);
                    513:                    close((*s_argument_thread).pipe_nombre_objets_attente[0]);
                    514:                    close((*s_argument_thread).pipe_interruptions[0]);
                    515:                    close((*s_argument_thread)
                    516:                            .pipe_nombre_interruptions_attente[0]);
                    517: 
1.40      bertrand  518:                    if (pthread_mutex_unlock(&((*s_argument_thread)
                    519:                            .mutex_nombre_references)) != 0)
1.20      bertrand  520:                    {
                    521:                        (*s_etat_processus).erreur_systeme = d_es_processus;
1.68      bertrand  522:                        pthread_mutex_unlock(&mutex_liste_threads);
1.20      bertrand  523:                        return;
                    524:                    }
                    525: 
                    526:                    pthread_mutex_destroy(&((*s_argument_thread).mutex));
1.40      bertrand  527:                    pthread_mutex_destroy(&((*s_argument_thread)
                    528:                            .mutex_nombre_references));
1.20      bertrand  529: 
                    530:                    if ((*s_argument_thread).processus_detache == d_faux)
                    531:                    {
                    532:                        if ((*s_argument_thread).destruction_objet == d_vrai)
                    533:                        {
                    534:                            liberation(s_etat_processus, (*s_argument_thread)
                    535:                                    .argument);
                    536:                        }
                    537:                    }
                    538: 
                    539:                    free(s_argument_thread);
                    540:                }
                    541:                else
                    542:                {
1.40      bertrand  543:                    if (pthread_mutex_unlock(&((*s_argument_thread)
                    544:                            .mutex_nombre_references)) != 0)
1.20      bertrand  545:                    {
                    546:                        (*s_etat_processus).erreur_systeme = d_es_processus;
1.68      bertrand  547:                        pthread_mutex_unlock(&mutex_liste_threads);
1.20      bertrand  548:                        return;
                    549:                    }
                    550:                }
                    551: 
1.1       bertrand  552:                element_suivant = (*((struct_liste_chainee *) element_courant))
                    553:                        .suivant;
1.20      bertrand  554:                free(element_courant);
1.1       bertrand  555:                element_courant = element_suivant;
                    556:            }
                    557: 
1.20      bertrand  558:            (*s_etat_processus).l_base_pile_processus = NULL;
                    559: 
1.1       bertrand  560:            pthread_mutex_trylock(&((*(*s_etat_processus).indep).mutex));
                    561:            pthread_mutex_unlock(&((*(*s_etat_processus).indep).mutex));
                    562:            liberation(s_etat_processus, (*s_etat_processus).indep);
                    563: 
                    564:            pthread_mutex_trylock(&((*(*s_etat_processus).depend).mutex));
                    565:            pthread_mutex_unlock(&((*(*s_etat_processus).depend).mutex));
                    566:            liberation(s_etat_processus, (*s_etat_processus).depend);
                    567: 
                    568:            free((*s_etat_processus).label_x);
                    569:            free((*s_etat_processus).label_y);
                    570:            free((*s_etat_processus).label_z);
                    571:            free((*s_etat_processus).titre);
                    572:            free((*s_etat_processus).legende);
                    573: 
                    574:            pthread_mutex_trylock(&((*(*s_etat_processus)
                    575:                    .parametres_courbes_de_niveau).mutex));
                    576:            pthread_mutex_unlock(&((*(*s_etat_processus)
                    577:                    .parametres_courbes_de_niveau).mutex));
                    578:            liberation(s_etat_processus, (*s_etat_processus)
                    579:                    .parametres_courbes_de_niveau);
                    580: 
                    581:            for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
                    582:            {
                    583:                if ((*s_etat_processus).corps_interruptions[i] != NULL)
                    584:                {
                    585:                    pthread_mutex_trylock(&((*(*s_etat_processus)
                    586:                            .corps_interruptions[i]).mutex));
                    587:                    pthread_mutex_unlock(&((*(*s_etat_processus)
                    588:                            .corps_interruptions[i]).mutex));
                    589: 
                    590:                    liberation(s_etat_processus,
                    591:                            (*s_etat_processus).corps_interruptions[i]);
                    592:                }
                    593: 
                    594:                element_courant = (*s_etat_processus)
                    595:                        .pile_origine_interruptions[i];
                    596: 
                    597:                while(element_courant != NULL)
                    598:                {
                    599:                    element_suivant = (*((struct_liste_chainee *)
                    600:                            element_courant)).suivant;
                    601: 
                    602:                    pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
                    603:                            element_courant)).donnee).mutex));
                    604:                    pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
                    605:                            element_courant)).donnee).mutex));
                    606: 
                    607:                    liberation(s_etat_processus,
                    608:                            (*((struct_liste_chainee *) element_courant))
                    609:                            .donnee);
                    610:                    free(element_courant);
                    611: 
                    612:                    element_courant = element_suivant;
                    613:                }
                    614:            }
                    615: 
1.52      bertrand  616:            liberation_arbre_variables(s_etat_processus,
                    617:                    (*s_etat_processus).s_arbre_variables, d_faux);
1.1       bertrand  618: 
                    619:            for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
                    620:            {
                    621:                pthread_mutex_trylock(&((*(*s_etat_processus)
                    622:                        .s_liste_variables_statiques[i].objet).mutex));
                    623:                pthread_mutex_unlock(&((*(*s_etat_processus)
                    624:                        .s_liste_variables_statiques[i].objet).mutex));
                    625: 
                    626:                liberation(s_etat_processus, (*s_etat_processus)
                    627:                        .s_liste_variables_statiques[i].objet);
                    628:                free((*s_etat_processus).s_liste_variables_statiques[i].nom);
                    629:            }
                    630: 
                    631:            free((*s_etat_processus).s_liste_variables_statiques);
                    632: 
                    633:            // Ne peut être effacé qu'une seule fois
                    634:            if (suppression_variables_partagees == d_faux)
                    635:            {
                    636:                suppression_variables_partagees = d_vrai;
                    637: 
                    638:                for(i = 0; i < (*(*s_etat_processus)
                    639:                        .s_liste_variables_partagees).nombre_variables; i++)
                    640:                {
                    641:                    pthread_mutex_trylock(&((*(*(*s_etat_processus)
                    642:                            .s_liste_variables_partagees).table[i].objet)
                    643:                            .mutex));
                    644:                    pthread_mutex_unlock(&((*(*(*s_etat_processus)
                    645:                            .s_liste_variables_partagees).table[i].objet)
                    646:                            .mutex));
                    647: 
                    648:                    liberation(s_etat_processus, (*(*s_etat_processus)
                    649:                            .s_liste_variables_partagees).table[i].objet);
                    650:                    free((*(*s_etat_processus).s_liste_variables_partagees)
                    651:                            .table[i].nom);
                    652:                }
                    653: 
                    654:                if ((*(*s_etat_processus).s_liste_variables_partagees).table
                    655:                        != NULL)
                    656:                {
                    657:                    free((struct_variable_partagee *) (*(*s_etat_processus)
                    658:                            .s_liste_variables_partagees).table);
                    659:                }
                    660: 
                    661:                pthread_mutex_trylock(&((*(*s_etat_processus)
                    662:                        .s_liste_variables_partagees).mutex));
                    663:                pthread_mutex_unlock(&((*(*s_etat_processus)
                    664:                        .s_liste_variables_partagees).mutex));
                    665:            }
                    666: 
                    667:            element_courant = (*s_etat_processus).l_base_pile;
                    668:            while(element_courant != NULL)
                    669:            {
                    670:                element_suivant = (*((struct_liste_chainee *)
                    671:                        element_courant)).suivant;
                    672: 
                    673:                pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
                    674:                        element_courant)).donnee).mutex));
                    675:                pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
                    676:                        element_courant)).donnee).mutex));
                    677: 
                    678:                liberation(s_etat_processus,
                    679:                        (*((struct_liste_chainee *)
                    680:                        element_courant)).donnee);
                    681:                free((struct_liste_chainee *) element_courant);
                    682: 
                    683:                element_courant = element_suivant;
                    684:            }
                    685: 
                    686:            element_courant = (*s_etat_processus).l_base_pile_contextes;
                    687:            while(element_courant != NULL)
                    688:            {
                    689:                element_suivant = (*((struct_liste_chainee *)
                    690:                        element_courant)).suivant;
                    691: 
                    692:                pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
                    693:                        element_courant)).donnee).mutex));
                    694:                pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
                    695:                        element_courant)).donnee).mutex));
                    696:                liberation(s_etat_processus, (*((struct_liste_chainee *)
                    697:                        element_courant)).donnee);
                    698:                free((struct_liste_chainee *) element_courant);
                    699: 
                    700:                element_courant = element_suivant;
                    701:            }
                    702: 
                    703:            element_courant = (*s_etat_processus).l_base_pile_taille_contextes;
                    704:            while(element_courant != NULL)
                    705:            {
                    706:                element_suivant = (*((struct_liste_chainee *)
                    707:                        element_courant)).suivant;
                    708: 
                    709:                pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
                    710:                        element_courant)).donnee).mutex));
                    711:                pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
                    712:                        element_courant)).donnee).mutex));
                    713:                liberation(s_etat_processus,
                    714:                        (*((struct_liste_chainee *)
                    715:                        element_courant)).donnee);
                    716:                free((struct_liste_chainee *) element_courant);
                    717: 
                    718:                element_courant = element_suivant;
                    719:            }
                    720: 
                    721:            for(i = 0; i < (*s_etat_processus).nombre_instructions_externes;
                    722:                    i++)
                    723:            {
                    724:                free((*s_etat_processus).s_instructions_externes[i].nom);
                    725:                free((*s_etat_processus).s_instructions_externes[i]
                    726:                        .nom_bibliotheque);
                    727:            }
                    728: 
                    729:            if ((*s_etat_processus).nombre_instructions_externes != 0)
                    730:            {
                    731:                free((*s_etat_processus).s_instructions_externes);
                    732:            }
                    733: 
                    734:            element_courant = (*s_etat_processus).s_bibliotheques;
                    735:            while(element_courant != NULL)
                    736:            {
                    737:                element_suivant = (*((struct_liste_chainee *)
                    738:                        element_courant)).suivant;
                    739: 
                    740:                element_candidat = (*candidat).s_bibliotheques;
                    741:                while(element_candidat != NULL)
                    742:                {
                    743:                    if (((*((struct_bibliotheque *) (*((struct_liste_chainee *)
                    744:                            element_courant)).donnee))
                    745:                            .descripteur == (*((struct_bibliotheque *)
                    746:                            (*((struct_liste_chainee *) element_candidat))
                    747:                            .donnee)).descripteur) &&
                    748:                            ((*((struct_bibliotheque *)
                    749:                            (*((struct_liste_chainee *) element_courant))
                    750:                            .donnee)).pid == (*((struct_bibliotheque *)
                    751:                            (*((struct_liste_chainee *) element_candidat))
                    752:                            .donnee)).pid) && (pthread_equal(
                    753:                            (*((struct_bibliotheque *)
                    754:                            (*((struct_liste_chainee *) element_courant))
                    755:                            .donnee)).tid, (*((struct_bibliotheque *)
                    756:                            (*((struct_liste_chainee *) element_candidat))
                    757:                            .donnee)).tid) != 0))
                    758:                    {
                    759:                        break;
                    760:                    }
                    761: 
                    762:                    element_candidat = (*((struct_liste_chainee *)
                    763:                            element_candidat)).suivant;
                    764:                }
                    765: 
                    766:                if (element_candidat == NULL)
                    767:                {
                    768:                    dlclose((*((struct_bibliotheque *)
                    769:                            (*((struct_liste_chainee *) element_courant))
                    770:                            .donnee)).descripteur);
                    771:                }
                    772: 
                    773:                free((*((struct_bibliotheque *)
                    774:                        (*((struct_liste_chainee *)
                    775:                        element_courant)).donnee)).nom);
                    776:                free((*((struct_liste_chainee *) element_courant)).donnee);
                    777:                free(element_courant);
                    778: 
                    779:                element_courant = element_suivant;
                    780:            }
                    781: 
                    782:            element_courant = (*s_etat_processus).l_base_pile_last;
                    783:            while(element_courant != NULL)
                    784:            {
                    785:                element_suivant = (*((struct_liste_chainee *)
                    786:                        element_courant)).suivant;
                    787: 
                    788:                pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
                    789:                        element_courant)).donnee).mutex));
                    790:                pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
                    791:                        element_courant)).donnee).mutex));
                    792:                liberation(s_etat_processus,
                    793:                        (*((struct_liste_chainee *) element_courant)).donnee);
                    794:                free(element_courant);
                    795: 
                    796:                element_courant = element_suivant;
                    797:            }
                    798: 
                    799:            element_courant = (*s_etat_processus).l_base_pile_systeme;
                    800:            while(element_courant != NULL)
                    801:            {
                    802:                element_suivant = (*((struct_liste_pile_systeme *)
                    803:                        element_courant)).suivant;
                    804: 
                    805:                if ((*((struct_liste_pile_systeme *)
                    806:                        element_courant)).indice_boucle != NULL)
                    807:                {
                    808:                    pthread_mutex_trylock(&((*(*((struct_liste_pile_systeme *)
                    809:                            element_courant)).indice_boucle).mutex));
                    810:                    pthread_mutex_unlock(&((*(*((struct_liste_pile_systeme *)
                    811:                            element_courant)).indice_boucle).mutex));
                    812:                }
                    813: 
                    814:                liberation(s_etat_processus,
                    815:                        (*((struct_liste_pile_systeme *)
                    816:                        element_courant)).indice_boucle);
                    817: 
                    818:                if ((*((struct_liste_pile_systeme *)
                    819:                        element_courant)).limite_indice_boucle != NULL)
                    820:                {
                    821:                    pthread_mutex_trylock(&((*(*((struct_liste_pile_systeme *)
                    822:                            element_courant)).limite_indice_boucle).mutex));
                    823:                    pthread_mutex_unlock(&((*(*((struct_liste_pile_systeme *)
                    824:                            element_courant)).limite_indice_boucle).mutex));
                    825:                }
                    826: 
                    827:                liberation(s_etat_processus,
                    828:                        (*((struct_liste_pile_systeme *)
                    829:                        element_courant)).limite_indice_boucle);
                    830: 
                    831:                if ((*((struct_liste_pile_systeme *)
                    832:                        element_courant)).objet_de_test != NULL)
                    833:                {
                    834:                    pthread_mutex_trylock(&((*(*((struct_liste_pile_systeme *)
                    835:                            element_courant)).objet_de_test).mutex));
                    836:                    pthread_mutex_unlock(&((*(*((struct_liste_pile_systeme *)
                    837:                            element_courant)).objet_de_test).mutex));
                    838:                }
                    839: 
                    840:                liberation(s_etat_processus,
                    841:                        (*((struct_liste_pile_systeme *)
                    842:                        element_courant)).objet_de_test);
                    843: 
                    844:                if ((*((struct_liste_pile_systeme *)
                    845:                        element_courant)).nom_variable != NULL)
                    846:                {
                    847:                    free((*((struct_liste_pile_systeme *)
                    848:                            element_courant)).nom_variable);
                    849:                }
                    850: 
                    851:                free(element_courant);
                    852: 
                    853:                element_courant = element_suivant;
                    854:            }
                    855: 
                    856:            element_courant = (*s_etat_processus).s_fichiers;
                    857:            while(element_courant != NULL)
                    858:            {
                    859:                element_suivant = (*((struct_liste_chainee *)
                    860:                        element_courant)).suivant;
                    861: 
                    862:                element_candidat = (*candidat).s_fichiers;
                    863:                while(element_candidat != NULL)
                    864:                {
                    865:                    if (((*((struct_descripteur_fichier *)
                    866:                            (*((struct_liste_chainee *) element_courant))
                    867:                            .donnee)).pid ==
                    868:                            (*((struct_descripteur_fichier *)
                    869:                            (*((struct_liste_chainee *) element_candidat))
                    870:                            .donnee)).pid) && (pthread_equal(
                    871:                            (*((struct_descripteur_fichier *)
                    872:                            (*((struct_liste_chainee *) element_courant))
                    873:                            .donnee)).tid, (*((struct_descripteur_fichier *)
                    874:                            (*((struct_liste_chainee *) element_candidat))
                    875:                            .donnee)).tid) != 0))
                    876:                    {
1.5       bertrand  877:                        if ((*((struct_descripteur_fichier *)
                    878:                                (*((struct_liste_chainee *) element_courant))
                    879:                                .donnee)).type ==
                    880:                                (*((struct_descripteur_fichier *)
                    881:                                (*((struct_liste_chainee *) element_candidat))
                    882:                                .donnee)).type)
                    883:                        {
                    884:                            if ((*((struct_descripteur_fichier *)
                    885:                                    (*((struct_liste_chainee *)
                    886:                                    element_candidat)).donnee)).type == 'C')
                    887:                            {
                    888:                                if ((*((struct_descripteur_fichier *)
                    889:                                        (*((struct_liste_chainee *)
                    890:                                        element_courant)).donnee))
                    891:                                        .descripteur_c ==
                    892:                                        (*((struct_descripteur_fichier *)
                    893:                                        (*((struct_liste_chainee *)
                    894:                                        element_candidat)).donnee))
                    895:                                        .descripteur_c)
                    896:                                {
                    897:                                    break;
                    898:                                }
                    899:                            }
                    900:                            else
                    901:                            {
                    902:                                if (((*((struct_descripteur_fichier *)
                    903:                                        (*((struct_liste_chainee *)
                    904:                                        element_courant)).donnee))
                    905:                                        .descripteur_sqlite ==
                    906:                                        (*((struct_descripteur_fichier *)
                    907:                                        (*((struct_liste_chainee *)
                    908:                                        element_candidat)).donnee))
                    909:                                        .descripteur_sqlite) &&
                    910:                                        ((*((struct_descripteur_fichier *)
                    911:                                        (*((struct_liste_chainee *)
                    912:                                        element_courant)).donnee))
                    913:                                        .descripteur_c ==
                    914:                                        (*((struct_descripteur_fichier *)
                    915:                                        (*((struct_liste_chainee *)
                    916:                                        element_candidat)).donnee))
                    917:                                        .descripteur_c))
                    918:                                {
                    919:                                    break;
                    920:                                }
                    921:                            }
                    922:                        }
1.1       bertrand  923:                    }
                    924: 
                    925:                    element_candidat = (*((struct_liste_chainee *)
                    926:                            element_candidat)).suivant;
                    927:                }
                    928: 
                    929:                if (element_candidat == NULL)
                    930:                {
                    931:                    fclose((*((struct_descripteur_fichier *)
                    932:                            (*((struct_liste_chainee *) element_courant))
1.5       bertrand  933:                            .donnee)).descripteur_c);
                    934: 
                    935:                    if ((*((struct_descripteur_fichier *)
                    936:                            (*((struct_liste_chainee *) element_courant))
                    937:                            .donnee)).type != 'C')
                    938:                    {
                    939:                        sqlite3_close((*((struct_descripteur_fichier *)
                    940:                                (*((struct_liste_chainee *) element_courant))
                    941:                                .donnee)).descripteur_sqlite);
                    942:                    }
1.1       bertrand  943:                }
                    944: 
                    945:                free((*((struct_descripteur_fichier *)
                    946:                        (*((struct_liste_chainee *)
                    947:                        element_courant)).donnee)).nom);
                    948:                free((struct_descripteur_fichier *)
                    949:                        (*((struct_liste_chainee *)
                    950:                        element_courant)).donnee);
                    951:                free(element_courant);
                    952: 
                    953:                element_courant = element_suivant;
                    954:            }
                    955: 
                    956:            element_courant = (*s_etat_processus).s_sockets;
                    957:            while(element_courant != NULL)
                    958:            {
                    959:                element_suivant = (*((struct_liste_chainee *)
                    960:                        element_courant)).suivant;
                    961: 
                    962:                element_candidat = (*candidat).s_sockets;
                    963:                while(element_candidat != NULL)
                    964:                {
                    965:                    if (((*((struct_socket *)
                    966:                            (*((struct_liste_chainee *) element_courant))
                    967:                            .donnee)).socket == (*((struct_socket *)
                    968:                            (*((struct_liste_chainee *) element_candidat))
                    969:                            .donnee)).socket) &&
                    970:                            ((*((struct_socket *)
                    971:                            (*((struct_liste_chainee *) element_courant))
                    972:                            .donnee)).pid == (*((struct_socket *)
                    973:                            (*((struct_liste_chainee *) element_candidat))
                    974:                            .donnee)).pid) && (pthread_equal(
                    975:                            (*((struct_socket *)
                    976:                            (*((struct_liste_chainee *) element_courant))
                    977:                            .donnee)).tid, (*((struct_socket *)
                    978:                            (*((struct_liste_chainee *) element_candidat))
                    979:                            .donnee)).tid) != 0))
                    980:                    {
                    981:                        break;
                    982:                    }
                    983: 
                    984:                    element_candidat = (*((struct_liste_chainee *)
                    985:                            element_candidat)).suivant;
                    986:                }
                    987: 
                    988:                if (element_candidat == NULL)
                    989:                {
                    990:                    if ((*((struct_socket *) (*((struct_liste_chainee *)
                    991:                            element_courant)).donnee)).socket_connectee
                    992:                            == d_vrai)
                    993:                    {
                    994:                        shutdown((*((struct_socket *)
                    995:                                (*((struct_liste_chainee *) element_courant))
                    996:                                .donnee)).socket, SHUT_RDWR);
                    997:                    }
                    998: 
                    999:                    close((*((struct_socket *)
                   1000:                            (*((struct_liste_chainee *) element_courant))
                   1001:                            .donnee)).socket);
                   1002:                }
                   1003: 
                   1004:                pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
                   1005:                        element_courant)).donnee).mutex));
                   1006:                pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
                   1007:                        element_courant)).donnee).mutex));
                   1008: 
                   1009:                liberation(s_etat_processus,
                   1010:                        (*((struct_liste_chainee *)
                   1011:                        element_courant)).donnee);
                   1012:                free(element_courant);
                   1013: 
                   1014:                element_courant = element_suivant;
                   1015:            }
                   1016: 
1.14      bertrand 1017: /*
                   1018: ================================================================================
                   1019:   À noter : on ne ferme pas la connexion car la conséquence immédiate est
                   1020:   une destruction de l'objet pour le processus père.
                   1021: ================================================================================
                   1022: 
1.1       bertrand 1023:            element_courant = (*s_etat_processus).s_connecteurs_sql;
                   1024:            while(element_courant != NULL)
                   1025:            {
                   1026:                element_suivant = (*((struct_liste_chainee *)
                   1027:                        element_courant)).suivant;
                   1028: 
                   1029:                element_candidat = (*candidat).s_connecteurs_sql;
                   1030:                while(element_candidat != NULL)
                   1031:                {
                   1032:                    if (((
                   1033: #ifdef MYSQL_SUPPORT
                   1034:                            ((*((struct_connecteur_sql *)
                   1035:                            (*((struct_liste_chainee *) element_courant))
                   1036:                            .donnee)).descripteur.mysql ==
                   1037:                            (*((struct_connecteur_sql *)
                   1038:                            (*((struct_liste_chainee *) element_candidat))
                   1039:                            .donnee)).descripteur.mysql)
                   1040:                            &&
                   1041:                            (strcmp((*((struct_connecteur_sql *)
                   1042:                            (*((struct_liste_chainee *) element_courant))
                   1043:                            .donnee)).type, "MYSQL") == 0)
                   1044:                            &&
                   1045:                            (strcmp((*((struct_connecteur_sql *)
                   1046:                            (*((struct_liste_chainee *) element_candidat))
                   1047:                            .donnee)).type, "MYSQL") == 0)
                   1048: #else
                   1049:                            0
                   1050: #endif
                   1051:                            ) || (
                   1052: #ifdef POSTGRESQL_SUPPORT
                   1053:                            ((*((struct_connecteur_sql *)
                   1054:                            (*((struct_liste_chainee *) element_courant))
                   1055:                            .donnee)).descripteur.postgresql ==
                   1056:                            (*((struct_connecteur_sql *)
                   1057:                            (*((struct_liste_chainee *) element_candidat))
                   1058:                            .donnee)).descripteur.postgresql)
                   1059:                            &&
                   1060:                            (strcmp((*((struct_connecteur_sql *)
                   1061:                            (*((struct_liste_chainee *) element_courant))
                   1062:                            .donnee)).type, "POSTGRESQL") == 0)
                   1063:                            &&
                   1064:                            (strcmp((*((struct_connecteur_sql *)
                   1065:                            (*((struct_liste_chainee *) element_candidat))
                   1066:                            .donnee)).type, "POSTGRESQL") == 0)
                   1067: #else
                   1068:                            0
                   1069: #endif
                   1070:                            )) &&
                   1071:                            ((*((struct_connecteur_sql *)
                   1072:                            (*((struct_liste_chainee *) element_courant))
                   1073:                            .donnee)).pid == (*((struct_connecteur_sql *)
                   1074:                            (*((struct_liste_chainee *) element_candidat))
                   1075:                            .donnee)).pid) && (pthread_equal(
                   1076:                            (*((struct_connecteur_sql *)
                   1077:                            (*((struct_liste_chainee *) element_courant))
                   1078:                            .donnee)).tid, (*((struct_connecteur_sql *)
                   1079:                            (*((struct_liste_chainee *) element_candidat))
                   1080:                            .donnee)).tid) != 0))
                   1081:                    {
                   1082:                        break;
                   1083:                    }
                   1084: 
                   1085:                    element_candidat = (*((struct_liste_chainee *)
                   1086:                            element_candidat)).suivant;
                   1087:                }
                   1088: 
                   1089:                if (element_candidat == NULL)
                   1090:                {
                   1091:                    sqlclose((*((struct_liste_chainee *) element_courant))
                   1092:                            .donnee);
                   1093:                }
                   1094: 
                   1095:                pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
                   1096:                        element_courant)).donnee).mutex));
                   1097:                pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
                   1098:                        element_courant)).donnee).mutex));
                   1099: 
                   1100:                liberation(s_etat_processus, (*((struct_liste_chainee *)
                   1101:                        element_courant)).donnee);
                   1102:                free(element_courant);
                   1103: 
                   1104:                element_courant = element_suivant;
                   1105:            }
1.14      bertrand 1106: */
1.1       bertrand 1107: 
1.15      bertrand 1108:            (*s_etat_processus).s_connecteurs_sql = NULL;
                   1109: 
1.1       bertrand 1110:            element_courant = (*s_etat_processus).s_marques;
                   1111:            while(element_courant != NULL)
                   1112:            {
                   1113:                free((*((struct_marque *) element_courant)).label);
                   1114:                free((*((struct_marque *) element_courant)).position);
                   1115:                element_suivant = (*((struct_marque *) element_courant))
                   1116:                        .suivant;
                   1117:                free(element_courant);
                   1118:                element_courant = element_suivant;
                   1119:            }
                   1120: 
                   1121:            liberation_allocateur(s_etat_processus);
                   1122: 
1.79      bertrand 1123: #          ifndef SEMAPHORES_NOMMES
                   1124:                sem_post(&((*s_etat_processus).semaphore_fork));
                   1125:                sem_destroy(&((*s_etat_processus).semaphore_fork));
                   1126: #          else
                   1127:                sem_post((*s_etat_processus).semaphore_fork);
1.80      bertrand 1128:                sem_close((*s_etat_processus).semaphore_fork);
1.79      bertrand 1129: #          endif
1.1       bertrand 1130: 
1.59      bertrand 1131:            liberation_contexte_cas(s_etat_processus);
1.1       bertrand 1132:            free(s_etat_processus);
                   1133: 
                   1134:            s_etat_processus = candidat;
                   1135:        }
                   1136: 
                   1137:        l_element_suivant = (*l_element_courant).suivant;
                   1138: 
                   1139:        free((struct_thread *) (*l_element_courant).donnee);
                   1140:        free((struct_liste_chainee *) l_element_courant);
                   1141: 
                   1142:        l_element_courant = l_element_suivant;
                   1143:    }
                   1144: 
                   1145:    liste_threads = NULL;
                   1146: 
                   1147:    l_element_courant = liste_threads_surveillance;
                   1148: 
                   1149:    while(l_element_courant != NULL)
                   1150:    {
                   1151:        s_argument_thread = (struct_descripteur_thread *)
                   1152:                (*l_element_courant).donnee;
                   1153: 
1.40      bertrand 1154:        if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references))
                   1155:                != 0)
1.1       bertrand 1156:        {
                   1157:            (*s_etat_processus).erreur_systeme = d_es_processus;
1.68      bertrand 1158:            pthread_mutex_unlock(&mutex_liste_threads);
1.1       bertrand 1159:            return;
                   1160:        }
                   1161: 
                   1162:        (*s_argument_thread).nombre_references--;
                   1163: 
                   1164:        BUG((*s_argument_thread).nombre_references < 0,
                   1165:                printf("(*s_argument_thread).nombre_references = %d\n",
                   1166:                (int) (*s_argument_thread).nombre_references));
                   1167: 
                   1168:        if ((*s_argument_thread).nombre_references == 0)
                   1169:        {
1.20      bertrand 1170:            close((*s_argument_thread).pipe_objets[0]);
                   1171:            close((*s_argument_thread).pipe_acquittement[1]);
                   1172:            close((*s_argument_thread).pipe_injections[1]);
                   1173:            close((*s_argument_thread).pipe_nombre_injections[1]);
                   1174:            close((*s_argument_thread).pipe_nombre_objets_attente[0]);
                   1175:            close((*s_argument_thread).pipe_interruptions[0]);
                   1176:            close((*s_argument_thread).pipe_nombre_interruptions_attente[0]);
                   1177: 
1.40      bertrand 1178:            if (pthread_mutex_unlock(&((*s_argument_thread)
                   1179:                    .mutex_nombre_references)) != 0)
1.1       bertrand 1180:            {
                   1181:                (*s_etat_processus).erreur_systeme = d_es_processus;
1.68      bertrand 1182:                pthread_mutex_unlock(&mutex_liste_threads);
1.1       bertrand 1183:                return;
                   1184:            }
                   1185: 
                   1186:            pthread_mutex_destroy(&((*s_argument_thread).mutex));
1.40      bertrand 1187:            pthread_mutex_destroy(&((*s_argument_thread)
                   1188:                    .mutex_nombre_references));
1.20      bertrand 1189: 
                   1190:            if ((*s_argument_thread).processus_detache == d_faux)
                   1191:            {
                   1192:                if ((*s_argument_thread).destruction_objet == d_vrai)
                   1193:                {
                   1194:                    liberation(s_etat_processus, (*s_argument_thread).argument);
                   1195:                }
                   1196:            }
                   1197: 
1.1       bertrand 1198:            free(s_argument_thread);
                   1199:        }
                   1200:        else
                   1201:        {
1.40      bertrand 1202:            if (pthread_mutex_unlock(&((*s_argument_thread)
                   1203:                    .mutex_nombre_references)) != 0)
1.1       bertrand 1204:            {
                   1205:                (*s_etat_processus).erreur_systeme = d_es_processus;
1.68      bertrand 1206:                pthread_mutex_unlock(&mutex_liste_threads);
1.1       bertrand 1207:                return;
                   1208:            }
                   1209:        }
                   1210: 
                   1211:        l_element_suivant = (*l_element_courant).suivant;
                   1212:        free((struct_liste_chainee *) l_element_courant);
                   1213:        l_element_courant = l_element_suivant;
                   1214:    }
                   1215: 
                   1216:    liste_threads_surveillance = NULL;
                   1217: 
1.68      bertrand 1218:    if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
1.1       bertrand 1219:    {
                   1220:        (*s_etat_processus).erreur_systeme = d_es_processus;
                   1221:        return;
                   1222:    }
                   1223: 
                   1224:    return;
                   1225: }
                   1226: 
                   1227: static struct_processus *
                   1228: recherche_thread(pid_t pid, pthread_t tid)
                   1229: {
                   1230:    volatile struct_liste_chainee_volatile      *l_element_courant;
                   1231: 
                   1232:    struct_processus                            *s_etat_processus;
                   1233: 
                   1234:    l_element_courant = liste_threads;
                   1235: 
                   1236:    while(l_element_courant != NULL)
                   1237:    {
                   1238:        if ((pthread_equal((*((struct_thread *) (*l_element_courant).donnee))
                   1239:                .tid, tid) != 0) && ((*((struct_thread *)
                   1240:                (*l_element_courant).donnee)).pid == pid))
                   1241:        {
                   1242:            break;
                   1243:        }
                   1244: 
                   1245:        l_element_courant = (*l_element_courant).suivant;
                   1246:    }
                   1247: 
                   1248:    if (l_element_courant == NULL)
                   1249:    {
                   1250:        /*
                   1251:         * Le processus n'existe plus. On ne distribue aucun signal.
                   1252:         */
                   1253: 
                   1254:        return(NULL);
                   1255:    }
                   1256: 
                   1257:    s_etat_processus = (*((struct_thread *)
                   1258:            (*l_element_courant).donnee)).s_etat_processus;
                   1259: 
                   1260:    return(s_etat_processus);
                   1261: }
                   1262: 
1.66      bertrand 1263: static struct_processus *
                   1264: recherche_thread_principal(pid_t pid)
1.1       bertrand 1265: {
                   1266:    volatile struct_liste_chainee_volatile      *l_element_courant;
                   1267: 
                   1268:    l_element_courant = liste_threads;
                   1269: 
                   1270:    while(l_element_courant != NULL)
                   1271:    {
                   1272:        if (((*((struct_thread *) (*l_element_courant).donnee)).thread_principal
                   1273:                == d_vrai) && ((*((struct_thread *)
                   1274:                (*l_element_courant).donnee)).pid == pid))
                   1275:        {
                   1276:            break;
                   1277:        }
                   1278: 
                   1279:        l_element_courant = (*l_element_courant).suivant;
                   1280:    }
                   1281: 
                   1282:    if (l_element_courant == NULL)
                   1283:    {
                   1284:        /*
                   1285:         * Le processus n'existe plus. On ne distribue aucun signal.
                   1286:         */
                   1287: 
1.66      bertrand 1288:        return(NULL);
1.1       bertrand 1289:    }
                   1290: 
1.66      bertrand 1291:    return((*((struct_thread *) (*l_element_courant).donnee))
                   1292:            .s_etat_processus);
1.1       bertrand 1293: }
                   1294: 
                   1295: 
                   1296: /*
                   1297: ================================================================================
                   1298:   Procédures de gestion des signaux d'interruption
                   1299: ================================================================================
                   1300:   Entrée : variable globale
                   1301: --------------------------------------------------------------------------------
                   1302:   Sortie : variable globale modifiée
                   1303: --------------------------------------------------------------------------------
                   1304:   Effets de bord : néant
                   1305: ================================================================================
                   1306: */
                   1307: 
                   1308: // Les routines suivantes sont uniquement appelées depuis les gestionnaires
1.17      bertrand 1309: // des signaux asynchrones. Elles ne doivent pas bloquer dans le cas où
1.1       bertrand 1310: // les sémaphores sont déjà bloqués par un gestionnaire de signal.
                   1311: 
                   1312: static inline void
1.68      bertrand 1313: verrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)
1.1       bertrand 1314: {
                   1315:    int         semaphore;
                   1316: 
1.79      bertrand 1317: #  ifndef SEMAPHORES_NOMMES
1.77      bertrand 1318:    if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.79      bertrand 1319: #  else
                   1320:    if (sem_post((*s_etat_processus).semaphore_fork) != 0)
                   1321: #  endif
1.1       bertrand 1322:    {
1.68      bertrand 1323:        BUG(1, uprintf("Lock error !\n"));
                   1324:        return;
1.1       bertrand 1325:    }
                   1326: 
                   1327:    // Il faut respecteur l'atomicité des deux opérations suivantes !
                   1328: 
1.68      bertrand 1329:    if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) != 0)
1.1       bertrand 1330:    {
1.79      bertrand 1331: #      ifndef SEMAPHORES_NOMMES
1.77      bertrand 1332:        sem_wait(&((*s_etat_processus).semaphore_fork));
1.79      bertrand 1333: #      else
                   1334:        sem_wait((*s_etat_processus).semaphore_fork);
                   1335: #      endif
1.68      bertrand 1336:        BUG(1, uprintf("Unlock error !\n"));
                   1337:        return;
1.1       bertrand 1338:    }
                   1339: 
1.8       bertrand 1340: #  ifndef SEMAPHORES_NOMMES
1.1       bertrand 1341:    if (sem_post(&semaphore_gestionnaires_signaux) == -1)
1.8       bertrand 1342: #  else
                   1343:    if (sem_post(semaphore_gestionnaires_signaux) == -1)
                   1344: #  endif
1.1       bertrand 1345:    {
1.79      bertrand 1346: #      ifndef SEMAPHORES_NOMMES
1.77      bertrand 1347:        sem_wait(&((*s_etat_processus).semaphore_fork));
1.79      bertrand 1348: #      else
                   1349:        sem_wait((*s_etat_processus).semaphore_fork);
                   1350: #      endif
1.1       bertrand 1351:        BUG(1, uprintf("Lock error !\n"));
                   1352:        return;
                   1353:    }
                   1354: 
1.8       bertrand 1355: #  ifndef SEMAPHORES_NOMMES
1.1       bertrand 1356:    if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)
1.8       bertrand 1357: #  else
                   1358:    if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
                   1359: #  endif
1.1       bertrand 1360:    {
1.79      bertrand 1361: #      ifndef SEMAPHORES_NOMMES
1.77      bertrand 1362:        sem_wait(&((*s_etat_processus).semaphore_fork));
1.79      bertrand 1363: #      else
                   1364:        sem_wait((*s_etat_processus).semaphore_fork);
                   1365: #      endif
1.1       bertrand 1366:        BUG(1, uprintf("Lock error !\n"));
                   1367:        return;
                   1368:    }
                   1369: 
1.68      bertrand 1370:    if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0)
1.1       bertrand 1371:    {
1.79      bertrand 1372: #      ifndef SEMAPHORES_NOMMES
1.77      bertrand 1373:        sem_wait(&((*s_etat_processus).semaphore_fork));
1.79      bertrand 1374: #      else
                   1375:        sem_wait((*s_etat_processus).semaphore_fork);
                   1376: #      endif
1.1       bertrand 1377:        BUG(1, uprintf("Unlock error !\n"));
                   1378:        return;
                   1379:    }
                   1380: 
                   1381:    if (semaphore == 1)
                   1382:    {
                   1383:        // Le semaphore ne peut être pris par le thread qui a appelé
                   1384:        // le gestionnaire de signal car le signal est bloqué par ce thread
                   1385:        // dans les zones critiques. Ce sémaphore ne peut donc être bloqué que
                   1386:        // par un thread concurrent. On essaye donc de le bloquer jusqu'à
                   1387:        // ce que ce soit possible.
                   1388: 
1.68      bertrand 1389:        if (pthread_mutex_lock(&mutex_liste_threads) != 0)
1.1       bertrand 1390:        {
1.80      bertrand 1391: #          ifndef SEMAPHORES_NOMMES
1.77      bertrand 1392:            sem_wait(&((*s_etat_processus).semaphore_fork));
1.80      bertrand 1393: #          else
                   1394:            sem_wait((*s_etat_processus).semaphore_fork);
                   1395: #          endif
1.68      bertrand 1396:            BUG(1, uprintf("Lock error !\n"));
                   1397:            return;
1.1       bertrand 1398:        }
                   1399:    }
                   1400: 
                   1401:    return;
                   1402: }
                   1403: 
                   1404: static inline void
1.68      bertrand 1405: deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)
1.1       bertrand 1406: {
                   1407:    int         semaphore;
                   1408: 
                   1409:    // Il faut respecteur l'atomicité des deux opérations suivantes !
                   1410: 
1.68      bertrand 1411:    if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) == -1)
1.1       bertrand 1412:    {
1.79      bertrand 1413: #      ifndef SEMAPHORES_NOMMES
1.77      bertrand 1414:        sem_wait(&((*s_etat_processus).semaphore_fork));
1.79      bertrand 1415: #      else
                   1416:        sem_wait((*s_etat_processus).semaphore_fork);
                   1417: #      endif
1.68      bertrand 1418:        BUG(1, uprintf("Unlock error !\n"));
                   1419:        return;
1.1       bertrand 1420:    }
                   1421: 
1.8       bertrand 1422: #  ifndef SEMAPHORES_NOMMES
1.1       bertrand 1423:    if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)
1.8       bertrand 1424: #  else
                   1425:    if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
                   1426: #  endif
1.1       bertrand 1427:    {
1.79      bertrand 1428: #      ifndef SEMAPHORES_NOMMES
1.77      bertrand 1429:        sem_wait(&((*s_etat_processus).semaphore_fork));
1.79      bertrand 1430: #      else
                   1431:        sem_wait((*s_etat_processus).semaphore_fork);
                   1432: #      endif
1.1       bertrand 1433:        BUG(1, uprintf("Unlock error !\n"));
                   1434:        return;
                   1435:    }
                   1436: 
1.8       bertrand 1437: #  ifndef SEMAPHORES_NOMMES
1.1       bertrand 1438:    while(sem_wait(&semaphore_gestionnaires_signaux) == -1)
1.8       bertrand 1439: #  else
                   1440:    while(sem_wait(semaphore_gestionnaires_signaux) == -1)
                   1441: #  endif
1.1       bertrand 1442:    {
                   1443:        if (errno != EINTR)
                   1444:        {
1.79      bertrand 1445: #          ifndef SEMAPHORES_NOMMES
1.77      bertrand 1446:            sem_wait(&((*s_etat_processus).semaphore_fork));
1.79      bertrand 1447: #          else
                   1448:            sem_wait((*s_etat_processus).semaphore_fork);
                   1449: #          endif
1.1       bertrand 1450:            BUG(1, uprintf("Unlock error !\n"));
                   1451:            return;
                   1452:        }
                   1453:    }
                   1454: 
1.68      bertrand 1455:    if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0)
1.1       bertrand 1456:    {
1.79      bertrand 1457: #      ifndef SEMAPHORES_NOMMES
1.77      bertrand 1458:        sem_wait(&((*s_etat_processus).semaphore_fork));
1.79      bertrand 1459: #      else
                   1460:        sem_wait((*s_etat_processus).semaphore_fork);
                   1461: #      endif
1.1       bertrand 1462:        BUG(1, uprintf("Unlock error !\n"));
                   1463:        return;
                   1464:    }
                   1465: 
1.79      bertrand 1466: #  ifndef SEMAPHORES_NOMMES
1.78      bertrand 1467:    while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1.79      bertrand 1468: #  else
                   1469:    while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
                   1470: #  endif
1.1       bertrand 1471:    {
1.79      bertrand 1472:        if (errno != EINTR)
                   1473:        {
                   1474:            BUG(1, uprintf("Unlock error !\n"));
                   1475:            return;
                   1476:        }
1.1       bertrand 1477:    }
                   1478: 
                   1479:    if (semaphore == 1)
                   1480:    {
1.68      bertrand 1481:        if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
1.1       bertrand 1482:        {
                   1483:            BUG(1, uprintf("Unlock error !\n"));
                   1484:            return;
                   1485:        }
                   1486:    }
                   1487: 
                   1488:    return;
                   1489: }
                   1490: 
1.65      bertrand 1491: #define test_signal(signal) \
1.67      bertrand 1492:    if (signal_test == SIGTEST) { signal_test = signal; return; }
1.66      bertrand 1493: 
1.67      bertrand 1494: // Récupération des signaux
                   1495: // - SIGINT    (arrêt au clavier)
                   1496: // - SIGTERM (signal d'arrêt en provenance du système)
1.65      bertrand 1497: 
1.67      bertrand 1498: void
                   1499: interruption1(int signal)
1.30      bertrand 1500: {
1.67      bertrand 1501:    test_signal(signal);
1.30      bertrand 1502: 
1.67      bertrand 1503:    switch(signal)
1.31      bertrand 1504:    {
1.67      bertrand 1505:        case SIGINT:
                   1506:            envoi_signal_processus(getpid(), rpl_sigint);
                   1507:            break;
1.66      bertrand 1508: 
1.67      bertrand 1509:        case SIGTERM:
                   1510:            envoi_signal_processus(getpid(), rpl_sigterm);
                   1511:            break;
1.31      bertrand 1512: 
1.81      bertrand 1513:        case SIGUSR1:
1.67      bertrand 1514:            envoi_signal_processus(getpid(), rpl_sigalrm);
                   1515:            break;
1.31      bertrand 1516:    }
1.66      bertrand 1517: 
1.67      bertrand 1518:    return;
1.66      bertrand 1519: }
                   1520: 
1.67      bertrand 1521: inline static void
                   1522: signal_alrm(struct_processus *s_etat_processus, pid_t pid)
1.66      bertrand 1523: {
1.67      bertrand 1524:    struct_processus        *s_thread_principal;
1.66      bertrand 1525: 
1.68      bertrand 1526:    verrouillage_gestionnaire_signaux(s_etat_processus);
1.67      bertrand 1527: 
                   1528:    if (pid == getpid())
                   1529:    {
                   1530:        // Si pid est égal à getpid(), le signal à traiter est issu
                   1531:        // du même processus que celui qui va le traiter, mais d'un thread
                   1532:        // différent.
1.66      bertrand 1533: 
1.67      bertrand 1534:        if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
1.66      bertrand 1535:        {
1.67      bertrand 1536:            printf("[%d] RPL/SIGALRM (thread %llu)\n", (int) getpid(),
                   1537:                    (unsigned long long) pthread_self());
                   1538:            fflush(stdout);
                   1539:        }
1.66      bertrand 1540: 
1.67      bertrand 1541:        if ((*s_etat_processus).pid_processus_pere != getpid())
                   1542:        {
                   1543:            // On n'est pas dans le processus père, on remonte le signal.
                   1544:            envoi_signal_processus((*s_etat_processus).pid_processus_pere,
                   1545:                    rpl_sigalrm);
1.66      bertrand 1546:        }
                   1547:        else
                   1548:        {
1.67      bertrand 1549:            // On est dans le processus père, on effectue un arrêt d'urgence.
                   1550:            (*s_etat_processus).var_volatile_alarme = -1;
                   1551:            (*s_etat_processus).var_volatile_requete_arret = -1;
1.66      bertrand 1552:        }
1.67      bertrand 1553:    }
                   1554:    else
                   1555:    {
                   1556:        // Le signal est issu d'un processus différent. On recherche le
                   1557:        // thread principal pour remonter le signal.
1.66      bertrand 1558: 
1.67      bertrand 1559:        if ((s_thread_principal = recherche_thread_principal(getpid()))
                   1560:                != NULL)
1.66      bertrand 1561:        {
1.67      bertrand 1562:            envoi_signal_contexte(s_thread_principal, rpl_sigalrm);
1.66      bertrand 1563:        }
1.67      bertrand 1564:    }
1.29      bertrand 1565: 
1.68      bertrand 1566:    deverrouillage_gestionnaire_signaux(s_etat_processus);
1.66      bertrand 1567:    return;
                   1568: }
                   1569: 
1.67      bertrand 1570: inline static void
                   1571: signal_term(struct_processus *s_etat_processus, pid_t pid)
1.66      bertrand 1572: {
1.67      bertrand 1573:    struct_processus        *s_thread_principal;
1.66      bertrand 1574:    volatile sig_atomic_t   exclusion = 0;
                   1575: 
1.68      bertrand 1576:    verrouillage_gestionnaire_signaux(s_etat_processus);
1.66      bertrand 1577: 
1.67      bertrand 1578:    if (pid == getpid())
1.1       bertrand 1579:    {
1.67      bertrand 1580:        if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
                   1581:        {
                   1582:            printf("[%d] RPL/SIGTERM (thread %llu)\n", (int) getpid(),
                   1583:                    (unsigned long long) pthread_self());
                   1584:            fflush(stdout);
                   1585:        }
                   1586: 
                   1587:        if ((*s_etat_processus).pid_processus_pere != getpid())
                   1588:        {
                   1589:            envoi_signal_processus((*s_etat_processus).pid_processus_pere,
                   1590:                    rpl_sigterm);
                   1591:        }
                   1592:        else
1.1       bertrand 1593:        {
1.67      bertrand 1594:            (*s_etat_processus).var_volatile_traitement_sigint = -1;
                   1595: 
                   1596:            while(exclusion == 1);
                   1597:            exclusion = 1;
1.1       bertrand 1598: 
1.67      bertrand 1599:            if ((*s_etat_processus).var_volatile_requete_arret == -1)
1.1       bertrand 1600:            {
1.68      bertrand 1601:                deverrouillage_gestionnaire_signaux(s_etat_processus);
1.67      bertrand 1602:                exclusion = 0;
                   1603:                return;
1.1       bertrand 1604:            }
                   1605: 
1.67      bertrand 1606:            (*s_etat_processus).var_volatile_requete_arret = -1;
                   1607:            (*s_etat_processus).var_volatile_alarme = -1;
                   1608: 
                   1609:            exclusion = 0;
1.1       bertrand 1610:        }
1.67      bertrand 1611:    }
                   1612:    else
                   1613:    {
                   1614:        if ((s_thread_principal = recherche_thread_principal(getpid()))
                   1615:                != NULL)
1.1       bertrand 1616:        {
1.67      bertrand 1617:            envoi_signal_contexte(s_thread_principal, rpl_sigterm);
                   1618:        }
                   1619:    }
1.44      bertrand 1620: 
1.68      bertrand 1621:    deverrouillage_gestionnaire_signaux(s_etat_processus);
1.67      bertrand 1622:    return;
                   1623: }
1.1       bertrand 1624: 
1.67      bertrand 1625: inline static void
                   1626: signal_int(struct_processus *s_etat_processus, pid_t pid)
                   1627: {
                   1628:    struct_processus        *s_thread_principal;
                   1629:    volatile sig_atomic_t   exclusion = 0;
1.1       bertrand 1630: 
1.68      bertrand 1631:    verrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 1632: 
1.67      bertrand 1633:    if (pid == getpid())
                   1634:    {
                   1635:        if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
                   1636:        {
                   1637:            printf("[%d] RPL/SIGINT (thread %llu)\n", (int) getpid(),
                   1638:                    (unsigned long long) pthread_self());
                   1639:            fflush(stdout);
                   1640:        }
1.1       bertrand 1641: 
1.67      bertrand 1642:        if ((*s_etat_processus).pid_processus_pere != getpid())
                   1643:        {
                   1644:            envoi_signal_processus((*s_etat_processus).pid_processus_pere,
                   1645:                    rpl_sigint);
                   1646:        }
                   1647:        else
                   1648:        {
                   1649:            (*s_etat_processus).var_volatile_traitement_sigint = -1;
1.44      bertrand 1650: 
1.67      bertrand 1651:            while(exclusion == 1);
                   1652:            exclusion = 1;
1.1       bertrand 1653: 
1.67      bertrand 1654:            if ((*s_etat_processus).var_volatile_requete_arret == -1)
                   1655:            {
1.68      bertrand 1656:                deverrouillage_gestionnaire_signaux(s_etat_processus);
1.67      bertrand 1657:                exclusion = 0;
                   1658:                return;
                   1659:            }
1.1       bertrand 1660: 
1.67      bertrand 1661:            if ((*s_etat_processus).langue == 'F')
                   1662:            {
                   1663:                printf("+++Interruption\n");
1.1       bertrand 1664:            }
                   1665:            else
                   1666:            {
1.67      bertrand 1667:                printf("+++Interrupt\n");
1.1       bertrand 1668:            }
                   1669: 
1.67      bertrand 1670:            fflush(stdout);
                   1671: 
                   1672:            (*s_etat_processus).var_volatile_requete_arret = -1;
                   1673:            (*s_etat_processus).var_volatile_alarme = -1;
                   1674: 
                   1675:            exclusion = 0;
1.1       bertrand 1676:        }
1.67      bertrand 1677:    }
                   1678:    else
                   1679:    {
                   1680:        if ((s_thread_principal = recherche_thread_principal(getpid()))
                   1681:                != NULL)
1.1       bertrand 1682:        {
1.67      bertrand 1683:            envoi_signal_contexte(s_thread_principal, rpl_sigint);
1.1       bertrand 1684:        }
                   1685:    }
                   1686: 
1.68      bertrand 1687:    deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 1688:    return;
                   1689: }
                   1690: 
1.67      bertrand 1691: // Récupération des signaux
                   1692: // - SIGFSTP
                   1693: //
                   1694: // ATTENTION :
                   1695: // Le signal SIGFSTP provient de la mort du processus de contrôle.
                   1696: // Sous certains systèmes (Linux...), la mort du terminal de contrôle
                   1697: // se traduit par l'envoi d'un SIGHUP au processus. Sur d'autres
                   1698: // (SunOS), le processus reçoit un SIGFSTP avec une structure siginfo
                   1699: // non initialisée (pointeur NULL) issue de TERMIO.
                   1700: 
1.1       bertrand 1701: void
1.67      bertrand 1702: interruption2(int signal)
1.1       bertrand 1703: {
1.65      bertrand 1704:    test_signal(signal);
1.67      bertrand 1705:    envoi_signal_processus(getpid(), rpl_sigtstp);
1.66      bertrand 1706:    return;
                   1707: }
                   1708: 
1.67      bertrand 1709: static inline void
                   1710: signal_tstp(struct_processus *s_etat_processus, pid_t pid)
1.66      bertrand 1711: {
                   1712:    struct_processus        *s_thread_principal;
                   1713: 
1.68      bertrand 1714:    verrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 1715: 
1.30      bertrand 1716:    if (pid == getpid())
1.1       bertrand 1717:    {
                   1718:        /*
                   1719:         *  0 => fonctionnement normal
                   1720:         * -1 => requête
                   1721:         *  1 => requête acceptée en attente de traitement
                   1722:         */
                   1723: 
                   1724:        if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
                   1725:        {
1.67      bertrand 1726:            printf("[%d] RPL/SIGTSTP (thread %llu)\n", (int) getpid(),
1.1       bertrand 1727:                    (unsigned long long) pthread_self());
                   1728:            fflush(stdout);
                   1729:        }
                   1730: 
                   1731:        if ((*s_etat_processus).var_volatile_processus_pere == 0)
                   1732:        {
1.67      bertrand 1733:            envoi_signal_processus((*s_etat_processus).pid_processus_pere,
                   1734:                    rpl_sigtstp);
1.1       bertrand 1735:        }
                   1736:        else
                   1737:        {
                   1738:            (*s_etat_processus).var_volatile_requete_arret2 = -1;
                   1739:        }
                   1740:    }
                   1741:    else
                   1742:    {
                   1743:        // Envoi d'un signal au thread maître du groupe.
                   1744: 
1.66      bertrand 1745:        if ((s_thread_principal = recherche_thread_principal(getpid()))
                   1746:                != NULL)
1.1       bertrand 1747:        {
1.67      bertrand 1748:            envoi_signal_contexte(s_thread_principal, rpl_sigtstp);
1.1       bertrand 1749:        }
                   1750:    }
                   1751: 
1.68      bertrand 1752:    deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 1753:    return;
                   1754: }
                   1755: 
                   1756: void
1.67      bertrand 1757: interruption3(int signal)
1.1       bertrand 1758: {
1.66      bertrand 1759:    // Si on passe par ici, c'est qu'il est impossible de récupérer
                   1760:    // l'erreur d'accès à la mémoire. On sort donc du programme quitte à
                   1761:    // ce qu'il reste des processus orphelins.
                   1762: 
1.81      bertrand 1763:    unsigned char       message_1[] = "+++System : Uncaught access violation\n"
                   1764:                                "+++System : Aborting !\n";
                   1765:    unsigned char       message_2[] = "+++System : Stack overflow\n"
1.67      bertrand 1766:                                "+++System : Aborting !\n";
                   1767: 
                   1768:    test_signal(signal);
1.66      bertrand 1769: 
                   1770:    if (pid_processus_pere == getpid())
                   1771:    {
1.81      bertrand 1772:        kill(pid_processus_pere, SIGUSR1);
                   1773:    }
                   1774: 
                   1775:    if (signal != SIGUSR2)
                   1776:    {
1.86      bertrand 1777:        write(STDERR_FILENO, message_1, strlen(message_1));
1.81      bertrand 1778:    }
                   1779:    else
                   1780:    {
1.86      bertrand 1781:        write(STDERR_FILENO, message_2, strlen(message_2));
1.66      bertrand 1782:    }
                   1783: 
                   1784:    _exit(EXIT_FAILURE);
                   1785: }
                   1786: 
1.81      bertrand 1787: 
                   1788: static void
                   1789: sortie_interruption_depassement_pile(void *arg1, void *arg2, void *arg3)
1.66      bertrand 1790: {
1.81      bertrand 1791:    switch((*((volatile int *) arg1)))
                   1792:    {
                   1793:        case 1:
                   1794:            longjmp(contexte_ecriture, -1);
                   1795:            break;
1.63      bertrand 1796: 
1.81      bertrand 1797:        case 2:
                   1798:            longjmp(contexte_impression, -1);
                   1799:            break;
                   1800:    }
1.1       bertrand 1801: 
1.81      bertrand 1802:    return;
                   1803: }
1.32      bertrand 1804: 
1.1       bertrand 1805: 
1.81      bertrand 1806: void
                   1807: interruption_depassement_pile(int urgence, stackoverflow_context_t scp)
                   1808: {
                   1809:    if ((urgence == 0) && (routine_recursive != 0))
1.1       bertrand 1810:    {
1.81      bertrand 1811:        // On peut tenter de récupérer le dépassement de pile. Si la variable
                   1812:        // 'routine_recursive' est non nulle, on récupère l'erreur.
1.1       bertrand 1813: 
1.81      bertrand 1814:        sigsegv_leave_handler(sortie_interruption_depassement_pile,
                   1815:                (void *) &routine_recursive, NULL, NULL);
1.1       bertrand 1816:    }
                   1817: 
1.81      bertrand 1818:    // Ici, la panique est totale et il vaut mieux quitter l'application.
                   1819:    interruption3(SIGUSR2);
                   1820:    return;
                   1821: }
1.1       bertrand 1822: 
                   1823: 
1.81      bertrand 1824: int
                   1825: interruption_violation_access(void *adresse_fautive, int gravite)
                   1826: {
                   1827:    unsigned char       message[] = "+++System : Trying to catch access "
                   1828:                                "violation\n";
1.63      bertrand 1829: 
1.85      bertrand 1830:    static int          compteur_erreur = 0;
1.63      bertrand 1831: 
1.81      bertrand 1832:    if ((gravite == 0) && (routine_recursive != 0))
                   1833:    {
                   1834:        // Il peut s'agir d'un dépassement de pile.
1.63      bertrand 1835: 
1.81      bertrand 1836:        sigsegv_leave_handler(sortie_interruption_depassement_pile,
                   1837:                (void *) &routine_recursive, NULL, NULL);
                   1838:    }
1.63      bertrand 1839: 
1.81      bertrand 1840:    // On est dans une bonne vieille violation d'accès. On essaie
                   1841:    // de fermer au mieux l'application.
1.63      bertrand 1842: 
1.81      bertrand 1843:    compteur_erreur++;
1.63      bertrand 1844: 
1.81      bertrand 1845:    if (compteur_erreur >= 2)
                   1846:    {
                   1847:        // Erreurs multiples, on arrête l'application.
                   1848:        interruption3(SIGSEGV);
                   1849:        return(0);
                   1850:    }
1.63      bertrand 1851: 
1.86      bertrand 1852:    write(STDERR_FILENO, message, strlen(message));
1.63      bertrand 1853: 
1.81      bertrand 1854:    if (pid_processus_pere == getpid())
                   1855:    {
                   1856:        longjmp(contexte_initial, -1);
                   1857:        return(1);
                   1858:    }
                   1859:    else
                   1860:    {
                   1861:        longjmp(contexte_processus, -1);
                   1862:        return(1);
1.1       bertrand 1863:    }
                   1864: 
1.81      bertrand 1865:    // On renvoie 0 parce qu'on décline toute responsabilité quant à la
                   1866:    // suite des événements...
                   1867:    return(0);
1.1       bertrand 1868: }
1.67      bertrand 1869: 
                   1870: // Traitement de rpl_sigstart
1.1       bertrand 1871: 
1.67      bertrand 1872: static inline void
                   1873: signal_start(struct_processus *s_etat_processus, pid_t pid)
1.1       bertrand 1874: {
1.69      bertrand 1875:    struct_processus        *s_thread_principal;
                   1876: 
                   1877:    verrouillage_gestionnaire_signaux(s_etat_processus);
                   1878: 
                   1879:    if (pid == getpid())
                   1880:    {
                   1881:        (*s_etat_processus).demarrage_fils = d_vrai;
                   1882:    }
                   1883:    else
                   1884:    {
                   1885:        // Envoi d'un signal au thread maître du groupe.
                   1886: 
                   1887:        if ((s_thread_principal = recherche_thread_principal(getpid()))
                   1888:                != NULL)
                   1889:        {
                   1890:            envoi_signal_contexte(s_thread_principal, rpl_sigstart);
                   1891:        }
                   1892:    }
                   1893: 
                   1894:    deverrouillage_gestionnaire_signaux(s_etat_processus);
1.67      bertrand 1895:    return;
                   1896: }
1.32      bertrand 1897: 
1.67      bertrand 1898: // Traitement de rpl_sigcont
1.1       bertrand 1899: 
1.67      bertrand 1900: static inline void
                   1901: signal_cont(struct_processus *s_etat_processus, pid_t pid)
                   1902: {
1.69      bertrand 1903:    struct_processus        *s_thread_principal;
                   1904: 
                   1905:    verrouillage_gestionnaire_signaux(s_etat_processus);
                   1906: 
                   1907:    if (pid == getpid())
                   1908:    {
                   1909:        (*s_etat_processus).redemarrage_processus = d_vrai;
                   1910:    }
                   1911:    else
                   1912:    {
                   1913:        // Envoi d'un signal au thread maître du groupe.
                   1914: 
                   1915:        if ((s_thread_principal = recherche_thread_principal(getpid()))
                   1916:                != NULL)
                   1917:        {
                   1918:            envoi_signal_contexte(s_thread_principal, rpl_sigcont);
                   1919:        }
                   1920:    }
                   1921: 
                   1922:    deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 1923:    return;
                   1924: }
                   1925: 
1.67      bertrand 1926: // Traitement de rpl_sigstop
                   1927: 
                   1928: static inline void
                   1929: signal_stop(struct_processus *s_etat_processus, pid_t pid)
1.1       bertrand 1930: {
1.67      bertrand 1931:    struct_processus        *s_thread_principal;
1.1       bertrand 1932: 
1.68      bertrand 1933:    verrouillage_gestionnaire_signaux(s_etat_processus);
1.32      bertrand 1934: 
1.30      bertrand 1935:    if (pid == getpid())
1.1       bertrand 1936:    {
                   1937:        if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
                   1938:        {
1.69      bertrand 1939:            printf("[%d] RPL/SIGSTOP (thread %llu)\n", (int) getpid(),
1.16      bertrand 1940:                    (unsigned long long) pthread_self());
                   1941:            fflush(stdout);
1.1       bertrand 1942:        }
                   1943: 
                   1944:        /*
                   1945:         * var_globale_traitement_retarde_stop :
                   1946:         *  0 -> traitement immédiat
                   1947:         *  1 -> traitement retardé (aucun signal reçu)
                   1948:         * -1 -> traitement retardé (un ou plusieurs signaux stop reçus)
                   1949:         */
                   1950: 
1.11      bertrand 1951:        if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)
1.1       bertrand 1952:        {
1.11      bertrand 1953:            (*s_etat_processus).var_volatile_requete_arret = -1;
1.1       bertrand 1954:        }
                   1955:        else
                   1956:        {
1.11      bertrand 1957:            (*s_etat_processus).var_volatile_traitement_retarde_stop = -1;
1.1       bertrand 1958:        }
                   1959:    }
                   1960:    else
                   1961:    {
                   1962:        // Envoi d'un signal au thread maître du groupe.
                   1963: 
1.67      bertrand 1964:        if ((s_thread_principal = recherche_thread_principal(getpid()))
                   1965:                != NULL)
1.1       bertrand 1966:        {
1.67      bertrand 1967:            envoi_signal_contexte(s_thread_principal, rpl_sigstop);
1.1       bertrand 1968:        }
                   1969:    }
                   1970: 
1.68      bertrand 1971:    deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 1972:    return;
                   1973: }
                   1974: 
1.67      bertrand 1975: // Traitement de rpl_siginject
                   1976: 
                   1977: static inline void
                   1978: signal_inject(struct_processus *s_etat_processus, pid_t pid)
1.1       bertrand 1979: {
1.68      bertrand 1980:    verrouillage_gestionnaire_signaux(s_etat_processus);
1.32      bertrand 1981: 
1.1       bertrand 1982:    if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
                   1983:    {
1.68      bertrand 1984:        deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 1985:        return;
                   1986:    }
                   1987: 
                   1988:    if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
                   1989:    {
1.67      bertrand 1990:        printf("[%d] RPL/SIGINJECT (thread %llu)\n", (int) getpid(),
1.1       bertrand 1991:                (unsigned long long) pthread_self());
                   1992:        fflush(stdout);
                   1993:    }
                   1994: 
1.68      bertrand 1995:    deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 1996:    return;
                   1997: }
                   1998: 
1.67      bertrand 1999: // Récupération des signaux
                   2000: // - SIGPIPE
                   2001: 
1.1       bertrand 2002: void
1.67      bertrand 2003: interruption5(int signal)
1.1       bertrand 2004: {
1.67      bertrand 2005:    unsigned char       message[] = "+++System : SIGPIPE\n"
                   2006:                                "+++System : Aborting !\n";
1.1       bertrand 2007: 
1.65      bertrand 2008:    test_signal(signal);
1.32      bertrand 2009: 
1.67      bertrand 2010:    if (pid_processus_pere == getpid())
1.1       bertrand 2011:    {
1.67      bertrand 2012:        envoi_signal_processus(pid_processus_pere, rpl_sigalrm);
1.1       bertrand 2013:    }
                   2014: 
1.86      bertrand 2015:    write(STDERR_FILENO, message, strlen(message));
1.1       bertrand 2016:    return;
                   2017: }
                   2018: 
1.67      bertrand 2019: static inline void
                   2020: signal_urg(struct_processus *s_etat_processus, pid_t pid)
1.1       bertrand 2021: {
1.67      bertrand 2022:    struct_processus        *s_thread_principal;
1.30      bertrand 2023: 
1.68      bertrand 2024:    verrouillage_gestionnaire_signaux(s_etat_processus);
1.32      bertrand 2025: 
1.30      bertrand 2026:    if (pid == getpid())
1.1       bertrand 2027:    {
                   2028:        if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
                   2029:        {
1.67      bertrand 2030:            printf("[%d] RPL/SIGURG (thread %llu)\n", (int) getpid(),
1.1       bertrand 2031:                    (unsigned long long) pthread_self());
                   2032:            fflush(stdout);
                   2033:        }
                   2034: 
                   2035:        (*s_etat_processus).var_volatile_alarme = -1;
                   2036:        (*s_etat_processus).var_volatile_requete_arret = -1;
                   2037:    }
                   2038:    else
                   2039:    {
                   2040:        // Envoi d'un signal au thread maître du groupe.
                   2041: 
1.67      bertrand 2042:        if ((s_thread_principal = recherche_thread_principal(getpid()))
                   2043:                != NULL)
1.1       bertrand 2044:        {
1.67      bertrand 2045:            envoi_signal_contexte(s_thread_principal, rpl_sigurg);
1.1       bertrand 2046:        }
                   2047:    }
                   2048: 
1.68      bertrand 2049:    deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 2050:    return;
                   2051: }
                   2052: 
1.67      bertrand 2053: // Traitement de rpl_sigabort
                   2054: 
                   2055: static inline void
                   2056: signal_abort(struct_processus *s_etat_processus, pid_t pid)
1.1       bertrand 2057: {
1.67      bertrand 2058:    struct_processus        *s_thread_principal;
1.1       bertrand 2059: 
1.68      bertrand 2060:    verrouillage_gestionnaire_signaux(s_etat_processus);
1.32      bertrand 2061: 
1.1       bertrand 2062:    if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
                   2063:    {
1.68      bertrand 2064:        deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 2065:        return;
                   2066:    }
                   2067: 
                   2068:    if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
                   2069:    {
1.67      bertrand 2070:        printf("[%d] RPL/SIGABORT (thread %llu)\n", (int) getpid(),
1.1       bertrand 2071:                (unsigned long long) pthread_self());
                   2072:        fflush(stdout);
                   2073:    }
                   2074: 
1.67      bertrand 2075:    if (pid == getpid())
1.30      bertrand 2076:    {
1.67      bertrand 2077:        (*s_etat_processus).arret_depuis_abort = -1;
                   2078: 
                   2079:        /*
                   2080:         * var_globale_traitement_retarde_stop :
                   2081:         *  0 -> traitement immédiat
                   2082:         *  1 -> traitement retardé (aucun signal reçu)
                   2083:         * -1 -> traitement retardé (un ou plusieurs signaux stop reçus)
                   2084:         */
                   2085: 
                   2086:        if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)
                   2087:        {
                   2088:            (*s_etat_processus).var_volatile_requete_arret = -1;
                   2089:        }
                   2090:        else
                   2091:        {
                   2092:            (*s_etat_processus).var_volatile_traitement_retarde_stop = -1;
                   2093:        }
                   2094:    }
                   2095:    else
                   2096:    {
                   2097:        (*s_etat_processus).arret_depuis_abort = -1;
                   2098: 
                   2099:        // Envoi d'un signal au thread maître du groupe.
                   2100: 
                   2101:        if ((s_thread_principal = recherche_thread_principal(getpid()))
                   2102:                != NULL)
                   2103:        {
                   2104:            envoi_signal_contexte(s_thread_principal, rpl_sigabort);
                   2105:        }
                   2106:    }
                   2107: 
1.68      bertrand 2108:    deverrouillage_gestionnaire_signaux(s_etat_processus);
1.67      bertrand 2109:    return;
                   2110: }
                   2111: 
                   2112: // Récupération des signaux
                   2113: // - SIGHUP
1.1       bertrand 2114: 
                   2115: void
1.67      bertrand 2116: interruption4(int signal)
                   2117: {
                   2118:    test_signal(signal);
                   2119:    envoi_signal_processus(getpid(), rpl_sighup);
                   2120:    return;
                   2121: }
                   2122: 
                   2123: static inline void
                   2124: signal_hup(struct_processus *s_etat_processus, pid_t pid)
1.1       bertrand 2125: {
                   2126:    file                    *fichier;
                   2127: 
                   2128:    unsigned char           nom[8 + 64 + 1];
                   2129: 
1.68      bertrand 2130:    verrouillage_gestionnaire_signaux(s_etat_processus);
1.32      bertrand 2131: 
1.1       bertrand 2132:    if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
                   2133:    {
1.68      bertrand 2134:        deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 2135:        return;
                   2136:    }
                   2137: 
                   2138:    snprintf(nom, 8 + 64 + 1, "rpl-out-%lu-%lu", (unsigned long) getpid(),
                   2139:            (unsigned long) pthread_self());
                   2140: 
                   2141:    if ((fichier = fopen(nom, "w+")) != NULL)
                   2142:    {
                   2143:        fclose(fichier);
                   2144: 
1.86      bertrand 2145:        freopen(nom, "w", stdout);
                   2146:        freopen(nom, "w", stderr);
1.1       bertrand 2147:    }
                   2148: 
1.86      bertrand 2149:    freopen("/dev/null", "r", stdin);
1.1       bertrand 2150: 
                   2151:    if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
                   2152:    {
1.69      bertrand 2153:        printf("[%d] RPL/SIGHUP (thread %llu)\n", (int) getpid(),
1.1       bertrand 2154:                (unsigned long long) pthread_self());
                   2155:        fflush(stdout);
                   2156:    }
                   2157: 
1.68      bertrand 2158:    deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 2159:    return;
                   2160: }
                   2161: 
                   2162: void
1.67      bertrand 2163: traitement_exceptions_gsl(const char *reason, const char *file,
                   2164:        int line, int gsl_errno)
                   2165: {
1.68      bertrand 2166:    code_erreur_gsl = gsl_errno;
                   2167:    envoi_signal_processus(getpid(), rpl_sigexcept);
                   2168:    return;
                   2169: }
1.67      bertrand 2170: 
1.68      bertrand 2171: static inline void
                   2172: signal_except(struct_processus *s_etat_processus, pid_t pid)
                   2173: {
                   2174:    verrouillage_gestionnaire_signaux(s_etat_processus);
1.67      bertrand 2175: 
                   2176:    if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
                   2177:    {
1.68      bertrand 2178:        deverrouillage_gestionnaire_signaux(s_etat_processus);
1.67      bertrand 2179:        return;
                   2180:    }
                   2181: 
1.68      bertrand 2182:    (*s_etat_processus).var_volatile_exception_gsl = code_erreur_gsl;
                   2183:    deverrouillage_gestionnaire_signaux(s_etat_processus);
                   2184: 
1.67      bertrand 2185:    return;
                   2186: }
                   2187: 
                   2188: static inline void
                   2189: envoi_interruptions(struct_processus *s_etat_processus, enum signaux_rpl signal,
                   2190:        pid_t pid_source)
1.16      bertrand 2191: {
1.67      bertrand 2192:    switch(signal)
                   2193:    {
1.69      bertrand 2194:        case rpl_signull:
                   2195:            break;
                   2196: 
1.67      bertrand 2197:        case rpl_sigint:
                   2198:            signal_int(s_etat_processus, pid_source);
                   2199:            break;
                   2200: 
                   2201:        case rpl_sigterm:
                   2202:            signal_term(s_etat_processus, pid_source);
                   2203:            break;
                   2204: 
                   2205:        case rpl_sigstart:
                   2206:            signal_start(s_etat_processus, pid_source);
                   2207:            break;
                   2208: 
                   2209:        case rpl_sigcont:
                   2210:            signal_cont(s_etat_processus, pid_source);
                   2211:            break;
                   2212: 
                   2213:        case rpl_sigstop:
                   2214:            signal_stop(s_etat_processus, pid_source);
                   2215:            break;
1.30      bertrand 2216: 
1.67      bertrand 2217:        case rpl_sigabort:
                   2218:            signal_abort(s_etat_processus, pid_source);
                   2219:            break;
                   2220: 
                   2221:        case rpl_sigurg:
                   2222:            signal_urg(s_etat_processus, pid_source);
                   2223:            break;
                   2224: 
                   2225:        case rpl_siginject:
                   2226:            signal_inject(s_etat_processus, pid_source);
                   2227:            break;
                   2228: 
                   2229:        case rpl_sigalrm:
                   2230:            signal_alrm(s_etat_processus, pid_source);
                   2231:            break;
                   2232: 
                   2233:        case rpl_sighup:
                   2234:            signal_hup(s_etat_processus, pid_source);
                   2235:            break;
                   2236: 
                   2237:        case rpl_sigtstp:
                   2238:            signal_tstp(s_etat_processus, pid_source);
                   2239:            break;
                   2240: 
1.68      bertrand 2241:        case rpl_sigexcept:
                   2242:            signal_except(s_etat_processus, pid_source);
                   2243:            break;
                   2244: 
1.67      bertrand 2245:        default:
1.69      bertrand 2246:            if ((*s_etat_processus).langue == 'F')
                   2247:            {
                   2248:                printf("+++System : Spurious signal (%d) !\n", signal);
                   2249:            }
                   2250:            else
                   2251:            {
                   2252:                printf("+++System : Signal inconnu (%d) !\n", signal);
                   2253:            }
                   2254: 
1.67      bertrand 2255:            break;
                   2256:    }
1.30      bertrand 2257: 
1.67      bertrand 2258:    return;
                   2259: }
1.16      bertrand 2260: 
1.67      bertrand 2261: void
                   2262: scrutation_interruptions(struct_processus *s_etat_processus)
                   2263: {
                   2264:    // Interruptions qui arrivent sur le processus depuis un
                   2265:    // processus externe.
1.32      bertrand 2266: 
1.68      bertrand 2267:    // Les pointeurs de lecture pointent sur les prochains éléments
                   2268:    // à lire. Les pointeurs d'écriture pointent sur les prochains éléments à
                   2269:    // écrire.
                   2270: 
1.72      bertrand 2271: #  ifndef SEMAPHORES_NOMMES
                   2272:        if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0)
                   2273: #  else
                   2274:        if (sem_trywait(semaphore_queue_signaux) == 0)
                   2275: #  endif
1.68      bertrand 2276:    {
                   2277:        if ((*s_queue_signaux).pointeur_lecture !=
                   2278:                (*s_queue_signaux).pointeur_ecriture)
                   2279:        {
                   2280:            // Il y a un signal en attente dans le segment partagé. On le
                   2281:            // traite.
                   2282: 
                   2283:            envoi_interruptions(s_etat_processus,
                   2284:                    (*s_queue_signaux).queue[(*s_queue_signaux)
                   2285:                    .pointeur_lecture].signal, (*s_queue_signaux).queue
                   2286:                    [(*s_queue_signaux).pointeur_lecture].pid);
                   2287:            (*s_queue_signaux).pointeur_lecture =
                   2288:                    ((*s_queue_signaux).pointeur_lecture + 1)
                   2289:                    % LONGUEUR_QUEUE_SIGNAUX;
                   2290:        }
                   2291: 
1.72      bertrand 2292: #      ifndef SEMAPHORES_NOMMES
                   2293:            sem_post(&((*s_queue_signaux).semaphore));
                   2294: #      else
                   2295:            sem_post(semaphore_queue_signaux);
                   2296: #      endif
1.68      bertrand 2297:    }
                   2298: 
1.67      bertrand 2299:    // Interruptions qui arrivent depuis le groupe courant de threads.
1.29      bertrand 2300: 
1.68      bertrand 2301:    if (pthread_mutex_trylock(&mutex_interruptions) == 0)
1.16      bertrand 2302:    {
1.68      bertrand 2303:        if ((*s_etat_processus).pointeur_signal_lecture !=
                   2304:                (*s_etat_processus).pointeur_signal_ecriture)
                   2305:        {
                   2306:            // Il y a un signal dans la queue du thread courant. On le traite.
                   2307: 
                   2308:            envoi_interruptions(s_etat_processus,
                   2309:                    (*s_etat_processus).signaux_en_queue
                   2310:                    [(*s_etat_processus).pointeur_signal_lecture],
                   2311:                    getpid());
                   2312:            (*s_etat_processus).pointeur_signal_lecture =
                   2313:                    ((*s_etat_processus).pointeur_signal_lecture + 1)
                   2314:                    % LONGUEUR_QUEUE_SIGNAUX;
                   2315:        }
                   2316: 
                   2317:        pthread_mutex_unlock(&mutex_interruptions);
1.67      bertrand 2318:    }
                   2319: 
                   2320:    return;
                   2321: }
                   2322: 
1.69      bertrand 2323: /*
                   2324: ================================================================================
                   2325:   Fonction renvoyant le nom du segment de mémoire partagée en fonction
                   2326:   du pid du processus.
                   2327: ================================================================================
                   2328:   Entrée : Chemin absolue servant de racine, pid du processus
                   2329: --------------------------------------------------------------------------------
                   2330:   Sortie : NULL ou nom du segment
                   2331: --------------------------------------------------------------------------------
                   2332:   Effet de bord : Néant
                   2333: ================================================================================
                   2334: */
                   2335: 
                   2336: static unsigned char *
                   2337: nom_segment(unsigned char *chemin, pid_t pid)
                   2338: {
                   2339:    unsigned char               *fichier;
                   2340: 
                   2341: #  ifdef IPCS_SYSV // !POSIX
                   2342: #      ifndef OS2 // !OS2
1.84      bertrand 2343: 
1.69      bertrand 2344:            if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) *
                   2345:                    sizeof(unsigned char))) == NULL)
                   2346:            {
                   2347:                return(NULL);
                   2348:            }
                   2349: 
                   2350:            sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid);
                   2351: #      else // OS2
                   2352:            if ((fichier = malloc((10 + 256 + 1) * sizeof(unsigned char)))
                   2353:                    == NULL)
                   2354:            {
                   2355:                return(NULL);
                   2356:            }
                   2357: 
                   2358:            sprintf(fichier, "\\SHAREMEM\\RPL-SIGQUEUES-%d", (int) pid);
                   2359: #      endif // OS2
                   2360: #  else // POSIX
                   2361: 
                   2362:        if ((fichier = malloc((1 + 256 + 1) *
                   2363:                sizeof(unsigned char))) == NULL)
                   2364:        {
                   2365:            return(NULL);
                   2366:        }
                   2367: 
                   2368:        sprintf(fichier, "/RPL-SIGQUEUES-%d", (int) pid);
                   2369: #  endif
                   2370: 
                   2371:    return(fichier);
                   2372: }
                   2373: 
                   2374: 
1.71      bertrand 2375: /*
                   2376: ================================================================================
                   2377:   Fonctions d'envoi d'un signal à un thread ou à un processus.
                   2378: ================================================================================
                   2379:   Entrée : processus et signal
                   2380: --------------------------------------------------------------------------------
                   2381:   Sortie : erreur
                   2382: --------------------------------------------------------------------------------
                   2383:   Effet de bord : Néant
                   2384: ================================================================================
                   2385: */
                   2386: 
1.67      bertrand 2387: int
                   2388: envoi_signal_processus(pid_t pid, enum signaux_rpl signal)
                   2389: {
1.83      bertrand 2390: #  ifndef OS2
                   2391:        int                         segment;
                   2392: #  endif
1.69      bertrand 2393: 
1.75      bertrand 2394: #  ifndef IPCS_SYSV
                   2395: #      ifdef SEMAPHORES_NOMMES
                   2396:            sem_t                   *semaphore;
                   2397: #      endif
                   2398: #  else
1.83      bertrand 2399: #      ifndef OS2
                   2400:            int                     desc;
                   2401:            key_t                   clef;
                   2402: #      endif
1.75      bertrand 2403: #  endif
1.72      bertrand 2404: 
1.69      bertrand 2405:    struct_queue_signaux            *queue;
                   2406: 
                   2407:    unsigned char                   *nom;
                   2408: 
1.67      bertrand 2409:    // Il s'agit d'ouvrir le segment de mémoire partagée, de le projeter en
                   2410:    // mémoire puis d'y inscrire le signal à traiter.
                   2411: 
1.69      bertrand 2412:    if (pid == getpid())
                   2413:    {
                   2414:        // Le signal est envoyé au même processus.
                   2415: 
                   2416:        if (s_queue_signaux == NULL)
                   2417:        {
                   2418:            return(1);
                   2419:        }
                   2420: 
1.72      bertrand 2421: #      ifndef SEMAPHORES_NOMMES
1.78      bertrand 2422:            while(sem_wait(&((*s_queue_signaux).semaphore)) != 0)
1.72      bertrand 2423: #      else
1.78      bertrand 2424:            while(sem_wait(semaphore_queue_signaux) != 0)
1.72      bertrand 2425: #      endif
1.69      bertrand 2426:        {
1.78      bertrand 2427:            if (errno != EINTR)
                   2428:            {
                   2429:                return(1);
                   2430:            }
1.69      bertrand 2431:        }
                   2432: 
                   2433:        (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture]
                   2434:                .pid = pid;
                   2435:        (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture]
                   2436:                .signal = signal;
                   2437: 
                   2438:        (*s_queue_signaux).pointeur_ecriture =
                   2439:                ((*s_queue_signaux).pointeur_ecriture + 1)
                   2440:                % LONGUEUR_QUEUE_SIGNAUX;
                   2441: 
1.72      bertrand 2442: #      ifndef SEMAPHORES_NOMMES
                   2443:            if (sem_post(&((*s_queue_signaux).semaphore)) != 0)
                   2444: #      else
                   2445:            if (sem_post(semaphore_queue_signaux) != 0)
                   2446: #      endif
1.69      bertrand 2447:        {
                   2448:            return(1);
                   2449:        }
                   2450:    }
                   2451:    else
                   2452:    {
                   2453:        // Le signal est envoyé depuis un processus distinct.
                   2454: 
1.75      bertrand 2455: #      ifdef IPCS_SYSV
1.76      bertrand 2456:            if ((nom = nom_segment(racine_segment, pid)) == NULL)
1.75      bertrand 2457:            {
                   2458:                return(1);
                   2459:            }
                   2460: 
1.83      bertrand 2461: #          ifndef OS2 // SysV
                   2462:                if ((desc = open(nom, O_RDWR)) == -1)
                   2463:                {
                   2464:                    free(nom);
                   2465:                    return(1);
                   2466:                }
                   2467: 
                   2468:                close(desc);
1.75      bertrand 2469: 
1.83      bertrand 2470:                if ((clef = ftok(nom, 1)) == -1)
                   2471:                {
                   2472:                    free(nom);
                   2473:                    return(1);
                   2474:                }
1.75      bertrand 2475: 
                   2476:                free(nom);
1.69      bertrand 2477: 
1.83      bertrand 2478:                if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0))
                   2479:                        == -1)
                   2480:                {
                   2481:                    return(1);
                   2482:                }
1.69      bertrand 2483: 
1.83      bertrand 2484:                queue = shmat(segment, NULL, 0);
                   2485: #          else // OS/2
                   2486:                if (DosGetNamedSharedMem((PVOID) &queue, nom,
                   2487:                        PAG_WRITE | PAG_READ) != 0)
                   2488:                {
                   2489:                    free(nom);
                   2490:                    return(1);
                   2491:                }
1.69      bertrand 2492: 
1.83      bertrand 2493:                free(nom);
                   2494: #          endif
1.75      bertrand 2495: #      else // POSIX
                   2496:            if ((nom = nom_segment(racine_segment, pid)) == NULL)
                   2497:            {
                   2498:                return(1);
                   2499:            }
1.69      bertrand 2500: 
1.75      bertrand 2501:            if ((segment = shm_open(nom, O_RDWR, 0)) == -1)
1.72      bertrand 2502:            {
1.75      bertrand 2503:                free(nom);
1.72      bertrand 2504:                return(1);
                   2505:            }
1.75      bertrand 2506: 
                   2507:            free(nom);
                   2508: 
                   2509:            if ((queue = mmap(NULL, sizeof(struct_queue_signaux),
                   2510:                    PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0)) ==
                   2511:                    MAP_FAILED)
1.72      bertrand 2512:            {
1.75      bertrand 2513:                close(segment);
1.72      bertrand 2514:                return(1);
                   2515:            }
1.75      bertrand 2516: #      endif
1.72      bertrand 2517: 
1.75      bertrand 2518:            // À ce moment, le segment de mémoire partagée est projeté
                   2519:            // dans l'espace du processus.
                   2520: 
                   2521: #      ifndef IPCS_SYSV // POSIX
                   2522: #          ifndef SEMAPHORES_NOMMES
1.78      bertrand 2523:                while(sem_wait(&((*queue).semaphore)) != 0)
1.75      bertrand 2524:                {
1.78      bertrand 2525:                    if (errno != EINTR)
                   2526:                    {
                   2527:                        return(1);
                   2528:                    }
1.75      bertrand 2529:                }
                   2530: #          else
1.80      bertrand 2531:                if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED)
1.75      bertrand 2532:                {
                   2533:                    return(1);
                   2534:                }
                   2535: 
1.78      bertrand 2536:                while(sem_wait(semaphore) != 0)
1.75      bertrand 2537:                {
1.78      bertrand 2538:                    if (errno != EINTR)
                   2539:                    {
                   2540:                        sem_close(semaphore);
                   2541:                        return(1);
                   2542:                    }
1.75      bertrand 2543:                }
                   2544: #          endif
                   2545: #      else // IPCS_SYSV
1.78      bertrand 2546:            while(sem_wait(&((*queue).semaphore)) != 0)
1.72      bertrand 2547:            {
1.78      bertrand 2548:                if (errno != EINTR)
                   2549:                {
                   2550:                    return(1);
                   2551:                }
1.72      bertrand 2552:            }
                   2553: #      endif
1.69      bertrand 2554: 
                   2555:        (*queue).queue[(*queue).pointeur_ecriture].pid = getpid();
                   2556:        (*queue).queue[(*queue).pointeur_ecriture].signal = signal;
                   2557: 
                   2558:        (*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1)
                   2559:                % LONGUEUR_QUEUE_SIGNAUX;
                   2560: 
1.75      bertrand 2561: #      ifndef IPCS_SYSV // POSIX
                   2562: #          ifndef SEMAPHORES_NOMMES
                   2563:                if (sem_post(&((*queue).semaphore)) != 0)
                   2564:                {
                   2565:                    return(1);
                   2566:                }
                   2567: #          else
                   2568:                if (sem_post(semaphore) != 0)
                   2569:                {
                   2570:                    sem_close(semaphore);
                   2571:                    return(1);
                   2572:                }
                   2573: 
                   2574:                if (sem_close(semaphore) != 0)
                   2575:                {
                   2576:                    return(1);
                   2577:                }
                   2578: #          endif
                   2579: 
                   2580:            if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
1.72      bertrand 2581:            {
1.75      bertrand 2582:                close(segment);
1.72      bertrand 2583:                return(1);
                   2584:            }
1.75      bertrand 2585: #      else // IPCS_SYSV
                   2586:            if (sem_post(&((*queue).semaphore)) != 0)
1.72      bertrand 2587:            {
                   2588:                return(1);
                   2589:            }
                   2590: 
1.83      bertrand 2591: #          ifndef OS2 // SysV
                   2592:                if (shmdt(queue) != 0)
                   2593:                {
                   2594:                    return(1);
                   2595:                }
                   2596: #          else // OS/2
                   2597:                // Pendant de DosGetNamedSHaredMem()
                   2598: #          endif
1.72      bertrand 2599: #      endif
1.69      bertrand 2600:    }
                   2601: 
1.89      bertrand 2602:    kill(pid, SIGALRM);
                   2603: 
1.67      bertrand 2604:    return(0);
                   2605: }
                   2606: 
                   2607: int
                   2608: envoi_signal_thread(pthread_t tid, enum signaux_rpl signal)
                   2609: {
                   2610:    // Un signal est envoyé d'un thread à un autre thread du même processus.
                   2611: 
1.68      bertrand 2612:    volatile struct_liste_chainee_volatile  *l_element_courant;
                   2613: 
                   2614:    struct_processus                        *s_etat_processus;
                   2615: 
                   2616:    if (pthread_mutex_lock(&mutex_liste_threads) != 0)
                   2617:    {
                   2618:        return(1);
                   2619:    }
                   2620: 
                   2621:    l_element_courant = liste_threads;
                   2622: 
                   2623:    while(l_element_courant != NULL)
                   2624:    {
                   2625:        if (((*((struct_thread *) (*l_element_courant).donnee)).pid
                   2626:                == getpid()) && (pthread_equal((*((struct_thread *)
                   2627:                (*l_element_courant).donnee)).tid, tid) != 0))
                   2628:        {
                   2629:            break;
                   2630:        }
                   2631: 
                   2632:        l_element_courant = (*l_element_courant).suivant;
                   2633:    }
                   2634: 
                   2635:    if (l_element_courant == NULL)
                   2636:    {
                   2637:        pthread_mutex_unlock(&mutex_liste_threads);
                   2638:        return(1);
                   2639:    }
                   2640: 
                   2641:    if (pthread_mutex_lock(&mutex_interruptions) != 0)
                   2642:    {
                   2643:        pthread_mutex_unlock(&mutex_liste_threads);
                   2644:        return(1);
                   2645:    }
                   2646: 
                   2647:    s_etat_processus = (*((struct_thread *) (*l_element_courant).donnee))
                   2648:            .s_etat_processus;
                   2649: 
                   2650:    (*s_etat_processus).signaux_en_queue
                   2651:            [(*s_etat_processus).pointeur_signal_ecriture] = signal;
                   2652:    (*s_etat_processus).pointeur_signal_ecriture =
                   2653:            ((*s_etat_processus).pointeur_signal_ecriture + 1)
                   2654:            % LONGUEUR_QUEUE_SIGNAUX;
                   2655: 
                   2656:    if (pthread_mutex_unlock(&mutex_interruptions) != 0)
                   2657:    {
                   2658:        pthread_mutex_unlock(&mutex_liste_threads);
                   2659:        return(1);
                   2660:    }
                   2661: 
                   2662:    if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
                   2663:    {
                   2664:        return(1);
                   2665:    }
                   2666: 
1.89      bertrand 2667:    pthread_kill(tid, SIGALRM);
                   2668: 
1.67      bertrand 2669:    return(0);
                   2670: }
                   2671: 
                   2672: int
                   2673: envoi_signal_contexte(struct_processus *s_etat_processus_a_signaler,
                   2674:        enum signaux_rpl signal)
                   2675: {
1.68      bertrand 2676:    pthread_mutex_lock(&mutex_interruptions);
1.67      bertrand 2677:    (*s_etat_processus_a_signaler).signaux_en_queue
1.68      bertrand 2678:            [(*s_etat_processus_a_signaler).pointeur_signal_ecriture] =
1.67      bertrand 2679:            signal;
1.68      bertrand 2680:    (*s_etat_processus_a_signaler).pointeur_signal_ecriture =
                   2681:            ((*s_etat_processus_a_signaler).pointeur_signal_ecriture + 1)
                   2682:            % LONGUEUR_QUEUE_SIGNAUX;
                   2683:    pthread_mutex_unlock(&mutex_interruptions);
1.67      bertrand 2684: 
1.89      bertrand 2685:    pthread_kill((*s_etat_processus_a_signaler).tid, SIGALRM);
                   2686: 
1.67      bertrand 2687:    return(0);
                   2688: }
                   2689: 
                   2690: 
                   2691: /*
                   2692: ================================================================================
                   2693:   Fonction créant un segment de mémoire partagée destiné à contenir
                   2694:   la queue des signaux.
                   2695: ================================================================================
                   2696:   Entrée : structure de description du processus
                   2697: --------------------------------------------------------------------------------
                   2698:   Sortie : Néant
                   2699: --------------------------------------------------------------------------------
                   2700:   Effet de bord : Néant
                   2701: ================================================================================
                   2702: */
                   2703: 
                   2704: void
                   2705: creation_queue_signaux(struct_processus *s_etat_processus)
                   2706: {
                   2707:    unsigned char                   *nom;
                   2708: 
1.69      bertrand 2709:    racine_segment = (*s_etat_processus).chemin_fichiers_temporaires;
                   2710: 
1.67      bertrand 2711: #  ifndef IPCS_SYSV // POSIX
1.71      bertrand 2712:        if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,
                   2713:                getpid())) == NULL)
                   2714:        {
                   2715:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2716:            return;
                   2717:        }
1.16      bertrand 2718: 
1.71      bertrand 2719:        if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_EXCL,
                   2720:                S_IRUSR | S_IWUSR)) == -1)
                   2721:        {
                   2722:            free(nom);
                   2723:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2724:            return;
                   2725:        }
1.16      bertrand 2726: 
1.71      bertrand 2727:        if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1)
                   2728:        {
                   2729:            free(nom);
                   2730:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2731:            return;
                   2732:        }
1.16      bertrand 2733: 
1.71      bertrand 2734:        s_queue_signaux = mmap(NULL, sizeof(struct_queue_signaux),
                   2735:                PROT_READ | PROT_WRITE, MAP_SHARED, f_queue_signaux, 0);
1.67      bertrand 2736: 
1.71      bertrand 2737:        if (((void *) s_queue_signaux) == ((void *) -1))
                   2738:        {
                   2739:            if (shm_unlink(nom) == -1)
                   2740:            {
                   2741:                free(nom);
                   2742:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2743:                return;
                   2744:            }
1.67      bertrand 2745: 
                   2746:            free(nom);
                   2747:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1.16      bertrand 2748:            return;
                   2749:        }
                   2750: 
1.67      bertrand 2751:        free(nom);
1.75      bertrand 2752: 
1.71      bertrand 2753: #      ifndef SEMAPHORES_NOMMES
                   2754:            sem_init(&((*s_queue_signaux).semaphore), 1, 1);
                   2755: #      else
1.80      bertrand 2756:            if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE))
1.72      bertrand 2757:                    == SEM_FAILED)
1.71      bertrand 2758:            {
                   2759:                (*s_etat_processus).erreur_systeme = d_es_processus;
                   2760:                return;
                   2761:            }
                   2762: #      endif
1.67      bertrand 2763: 
1.71      bertrand 2764:        (*s_queue_signaux).pointeur_lecture = 0;
                   2765:        (*s_queue_signaux).pointeur_ecriture = 0;
1.67      bertrand 2766: 
1.71      bertrand 2767:        if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0))
1.16      bertrand 2768:        {
1.71      bertrand 2769:            (*s_etat_processus).erreur_systeme = d_es_processus;
1.16      bertrand 2770:            return;
                   2771:        }
1.75      bertrand 2772: #  else // IPCS_SYSV
1.71      bertrand 2773: #      ifndef OS2
1.75      bertrand 2774:            int                             segment;
                   2775:            int                             support;
1.71      bertrand 2776: 
                   2777:            key_t                           clef;
1.67      bertrand 2778: 
1.71      bertrand 2779:            // Création d'un segment de données associé au PID du processus
                   2780:            // courant
1.16      bertrand 2781: 
1.71      bertrand 2782:            if ((nom = nom_segment((*s_etat_processus)
                   2783:                    .chemin_fichiers_temporaires, getpid())) == NULL)
                   2784:            {
                   2785:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2786:                return;
                   2787:            }
                   2788: 
1.76      bertrand 2789:            if ((support = open(nom, O_RDWR | O_CREAT | O_EXCL,
1.75      bertrand 2790:                    S_IRUSR | S_IWUSR)) == -1)
1.71      bertrand 2791:            {
                   2792:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   2793:                return;
                   2794:            }
                   2795: 
                   2796:            if ((clef = ftok(nom, 1)) == -1)
                   2797:            {
                   2798:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2799:                return;
                   2800:            }
1.1       bertrand 2801: 
1.75      bertrand 2802:            close(support);
1.71      bertrand 2803:            free(nom);
1.1       bertrand 2804: 
1.75      bertrand 2805:            if ((segment = shmget(clef, sizeof(struct_queue_signaux),
1.71      bertrand 2806:                    IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1)
                   2807:            {
                   2808:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2809:                return;
                   2810:            }
                   2811: 
1.75      bertrand 2812:            s_queue_signaux = shmat(segment, NULL, 0);
                   2813:            f_queue_signaux = segment;
1.71      bertrand 2814: 
1.75      bertrand 2815:            if (((void *) s_queue_signaux) == ((void *) -1))
1.71      bertrand 2816:            {
1.75      bertrand 2817:                if (shmctl(f_queue_signaux, IPC_RMID, 0) == -1)
1.71      bertrand 2818:                {
                   2819:                    (*s_etat_processus).erreur_systeme =
                   2820:                            d_es_allocation_memoire;
                   2821:                    return;
                   2822:                }
                   2823: 
                   2824:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2825:                return;
                   2826:            }
1.75      bertrand 2827: 
                   2828:            sem_init(&((*s_queue_signaux).semaphore), 1, 1);
                   2829:            (*s_queue_signaux).pointeur_lecture = 0;
                   2830:            (*s_queue_signaux).pointeur_ecriture = 0;
1.71      bertrand 2831: #      else // OS/2
                   2832:            if ((nom = nom_segment(NULL, getpid())) == NULL)
                   2833:            {
                   2834:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2835:                return;
                   2836:            }
                   2837: 
1.83      bertrand 2838:            if (DosAllocSharedMem((PVOID) &s_queue_signaux, nom,
                   2839:                    sizeof(struct_queue_signaux),
1.71      bertrand 2840:                    PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)
                   2841:            {
                   2842:                free(nom);
                   2843:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2844:                return;
                   2845:            }
1.67      bertrand 2846: 
1.71      bertrand 2847:            free(nom);
1.83      bertrand 2848: 
                   2849:            sem_init(&((*s_queue_signaux).semaphore), 1, 1);
                   2850:            (*s_queue_signaux).pointeur_lecture = 0;
                   2851:            (*s_queue_signaux).pointeur_ecriture = 0;
1.71      bertrand 2852: #      endif
1.67      bertrand 2853: #  endif
                   2854: 
1.1       bertrand 2855:    return;
                   2856: }
                   2857: 
1.67      bertrand 2858: 
                   2859: /*
                   2860: ================================================================================
                   2861:   Fonction libérant le segment de mémoire partagée destiné à contenir
                   2862:   la queue des signaux.
                   2863: ================================================================================
                   2864:   Entrée : structure de description du processus
                   2865: --------------------------------------------------------------------------------
                   2866:   Sortie : Néant
                   2867: --------------------------------------------------------------------------------
                   2868:   Effet de bord : Néant
                   2869: ================================================================================
                   2870: */
                   2871: 
                   2872: void
                   2873: liberation_queue_signaux(struct_processus *s_etat_processus)
1.66      bertrand 2874: {
1.67      bertrand 2875: #  ifdef IPCS_SYSV // SystemV
                   2876: #      ifndef OS2
1.75      bertrand 2877:            if (shmdt(s_queue_signaux) == -1)
                   2878:            {
                   2879:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2880:                return;
                   2881:            }
1.67      bertrand 2882: #      else // OS/2
                   2883: #      endif
                   2884: #  else // POSIX
1.72      bertrand 2885: #      ifndef SEMAPHORES_NOMMES
                   2886:            sem_close(&((*s_queue_signaux).semaphore));
                   2887: #      else
                   2888:            sem_close(semaphore_queue_signaux);
                   2889: #      endif
1.70      bertrand 2890: 
1.67      bertrand 2891:        if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
1.66      bertrand 2892:        {
1.67      bertrand 2893:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2894:            return;
1.66      bertrand 2895:        }
1.69      bertrand 2896: 
                   2897:        close(f_queue_signaux);
1.67      bertrand 2898: #  endif
1.66      bertrand 2899: 
                   2900:    return;
                   2901: }
                   2902: 
1.67      bertrand 2903: 
                   2904: /*
                   2905: ================================================================================
                   2906:   Fonction détruisant le segment de mémoire partagée destiné à contenir
                   2907:   la queue des signaux.
                   2908: ================================================================================
                   2909:   Entrée : structure de description du processus
                   2910: --------------------------------------------------------------------------------
                   2911:   Sortie : Néant
                   2912: --------------------------------------------------------------------------------
                   2913:   Effet de bord : Néant
                   2914: ================================================================================
                   2915: */
                   2916: 
1.66      bertrand 2917: void
1.67      bertrand 2918: destruction_queue_signaux(struct_processus *s_etat_processus)
1.66      bertrand 2919: {
1.83      bertrand 2920: #  ifndef OS2
                   2921:        unsigned char       *nom;
                   2922: #  endif
1.66      bertrand 2923: 
1.67      bertrand 2924: #  ifdef IPCS_SYSV // SystemV
1.71      bertrand 2925: #      ifndef OS2
1.75      bertrand 2926:            // Il faut commencer par éliminer le sémaphore.
                   2927: 
                   2928:            if (semctl((*s_queue_signaux).semaphore.sem, 0, IPC_RMID) == -1)
                   2929:            {
                   2930:                (*s_etat_processus).erreur_systeme = d_es_processus;
                   2931:                return;
                   2932:            }
                   2933: 
                   2934:            unlink((*s_queue_signaux).semaphore.path);
                   2935: 
                   2936:            if (shmdt(s_queue_signaux) == -1)
1.71      bertrand 2937:            {
                   2938:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2939:                return;
                   2940:            }
                   2941: 
1.75      bertrand 2942:            if (shmctl(f_queue_signaux, IPC_RMID, 0) == -1)
1.71      bertrand 2943:            {
                   2944:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2945:                return;
                   2946:            }
                   2947: 
                   2948:            if ((nom = nom_segment((*s_etat_processus)
                   2949:                    .chemin_fichiers_temporaires, getpid())) == NULL)
                   2950:            {
                   2951:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2952:                return;
                   2953:            }
1.66      bertrand 2954: 
1.71      bertrand 2955:            unlink(nom);
                   2956:            free(nom);
                   2957: #      else
1.83      bertrand 2958:            sem_close(&((*s_queue_signaux).semaphore));
                   2959:            sem_destroy(&((*s_queue_signaux).semaphore));
                   2960: 
                   2961:            if (DosFreeMem(s_queue_signaux) != 0)
1.71      bertrand 2962:            {
                   2963:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2964:                return;
                   2965:            }
                   2966: #      endif
1.67      bertrand 2967: #  else // POSIX
1.72      bertrand 2968: #      ifndef SEMAPHORES_NOMMES
                   2969:            sem_close(&((*s_queue_signaux).semaphore));
                   2970:            sem_destroy(&((*s_queue_signaux).semaphore));
                   2971: #      else
                   2972:            sem_close(semaphore_queue_signaux);
1.80      bertrand 2973:            sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);
1.72      bertrand 2974: #      endif
1.67      bertrand 2975: 
1.70      bertrand 2976:        if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
                   2977:        {
                   2978:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2979:            return;
                   2980:        }
                   2981: 
                   2982:        if ((nom = nom_segment(NULL, getpid())) == NULL)
                   2983:        {
                   2984:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2985:            return;
                   2986:        }
1.66      bertrand 2987: 
1.70      bertrand 2988:        close(f_queue_signaux);
1.66      bertrand 2989: 
1.70      bertrand 2990:        if (shm_unlink(nom) != 0)
                   2991:        {
                   2992:            free(nom);
                   2993:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2994:            return;
                   2995:        }
1.69      bertrand 2996: 
1.67      bertrand 2997:        free(nom);
                   2998: #  endif
                   2999: 
1.66      bertrand 3000:    return;
                   3001: }
                   3002: 
1.1       bertrand 3003: // vim: ts=4

CVSweb interface <joel.bertrand@systella.fr>