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

1.1       bertrand    1: /*
                      2: ================================================================================
1.82      bertrand    3:   RPL/2 (R) version 4.1.4
1.45      bertrand    4:   Copyright (C) 1989-2011 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: 
                   1776:    if (signal != SIGUSR2)
                   1777:    {
                   1778:        write(STDERR_FILENO, message_1, strlen(message_1));
                   1779:    }
                   1780:    else
                   1781:    {
                   1782:        write(STDERR_FILENO, message_2, strlen(message_2));
1.66      bertrand 1783:    }
                   1784: 
                   1785:    _exit(EXIT_FAILURE);
                   1786: }
                   1787: 
1.81      bertrand 1788: 
                   1789: static void
                   1790: sortie_interruption_depassement_pile(void *arg1, void *arg2, void *arg3)
1.66      bertrand 1791: {
1.81      bertrand 1792:    switch((*((volatile int *) arg1)))
                   1793:    {
                   1794:        case 1:
                   1795:            longjmp(contexte_ecriture, -1);
                   1796:            break;
1.63      bertrand 1797: 
1.81      bertrand 1798:        case 2:
                   1799:            longjmp(contexte_impression, -1);
                   1800:            break;
                   1801:    }
1.1       bertrand 1802: 
1.81      bertrand 1803:    return;
                   1804: }
1.32      bertrand 1805: 
1.1       bertrand 1806: 
1.81      bertrand 1807: void
                   1808: interruption_depassement_pile(int urgence, stackoverflow_context_t scp)
                   1809: {
                   1810:    if ((urgence == 0) && (routine_recursive != 0))
1.1       bertrand 1811:    {
1.81      bertrand 1812:        // On peut tenter de récupérer le dépassement de pile. Si la variable
                   1813:        // 'routine_recursive' est non nulle, on récupère l'erreur.
1.1       bertrand 1814: 
1.81      bertrand 1815:        sigsegv_leave_handler(sortie_interruption_depassement_pile,
                   1816:                (void *) &routine_recursive, NULL, NULL);
1.1       bertrand 1817:    }
                   1818: 
1.81      bertrand 1819:    // Ici, la panique est totale et il vaut mieux quitter l'application.
                   1820:    interruption3(SIGUSR2);
                   1821:    return;
                   1822: }
1.1       bertrand 1823: 
                   1824: 
1.81      bertrand 1825: int
                   1826: interruption_violation_access(void *adresse_fautive, int gravite)
                   1827: {
                   1828:    unsigned char       message[] = "+++System : Trying to catch access "
                   1829:                                "violation\n";
1.63      bertrand 1830: 
1.81      bertrand 1831:    static int              compteur_erreur = 0;
1.63      bertrand 1832: 
1.81      bertrand 1833:    if ((gravite == 0) && (routine_recursive != 0))
                   1834:    {
                   1835:        // Il peut s'agir d'un dépassement de pile.
1.63      bertrand 1836: 
1.81      bertrand 1837:        sigsegv_leave_handler(sortie_interruption_depassement_pile,
                   1838:                (void *) &routine_recursive, NULL, NULL);
                   1839:    }
1.63      bertrand 1840: 
1.81      bertrand 1841:    // On est dans une bonne vieille violation d'accès. On essaie
                   1842:    // de fermer au mieux l'application.
1.63      bertrand 1843: 
1.81      bertrand 1844:    compteur_erreur++;
1.63      bertrand 1845: 
1.81      bertrand 1846:    if (compteur_erreur >= 2)
                   1847:    {
                   1848:        // Erreurs multiples, on arrête l'application.
                   1849:        interruption3(SIGSEGV);
                   1850:        return(0);
                   1851:    }
1.63      bertrand 1852: 
1.81      bertrand 1853:    write(STDERR_FILENO, message, strlen(message));
1.63      bertrand 1854: 
1.81      bertrand 1855:    if (pid_processus_pere == getpid())
                   1856:    {
                   1857:        longjmp(contexte_initial, -1);
                   1858:        return(1);
                   1859:    }
                   1860:    else
                   1861:    {
                   1862:        longjmp(contexte_processus, -1);
                   1863:        return(1);
1.1       bertrand 1864:    }
                   1865: 
1.81      bertrand 1866:    // On renvoie 0 parce qu'on décline toute responsabilité quant à la
                   1867:    // suite des événements...
                   1868:    return(0);
1.1       bertrand 1869: }
1.67      bertrand 1870: 
                   1871: // Traitement de rpl_sigstart
1.1       bertrand 1872: 
1.67      bertrand 1873: static inline void
                   1874: signal_start(struct_processus *s_etat_processus, pid_t pid)
1.1       bertrand 1875: {
1.69      bertrand 1876:    struct_processus        *s_thread_principal;
                   1877: 
                   1878:    verrouillage_gestionnaire_signaux(s_etat_processus);
                   1879: 
                   1880:    if (pid == getpid())
                   1881:    {
                   1882:        (*s_etat_processus).demarrage_fils = d_vrai;
                   1883:    }
                   1884:    else
                   1885:    {
                   1886:        // Envoi d'un signal au thread maître du groupe.
                   1887: 
                   1888:        if ((s_thread_principal = recherche_thread_principal(getpid()))
                   1889:                != NULL)
                   1890:        {
                   1891:            envoi_signal_contexte(s_thread_principal, rpl_sigstart);
                   1892:        }
                   1893:    }
                   1894: 
                   1895:    deverrouillage_gestionnaire_signaux(s_etat_processus);
1.67      bertrand 1896:    return;
                   1897: }
1.32      bertrand 1898: 
1.67      bertrand 1899: // Traitement de rpl_sigcont
1.1       bertrand 1900: 
1.67      bertrand 1901: static inline void
                   1902: signal_cont(struct_processus *s_etat_processus, pid_t pid)
                   1903: {
1.69      bertrand 1904:    struct_processus        *s_thread_principal;
                   1905: 
                   1906:    verrouillage_gestionnaire_signaux(s_etat_processus);
                   1907: 
                   1908:    if (pid == getpid())
                   1909:    {
                   1910:        (*s_etat_processus).redemarrage_processus = d_vrai;
                   1911:    }
                   1912:    else
                   1913:    {
                   1914:        // Envoi d'un signal au thread maître du groupe.
                   1915: 
                   1916:        if ((s_thread_principal = recherche_thread_principal(getpid()))
                   1917:                != NULL)
                   1918:        {
                   1919:            envoi_signal_contexte(s_thread_principal, rpl_sigcont);
                   1920:        }
                   1921:    }
                   1922: 
                   1923:    deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 1924:    return;
                   1925: }
                   1926: 
1.67      bertrand 1927: // Traitement de rpl_sigstop
                   1928: 
                   1929: static inline void
                   1930: signal_stop(struct_processus *s_etat_processus, pid_t pid)
1.1       bertrand 1931: {
1.67      bertrand 1932:    struct_processus        *s_thread_principal;
1.1       bertrand 1933: 
1.68      bertrand 1934:    verrouillage_gestionnaire_signaux(s_etat_processus);
1.32      bertrand 1935: 
1.30      bertrand 1936:    if (pid == getpid())
1.1       bertrand 1937:    {
                   1938:        if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
                   1939:                == NULL)
                   1940:        {
1.68      bertrand 1941:            deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 1942:            return;
                   1943:        }
                   1944: 
                   1945:        if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
                   1946:        {
1.69      bertrand 1947:            printf("[%d] RPL/SIGSTOP (thread %llu)\n", (int) getpid(),
1.16      bertrand 1948:                    (unsigned long long) pthread_self());
                   1949:            fflush(stdout);
1.1       bertrand 1950:        }
                   1951: 
                   1952:        /*
                   1953:         * var_globale_traitement_retarde_stop :
                   1954:         *  0 -> traitement immédiat
                   1955:         *  1 -> traitement retardé (aucun signal reçu)
                   1956:         * -1 -> traitement retardé (un ou plusieurs signaux stop reçus)
                   1957:         */
                   1958: 
1.11      bertrand 1959:        if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)
1.1       bertrand 1960:        {
1.11      bertrand 1961:            (*s_etat_processus).var_volatile_requete_arret = -1;
1.1       bertrand 1962:        }
                   1963:        else
                   1964:        {
1.11      bertrand 1965:            (*s_etat_processus).var_volatile_traitement_retarde_stop = -1;
1.1       bertrand 1966:        }
                   1967:    }
                   1968:    else
                   1969:    {
                   1970:        // Envoi d'un signal au thread maître du groupe.
                   1971: 
1.67      bertrand 1972:        if ((s_thread_principal = recherche_thread_principal(getpid()))
                   1973:                != NULL)
1.1       bertrand 1974:        {
1.67      bertrand 1975:            envoi_signal_contexte(s_thread_principal, rpl_sigstop);
1.1       bertrand 1976:        }
                   1977:    }
                   1978: 
1.68      bertrand 1979:    deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 1980:    return;
                   1981: }
                   1982: 
1.67      bertrand 1983: // Traitement de rpl_siginject
                   1984: 
                   1985: static inline void
                   1986: signal_inject(struct_processus *s_etat_processus, pid_t pid)
1.1       bertrand 1987: {
1.68      bertrand 1988:    verrouillage_gestionnaire_signaux(s_etat_processus);
1.32      bertrand 1989: 
1.1       bertrand 1990:    if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
                   1991:    {
1.68      bertrand 1992:        deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 1993:        return;
                   1994:    }
                   1995: 
                   1996:    if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
                   1997:    {
1.67      bertrand 1998:        printf("[%d] RPL/SIGINJECT (thread %llu)\n", (int) getpid(),
1.1       bertrand 1999:                (unsigned long long) pthread_self());
                   2000:        fflush(stdout);
                   2001:    }
                   2002: 
1.68      bertrand 2003:    deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 2004:    return;
                   2005: }
                   2006: 
1.67      bertrand 2007: // Récupération des signaux
                   2008: // - SIGPIPE
                   2009: 
1.1       bertrand 2010: void
1.67      bertrand 2011: interruption5(int signal)
1.1       bertrand 2012: {
1.67      bertrand 2013:    unsigned char       message[] = "+++System : SIGPIPE\n"
                   2014:                                "+++System : Aborting !\n";
1.1       bertrand 2015: 
1.65      bertrand 2016:    test_signal(signal);
1.32      bertrand 2017: 
1.67      bertrand 2018:    if (pid_processus_pere == getpid())
1.1       bertrand 2019:    {
1.67      bertrand 2020:        envoi_signal_processus(pid_processus_pere, rpl_sigalrm);
1.1       bertrand 2021:    }
                   2022: 
1.67      bertrand 2023:    write(STDERR_FILENO, message, strlen(message));
1.1       bertrand 2024:    return;
                   2025: }
                   2026: 
1.67      bertrand 2027: static inline void
                   2028: signal_urg(struct_processus *s_etat_processus, pid_t pid)
1.1       bertrand 2029: {
1.67      bertrand 2030:    struct_processus        *s_thread_principal;
1.30      bertrand 2031: 
1.68      bertrand 2032:    verrouillage_gestionnaire_signaux(s_etat_processus);
1.32      bertrand 2033: 
1.30      bertrand 2034:    if (pid == getpid())
1.1       bertrand 2035:    {
                   2036:        if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
                   2037:                == NULL)
                   2038:        {
1.68      bertrand 2039:            deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 2040:            return;
                   2041:        }
                   2042: 
                   2043:        if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
                   2044:        {
1.67      bertrand 2045:            printf("[%d] RPL/SIGURG (thread %llu)\n", (int) getpid(),
1.1       bertrand 2046:                    (unsigned long long) pthread_self());
                   2047:            fflush(stdout);
                   2048:        }
                   2049: 
                   2050:        (*s_etat_processus).var_volatile_alarme = -1;
                   2051:        (*s_etat_processus).var_volatile_requete_arret = -1;
                   2052:    }
                   2053:    else
                   2054:    {
                   2055:        // Envoi d'un signal au thread maître du groupe.
                   2056: 
1.67      bertrand 2057:        if ((s_thread_principal = recherche_thread_principal(getpid()))
                   2058:                != NULL)
1.1       bertrand 2059:        {
1.67      bertrand 2060:            envoi_signal_contexte(s_thread_principal, rpl_sigurg);
1.1       bertrand 2061:        }
                   2062:    }
                   2063: 
1.68      bertrand 2064:    deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 2065:    return;
                   2066: }
                   2067: 
1.67      bertrand 2068: // Traitement de rpl_sigabort
                   2069: 
                   2070: static inline void
                   2071: signal_abort(struct_processus *s_etat_processus, pid_t pid)
1.1       bertrand 2072: {
1.67      bertrand 2073:    struct_processus        *s_thread_principal;
1.1       bertrand 2074: 
1.68      bertrand 2075:    verrouillage_gestionnaire_signaux(s_etat_processus);
1.32      bertrand 2076: 
1.1       bertrand 2077:    if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
                   2078:    {
1.68      bertrand 2079:        deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 2080:        return;
                   2081:    }
                   2082: 
                   2083:    if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
                   2084:    {
1.67      bertrand 2085:        printf("[%d] RPL/SIGABORT (thread %llu)\n", (int) getpid(),
1.1       bertrand 2086:                (unsigned long long) pthread_self());
                   2087:        fflush(stdout);
                   2088:    }
                   2089: 
1.67      bertrand 2090:    if (pid == getpid())
1.30      bertrand 2091:    {
1.67      bertrand 2092:        if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
                   2093:                == NULL)
                   2094:        {
1.68      bertrand 2095:            deverrouillage_gestionnaire_signaux(s_etat_processus);
1.67      bertrand 2096:            return;
                   2097:        }
1.30      bertrand 2098: 
1.67      bertrand 2099:        (*s_etat_processus).arret_depuis_abort = -1;
                   2100: 
                   2101:        /*
                   2102:         * var_globale_traitement_retarde_stop :
                   2103:         *  0 -> traitement immédiat
                   2104:         *  1 -> traitement retardé (aucun signal reçu)
                   2105:         * -1 -> traitement retardé (un ou plusieurs signaux stop reçus)
                   2106:         */
                   2107: 
                   2108:        if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)
                   2109:        {
                   2110:            (*s_etat_processus).var_volatile_requete_arret = -1;
                   2111:        }
                   2112:        else
                   2113:        {
                   2114:            (*s_etat_processus).var_volatile_traitement_retarde_stop = -1;
                   2115:        }
                   2116:    }
                   2117:    else
                   2118:    {
                   2119:        (*s_etat_processus).arret_depuis_abort = -1;
                   2120: 
                   2121:        // Envoi d'un signal au thread maître du groupe.
                   2122: 
                   2123:        if ((s_thread_principal = recherche_thread_principal(getpid()))
                   2124:                != NULL)
                   2125:        {
                   2126:            envoi_signal_contexte(s_thread_principal, rpl_sigabort);
                   2127:        }
                   2128:    }
                   2129: 
1.68      bertrand 2130:    deverrouillage_gestionnaire_signaux(s_etat_processus);
1.67      bertrand 2131:    return;
                   2132: }
                   2133: 
                   2134: // Récupération des signaux
                   2135: // - SIGHUP
1.1       bertrand 2136: 
                   2137: void
1.67      bertrand 2138: interruption4(int signal)
                   2139: {
                   2140:    test_signal(signal);
                   2141:    envoi_signal_processus(getpid(), rpl_sighup);
                   2142:    return;
                   2143: }
                   2144: 
                   2145: static inline void
                   2146: signal_hup(struct_processus *s_etat_processus, pid_t pid)
1.1       bertrand 2147: {
                   2148:    file                    *fichier;
                   2149: 
                   2150:    unsigned char           nom[8 + 64 + 1];
                   2151: 
1.68      bertrand 2152:    verrouillage_gestionnaire_signaux(s_etat_processus);
1.32      bertrand 2153: 
1.1       bertrand 2154:    if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
                   2155:    {
1.68      bertrand 2156:        deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 2157:        return;
                   2158:    }
                   2159: 
                   2160:    snprintf(nom, 8 + 64 + 1, "rpl-out-%lu-%lu", (unsigned long) getpid(),
                   2161:            (unsigned long) pthread_self());
                   2162: 
                   2163:    if ((fichier = fopen(nom, "w+")) != NULL)
                   2164:    {
                   2165:        fclose(fichier);
                   2166: 
                   2167:        freopen(nom, "w", stdout);
                   2168:        freopen(nom, "w", stderr);
                   2169:    }
                   2170: 
                   2171:    freopen("/dev/null", "r", stdin);
                   2172: 
                   2173:    if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
                   2174:    {
1.69      bertrand 2175:        printf("[%d] RPL/SIGHUP (thread %llu)\n", (int) getpid(),
1.1       bertrand 2176:                (unsigned long long) pthread_self());
                   2177:        fflush(stdout);
                   2178:    }
                   2179: 
1.68      bertrand 2180:    deverrouillage_gestionnaire_signaux(s_etat_processus);
1.1       bertrand 2181:    return;
                   2182: }
                   2183: 
                   2184: void
1.67      bertrand 2185: traitement_exceptions_gsl(const char *reason, const char *file,
                   2186:        int line, int gsl_errno)
                   2187: {
1.68      bertrand 2188:    code_erreur_gsl = gsl_errno;
                   2189:    envoi_signal_processus(getpid(), rpl_sigexcept);
                   2190:    return;
                   2191: }
1.67      bertrand 2192: 
1.68      bertrand 2193: static inline void
                   2194: signal_except(struct_processus *s_etat_processus, pid_t pid)
                   2195: {
                   2196:    verrouillage_gestionnaire_signaux(s_etat_processus);
1.67      bertrand 2197: 
                   2198:    if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
                   2199:    {
1.68      bertrand 2200:        deverrouillage_gestionnaire_signaux(s_etat_processus);
1.67      bertrand 2201:        return;
                   2202:    }
                   2203: 
1.68      bertrand 2204:    (*s_etat_processus).var_volatile_exception_gsl = code_erreur_gsl;
                   2205:    deverrouillage_gestionnaire_signaux(s_etat_processus);
                   2206: 
1.67      bertrand 2207:    return;
                   2208: }
                   2209: 
                   2210: static inline void
                   2211: envoi_interruptions(struct_processus *s_etat_processus, enum signaux_rpl signal,
                   2212:        pid_t pid_source)
1.16      bertrand 2213: {
1.67      bertrand 2214:    switch(signal)
                   2215:    {
1.69      bertrand 2216:        case rpl_signull:
                   2217:            break;
                   2218: 
1.67      bertrand 2219:        case rpl_sigint:
                   2220:            signal_int(s_etat_processus, pid_source);
                   2221:            break;
                   2222: 
                   2223:        case rpl_sigterm:
                   2224:            signal_term(s_etat_processus, pid_source);
                   2225:            break;
                   2226: 
                   2227:        case rpl_sigstart:
                   2228:            signal_start(s_etat_processus, pid_source);
                   2229:            break;
                   2230: 
                   2231:        case rpl_sigcont:
                   2232:            signal_cont(s_etat_processus, pid_source);
                   2233:            break;
                   2234: 
                   2235:        case rpl_sigstop:
                   2236:            signal_stop(s_etat_processus, pid_source);
                   2237:            break;
1.30      bertrand 2238: 
1.67      bertrand 2239:        case rpl_sigabort:
                   2240:            signal_abort(s_etat_processus, pid_source);
                   2241:            break;
                   2242: 
                   2243:        case rpl_sigurg:
                   2244:            signal_urg(s_etat_processus, pid_source);
                   2245:            break;
                   2246: 
                   2247:        case rpl_siginject:
                   2248:            signal_inject(s_etat_processus, pid_source);
                   2249:            break;
                   2250: 
                   2251:        case rpl_sigalrm:
                   2252:            signal_alrm(s_etat_processus, pid_source);
                   2253:            break;
                   2254: 
                   2255:        case rpl_sighup:
                   2256:            signal_hup(s_etat_processus, pid_source);
                   2257:            break;
                   2258: 
                   2259:        case rpl_sigtstp:
                   2260:            signal_tstp(s_etat_processus, pid_source);
                   2261:            break;
                   2262: 
1.68      bertrand 2263:        case rpl_sigexcept:
                   2264:            signal_except(s_etat_processus, pid_source);
                   2265:            break;
                   2266: 
1.67      bertrand 2267:        default:
1.69      bertrand 2268:            if ((*s_etat_processus).langue == 'F')
                   2269:            {
                   2270:                printf("+++System : Spurious signal (%d) !\n", signal);
                   2271:            }
                   2272:            else
                   2273:            {
                   2274:                printf("+++System : Signal inconnu (%d) !\n", signal);
                   2275:            }
                   2276: 
1.67      bertrand 2277:            break;
                   2278:    }
1.30      bertrand 2279: 
1.67      bertrand 2280:    return;
                   2281: }
1.16      bertrand 2282: 
1.67      bertrand 2283: void
                   2284: scrutation_interruptions(struct_processus *s_etat_processus)
                   2285: {
                   2286:    // Interruptions qui arrivent sur le processus depuis un
                   2287:    // processus externe.
1.32      bertrand 2288: 
1.68      bertrand 2289:    // Les pointeurs de lecture pointent sur les prochains éléments
                   2290:    // à lire. Les pointeurs d'écriture pointent sur les prochains éléments à
                   2291:    // écrire.
                   2292: 
1.72      bertrand 2293: #  ifndef SEMAPHORES_NOMMES
                   2294:        if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0)
                   2295: #  else
                   2296:        if (sem_trywait(semaphore_queue_signaux) == 0)
                   2297: #  endif
1.68      bertrand 2298:    {
                   2299:        if ((*s_queue_signaux).pointeur_lecture !=
                   2300:                (*s_queue_signaux).pointeur_ecriture)
                   2301:        {
                   2302:            // Il y a un signal en attente dans le segment partagé. On le
                   2303:            // traite.
                   2304: 
                   2305:            envoi_interruptions(s_etat_processus,
                   2306:                    (*s_queue_signaux).queue[(*s_queue_signaux)
                   2307:                    .pointeur_lecture].signal, (*s_queue_signaux).queue
                   2308:                    [(*s_queue_signaux).pointeur_lecture].pid);
                   2309:            (*s_queue_signaux).pointeur_lecture =
                   2310:                    ((*s_queue_signaux).pointeur_lecture + 1)
                   2311:                    % LONGUEUR_QUEUE_SIGNAUX;
                   2312:        }
                   2313: 
1.72      bertrand 2314: #      ifndef SEMAPHORES_NOMMES
                   2315:            sem_post(&((*s_queue_signaux).semaphore));
                   2316: #      else
                   2317:            sem_post(semaphore_queue_signaux);
                   2318: #      endif
1.68      bertrand 2319:    }
                   2320: 
1.67      bertrand 2321:    // Interruptions qui arrivent depuis le groupe courant de threads.
1.29      bertrand 2322: 
1.68      bertrand 2323:    if (pthread_mutex_trylock(&mutex_interruptions) == 0)
1.16      bertrand 2324:    {
1.68      bertrand 2325:        if ((*s_etat_processus).pointeur_signal_lecture !=
                   2326:                (*s_etat_processus).pointeur_signal_ecriture)
                   2327:        {
                   2328:            // Il y a un signal dans la queue du thread courant. On le traite.
                   2329: 
                   2330:            envoi_interruptions(s_etat_processus,
                   2331:                    (*s_etat_processus).signaux_en_queue
                   2332:                    [(*s_etat_processus).pointeur_signal_lecture],
                   2333:                    getpid());
                   2334:            (*s_etat_processus).pointeur_signal_lecture =
                   2335:                    ((*s_etat_processus).pointeur_signal_lecture + 1)
                   2336:                    % LONGUEUR_QUEUE_SIGNAUX;
                   2337:        }
                   2338: 
                   2339:        pthread_mutex_unlock(&mutex_interruptions);
1.67      bertrand 2340:    }
                   2341: 
                   2342:    return;
                   2343: }
                   2344: 
1.69      bertrand 2345: /*
                   2346: ================================================================================
                   2347:   Fonction renvoyant le nom du segment de mémoire partagée en fonction
                   2348:   du pid du processus.
                   2349: ================================================================================
                   2350:   Entrée : Chemin absolue servant de racine, pid du processus
                   2351: --------------------------------------------------------------------------------
                   2352:   Sortie : NULL ou nom du segment
                   2353: --------------------------------------------------------------------------------
                   2354:   Effet de bord : Néant
                   2355: ================================================================================
                   2356: */
                   2357: 
                   2358: static unsigned char *
                   2359: nom_segment(unsigned char *chemin, pid_t pid)
                   2360: {
                   2361:    unsigned char               *fichier;
                   2362: 
                   2363: #  ifdef IPCS_SYSV // !POSIX
                   2364: #      ifndef OS2 // !OS2
                   2365:            if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) *
                   2366:                    sizeof(unsigned char))) == NULL)
                   2367:            {
                   2368:                return(NULL);
                   2369:            }
                   2370: 
                   2371:            sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid);
                   2372: #      else // OS2
                   2373:            if ((fichier = malloc((10 + 256 + 1) * sizeof(unsigned char)))
                   2374:                    == NULL)
                   2375:            {
                   2376:                return(NULL);
                   2377:            }
                   2378: 
                   2379:            sprintf(fichier, "\\SHAREMEM\\RPL-SIGQUEUES-%d", (int) pid);
                   2380: #      endif // OS2
                   2381: #  else // POSIX
                   2382: 
                   2383:        if ((fichier = malloc((1 + 256 + 1) *
                   2384:                sizeof(unsigned char))) == NULL)
                   2385:        {
                   2386:            return(NULL);
                   2387:        }
                   2388: 
                   2389:        sprintf(fichier, "/RPL-SIGQUEUES-%d", (int) pid);
                   2390: #  endif
                   2391: 
                   2392:    return(fichier);
                   2393: }
                   2394: 
                   2395: 
1.71      bertrand 2396: /*
                   2397: ================================================================================
                   2398:   Fonctions d'envoi d'un signal à un thread ou à un processus.
                   2399: ================================================================================
                   2400:   Entrée : processus et signal
                   2401: --------------------------------------------------------------------------------
                   2402:   Sortie : erreur
                   2403: --------------------------------------------------------------------------------
                   2404:   Effet de bord : Néant
                   2405: ================================================================================
                   2406: */
                   2407: 
1.67      bertrand 2408: int
                   2409: envoi_signal_processus(pid_t pid, enum signaux_rpl signal)
                   2410: {
1.83    ! bertrand 2411: #  ifndef OS2
        !          2412:        int                         segment;
        !          2413: #  endif
1.69      bertrand 2414: 
1.75      bertrand 2415: #  ifndef IPCS_SYSV
                   2416: #      ifdef SEMAPHORES_NOMMES
                   2417:            sem_t                   *semaphore;
                   2418: #      endif
                   2419: #  else
1.83    ! bertrand 2420: #      ifndef OS2
        !          2421:            int                     desc;
        !          2422:            key_t                   clef;
        !          2423: #      endif
1.75      bertrand 2424: #  endif
1.72      bertrand 2425: 
1.69      bertrand 2426:    struct_queue_signaux            *queue;
                   2427: 
                   2428:    unsigned char                   *nom;
                   2429: 
1.67      bertrand 2430:    // Il s'agit d'ouvrir le segment de mémoire partagée, de le projeter en
                   2431:    // mémoire puis d'y inscrire le signal à traiter.
                   2432: 
1.69      bertrand 2433:    if (pid == getpid())
                   2434:    {
                   2435:        // Le signal est envoyé au même processus.
                   2436: 
                   2437:        if (s_queue_signaux == NULL)
                   2438:        {
                   2439:            return(1);
                   2440:        }
                   2441: 
1.72      bertrand 2442: #      ifndef SEMAPHORES_NOMMES
1.78      bertrand 2443:            while(sem_wait(&((*s_queue_signaux).semaphore)) != 0)
1.72      bertrand 2444: #      else
1.78      bertrand 2445:            while(sem_wait(semaphore_queue_signaux) != 0)
1.72      bertrand 2446: #      endif
1.69      bertrand 2447:        {
1.78      bertrand 2448:            if (errno != EINTR)
                   2449:            {
                   2450:                return(1);
                   2451:            }
1.69      bertrand 2452:        }
                   2453: 
                   2454:        (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture]
                   2455:                .pid = pid;
                   2456:        (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture]
                   2457:                .signal = signal;
                   2458: 
                   2459:        (*s_queue_signaux).pointeur_ecriture =
                   2460:                ((*s_queue_signaux).pointeur_ecriture + 1)
                   2461:                % LONGUEUR_QUEUE_SIGNAUX;
                   2462: 
1.72      bertrand 2463: #      ifndef SEMAPHORES_NOMMES
                   2464:            if (sem_post(&((*s_queue_signaux).semaphore)) != 0)
                   2465: #      else
                   2466:            if (sem_post(semaphore_queue_signaux) != 0)
                   2467: #      endif
1.69      bertrand 2468:        {
                   2469:            return(1);
                   2470:        }
                   2471:    }
                   2472:    else
                   2473:    {
                   2474:        // Le signal est envoyé depuis un processus distinct.
                   2475: 
1.75      bertrand 2476: #      ifdef IPCS_SYSV
1.76      bertrand 2477:            if ((nom = nom_segment(racine_segment, pid)) == NULL)
1.75      bertrand 2478:            {
                   2479:                return(1);
                   2480:            }
                   2481: 
1.83    ! bertrand 2482: #          ifndef OS2 // SysV
        !          2483:                if ((desc = open(nom, O_RDWR)) == -1)
        !          2484:                {
        !          2485:                    free(nom);
        !          2486:                    return(1);
        !          2487:                }
        !          2488: 
        !          2489:                close(desc);
1.75      bertrand 2490: 
1.83    ! bertrand 2491:                if ((clef = ftok(nom, 1)) == -1)
        !          2492:                {
        !          2493:                    free(nom);
        !          2494:                    return(1);
        !          2495:                }
1.75      bertrand 2496: 
                   2497:                free(nom);
1.69      bertrand 2498: 
1.83    ! bertrand 2499:                if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0))
        !          2500:                        == -1)
        !          2501:                {
        !          2502:                    return(1);
        !          2503:                }
1.69      bertrand 2504: 
1.83    ! bertrand 2505:                queue = shmat(segment, NULL, 0);
        !          2506: #          else // OS/2
        !          2507:                if (DosGetNamedSharedMem((PVOID) &queue, nom,
        !          2508:                        PAG_WRITE | PAG_READ) != 0)
        !          2509:                {
        !          2510:                    free(nom);
        !          2511:                    return(1);
        !          2512:                }
1.69      bertrand 2513: 
1.83    ! bertrand 2514:                free(nom);
        !          2515: #          endif
1.75      bertrand 2516: #      else // POSIX
                   2517:            if ((nom = nom_segment(racine_segment, pid)) == NULL)
                   2518:            {
                   2519:                return(1);
                   2520:            }
1.69      bertrand 2521: 
1.75      bertrand 2522:            if ((segment = shm_open(nom, O_RDWR, 0)) == -1)
1.72      bertrand 2523:            {
1.75      bertrand 2524:                free(nom);
1.72      bertrand 2525:                return(1);
                   2526:            }
1.75      bertrand 2527: 
                   2528:            free(nom);
                   2529: 
                   2530:            if ((queue = mmap(NULL, sizeof(struct_queue_signaux),
                   2531:                    PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0)) ==
                   2532:                    MAP_FAILED)
1.72      bertrand 2533:            {
1.75      bertrand 2534:                close(segment);
1.72      bertrand 2535:                return(1);
                   2536:            }
1.75      bertrand 2537: #      endif
1.72      bertrand 2538: 
1.75      bertrand 2539:            // À ce moment, le segment de mémoire partagée est projeté
                   2540:            // dans l'espace du processus.
                   2541: 
                   2542: #      ifndef IPCS_SYSV // POSIX
                   2543: #          ifndef SEMAPHORES_NOMMES
1.78      bertrand 2544:                while(sem_wait(&((*queue).semaphore)) != 0)
1.75      bertrand 2545:                {
1.78      bertrand 2546:                    if (errno != EINTR)
                   2547:                    {
                   2548:                        return(1);
                   2549:                    }
1.75      bertrand 2550:                }
                   2551: #          else
1.80      bertrand 2552:                if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED)
1.75      bertrand 2553:                {
                   2554:                    return(1);
                   2555:                }
                   2556: 
1.78      bertrand 2557:                while(sem_wait(semaphore) != 0)
1.75      bertrand 2558:                {
1.78      bertrand 2559:                    if (errno != EINTR)
                   2560:                    {
                   2561:                        sem_close(semaphore);
                   2562:                        return(1);
                   2563:                    }
1.75      bertrand 2564:                }
                   2565: #          endif
                   2566: #      else // IPCS_SYSV
1.78      bertrand 2567:            while(sem_wait(&((*queue).semaphore)) != 0)
1.72      bertrand 2568:            {
1.78      bertrand 2569:                if (errno != EINTR)
                   2570:                {
                   2571:                    return(1);
                   2572:                }
1.72      bertrand 2573:            }
                   2574: #      endif
1.69      bertrand 2575: 
                   2576:        (*queue).queue[(*queue).pointeur_ecriture].pid = getpid();
                   2577:        (*queue).queue[(*queue).pointeur_ecriture].signal = signal;
                   2578: 
                   2579:        (*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1)
                   2580:                % LONGUEUR_QUEUE_SIGNAUX;
                   2581: 
1.75      bertrand 2582: #      ifndef IPCS_SYSV // POSIX
                   2583: #          ifndef SEMAPHORES_NOMMES
                   2584:                if (sem_post(&((*queue).semaphore)) != 0)
                   2585:                {
                   2586:                    return(1);
                   2587:                }
                   2588: #          else
                   2589:                if (sem_post(semaphore) != 0)
                   2590:                {
                   2591:                    sem_close(semaphore);
                   2592:                    return(1);
                   2593:                }
                   2594: 
                   2595:                if (sem_close(semaphore) != 0)
                   2596:                {
                   2597:                    return(1);
                   2598:                }
                   2599: #          endif
                   2600: 
                   2601:            if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
1.72      bertrand 2602:            {
1.75      bertrand 2603:                close(segment);
1.72      bertrand 2604:                return(1);
                   2605:            }
1.75      bertrand 2606: #      else // IPCS_SYSV
                   2607:            if (sem_post(&((*queue).semaphore)) != 0)
1.72      bertrand 2608:            {
                   2609:                return(1);
                   2610:            }
                   2611: 
1.83    ! bertrand 2612: #          ifndef OS2 // SysV
        !          2613:                if (shmdt(queue) != 0)
        !          2614:                {
        !          2615:                    return(1);
        !          2616:                }
        !          2617: #          else // OS/2
        !          2618:                // Pendant de DosGetNamedSHaredMem()
        !          2619: #          endif
1.72      bertrand 2620: #      endif
1.69      bertrand 2621:    }
                   2622: 
1.67      bertrand 2623:    return(0);
                   2624: }
                   2625: 
                   2626: int
                   2627: envoi_signal_thread(pthread_t tid, enum signaux_rpl signal)
                   2628: {
                   2629:    // Un signal est envoyé d'un thread à un autre thread du même processus.
                   2630: 
1.68      bertrand 2631:    volatile struct_liste_chainee_volatile  *l_element_courant;
                   2632: 
                   2633:    struct_processus                        *s_etat_processus;
                   2634: 
                   2635:    if (pthread_mutex_lock(&mutex_liste_threads) != 0)
                   2636:    {
                   2637:        return(1);
                   2638:    }
                   2639: 
                   2640:    l_element_courant = liste_threads;
                   2641: 
                   2642:    while(l_element_courant != NULL)
                   2643:    {
                   2644:        if (((*((struct_thread *) (*l_element_courant).donnee)).pid
                   2645:                == getpid()) && (pthread_equal((*((struct_thread *)
                   2646:                (*l_element_courant).donnee)).tid, tid) != 0))
                   2647:        {
                   2648:            break;
                   2649:        }
                   2650: 
                   2651:        l_element_courant = (*l_element_courant).suivant;
                   2652:    }
                   2653: 
                   2654:    if (l_element_courant == NULL)
                   2655:    {
                   2656:        pthread_mutex_unlock(&mutex_liste_threads);
                   2657:        return(1);
                   2658:    }
                   2659: 
                   2660:    if (pthread_mutex_lock(&mutex_interruptions) != 0)
                   2661:    {
                   2662:        pthread_mutex_unlock(&mutex_liste_threads);
                   2663:        return(1);
                   2664:    }
                   2665: 
                   2666:    s_etat_processus = (*((struct_thread *) (*l_element_courant).donnee))
                   2667:            .s_etat_processus;
                   2668: 
                   2669:    (*s_etat_processus).signaux_en_queue
                   2670:            [(*s_etat_processus).pointeur_signal_ecriture] = signal;
                   2671:    (*s_etat_processus).pointeur_signal_ecriture =
                   2672:            ((*s_etat_processus).pointeur_signal_ecriture + 1)
                   2673:            % LONGUEUR_QUEUE_SIGNAUX;
                   2674: 
                   2675:    if (pthread_mutex_unlock(&mutex_interruptions) != 0)
                   2676:    {
                   2677:        pthread_mutex_unlock(&mutex_liste_threads);
                   2678:        return(1);
                   2679:    }
                   2680: 
                   2681:    if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
                   2682:    {
                   2683:        return(1);
                   2684:    }
                   2685: 
1.67      bertrand 2686:    return(0);
                   2687: }
                   2688: 
                   2689: int
                   2690: envoi_signal_contexte(struct_processus *s_etat_processus_a_signaler,
                   2691:        enum signaux_rpl signal)
                   2692: {
1.68      bertrand 2693:    pthread_mutex_lock(&mutex_interruptions);
1.67      bertrand 2694:    (*s_etat_processus_a_signaler).signaux_en_queue
1.68      bertrand 2695:            [(*s_etat_processus_a_signaler).pointeur_signal_ecriture] =
1.67      bertrand 2696:            signal;
1.68      bertrand 2697:    (*s_etat_processus_a_signaler).pointeur_signal_ecriture =
                   2698:            ((*s_etat_processus_a_signaler).pointeur_signal_ecriture + 1)
                   2699:            % LONGUEUR_QUEUE_SIGNAUX;
                   2700:    pthread_mutex_unlock(&mutex_interruptions);
1.67      bertrand 2701: 
                   2702:    return(0);
                   2703: }
                   2704: 
                   2705: 
                   2706: /*
                   2707: ================================================================================
                   2708:   Fonction créant un segment de mémoire partagée destiné à contenir
                   2709:   la queue des signaux.
                   2710: ================================================================================
                   2711:   Entrée : structure de description du processus
                   2712: --------------------------------------------------------------------------------
                   2713:   Sortie : Néant
                   2714: --------------------------------------------------------------------------------
                   2715:   Effet de bord : Néant
                   2716: ================================================================================
                   2717: */
                   2718: 
                   2719: void
                   2720: creation_queue_signaux(struct_processus *s_etat_processus)
                   2721: {
                   2722:    unsigned char                   *nom;
                   2723: 
1.69      bertrand 2724:    racine_segment = (*s_etat_processus).chemin_fichiers_temporaires;
                   2725: 
1.67      bertrand 2726: #  ifndef IPCS_SYSV // POSIX
1.71      bertrand 2727:        if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,
                   2728:                getpid())) == NULL)
                   2729:        {
                   2730:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2731:            return;
                   2732:        }
1.16      bertrand 2733: 
1.71      bertrand 2734:        if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_EXCL,
                   2735:                S_IRUSR | S_IWUSR)) == -1)
                   2736:        {
                   2737:            free(nom);
                   2738:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2739:            return;
                   2740:        }
1.16      bertrand 2741: 
1.71      bertrand 2742:        if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1)
                   2743:        {
                   2744:            free(nom);
                   2745:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2746:            return;
                   2747:        }
1.16      bertrand 2748: 
1.71      bertrand 2749:        s_queue_signaux = mmap(NULL, sizeof(struct_queue_signaux),
                   2750:                PROT_READ | PROT_WRITE, MAP_SHARED, f_queue_signaux, 0);
1.67      bertrand 2751: 
1.71      bertrand 2752:        if (((void *) s_queue_signaux) == ((void *) -1))
                   2753:        {
                   2754:            if (shm_unlink(nom) == -1)
                   2755:            {
                   2756:                free(nom);
                   2757:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2758:                return;
                   2759:            }
1.67      bertrand 2760: 
                   2761:            free(nom);
                   2762:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1.16      bertrand 2763:            return;
                   2764:        }
                   2765: 
1.67      bertrand 2766:        free(nom);
1.75      bertrand 2767: 
1.71      bertrand 2768: #      ifndef SEMAPHORES_NOMMES
                   2769:            sem_init(&((*s_queue_signaux).semaphore), 1, 1);
                   2770: #      else
1.80      bertrand 2771:            if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE))
1.72      bertrand 2772:                    == SEM_FAILED)
1.71      bertrand 2773:            {
                   2774:                (*s_etat_processus).erreur_systeme = d_es_processus;
                   2775:                return;
                   2776:            }
                   2777: #      endif
1.67      bertrand 2778: 
1.71      bertrand 2779:        (*s_queue_signaux).pointeur_lecture = 0;
                   2780:        (*s_queue_signaux).pointeur_ecriture = 0;
1.67      bertrand 2781: 
1.71      bertrand 2782:        if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0))
1.16      bertrand 2783:        {
1.71      bertrand 2784:            (*s_etat_processus).erreur_systeme = d_es_processus;
1.16      bertrand 2785:            return;
                   2786:        }
1.75      bertrand 2787: #  else // IPCS_SYSV
1.71      bertrand 2788: #      ifndef OS2
1.75      bertrand 2789:            int                             segment;
                   2790:            int                             support;
1.71      bertrand 2791: 
                   2792:            key_t                           clef;
1.67      bertrand 2793: 
1.71      bertrand 2794:            // Création d'un segment de données associé au PID du processus
                   2795:            // courant
1.16      bertrand 2796: 
1.71      bertrand 2797:            if ((nom = nom_segment((*s_etat_processus)
                   2798:                    .chemin_fichiers_temporaires, getpid())) == NULL)
                   2799:            {
                   2800:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2801:                return;
                   2802:            }
                   2803: 
1.76      bertrand 2804:            if ((support = open(nom, O_RDWR | O_CREAT | O_EXCL,
1.75      bertrand 2805:                    S_IRUSR | S_IWUSR)) == -1)
1.71      bertrand 2806:            {
                   2807:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   2808:                return;
                   2809:            }
                   2810: 
                   2811:            if ((clef = ftok(nom, 1)) == -1)
                   2812:            {
                   2813:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2814:                return;
                   2815:            }
1.1       bertrand 2816: 
1.75      bertrand 2817:            close(support);
1.71      bertrand 2818:            free(nom);
1.1       bertrand 2819: 
1.75      bertrand 2820:            if ((segment = shmget(clef, sizeof(struct_queue_signaux),
1.71      bertrand 2821:                    IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1)
                   2822:            {
                   2823:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2824:                return;
                   2825:            }
                   2826: 
1.75      bertrand 2827:            s_queue_signaux = shmat(segment, NULL, 0);
                   2828:            f_queue_signaux = segment;
1.71      bertrand 2829: 
1.75      bertrand 2830:            if (((void *) s_queue_signaux) == ((void *) -1))
1.71      bertrand 2831:            {
1.75      bertrand 2832:                if (shmctl(f_queue_signaux, IPC_RMID, 0) == -1)
1.71      bertrand 2833:                {
                   2834:                    (*s_etat_processus).erreur_systeme =
                   2835:                            d_es_allocation_memoire;
                   2836:                    return;
                   2837:                }
                   2838: 
                   2839:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2840:                return;
                   2841:            }
1.75      bertrand 2842: 
                   2843:            sem_init(&((*s_queue_signaux).semaphore), 1, 1);
                   2844:            (*s_queue_signaux).pointeur_lecture = 0;
                   2845:            (*s_queue_signaux).pointeur_ecriture = 0;
1.71      bertrand 2846: #      else // OS/2
                   2847:            if ((nom = nom_segment(NULL, getpid())) == NULL)
                   2848:            {
                   2849:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2850:                return;
                   2851:            }
                   2852: 
1.83    ! bertrand 2853:            if (DosAllocSharedMem((PVOID) &s_queue_signaux, nom,
        !          2854:                    sizeof(struct_queue_signaux),
1.71      bertrand 2855:                    PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)
                   2856:            {
                   2857:                free(nom);
                   2858:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2859:                return;
                   2860:            }
1.67      bertrand 2861: 
1.71      bertrand 2862:            free(nom);
1.83    ! bertrand 2863: 
        !          2864:            sem_init(&((*s_queue_signaux).semaphore), 1, 1);
        !          2865:            (*s_queue_signaux).pointeur_lecture = 0;
        !          2866:            (*s_queue_signaux).pointeur_ecriture = 0;
1.71      bertrand 2867: #      endif
1.67      bertrand 2868: #  endif
                   2869: 
1.1       bertrand 2870:    return;
                   2871: }
                   2872: 
1.67      bertrand 2873: 
                   2874: /*
                   2875: ================================================================================
                   2876:   Fonction libérant le segment de mémoire partagée destiné à contenir
                   2877:   la queue des signaux.
                   2878: ================================================================================
                   2879:   Entrée : structure de description du processus
                   2880: --------------------------------------------------------------------------------
                   2881:   Sortie : Néant
                   2882: --------------------------------------------------------------------------------
                   2883:   Effet de bord : Néant
                   2884: ================================================================================
                   2885: */
                   2886: 
                   2887: void
                   2888: liberation_queue_signaux(struct_processus *s_etat_processus)
1.66      bertrand 2889: {
1.67      bertrand 2890: #  ifdef IPCS_SYSV // SystemV
                   2891: #      ifndef OS2
1.75      bertrand 2892:            if (shmdt(s_queue_signaux) == -1)
                   2893:            {
                   2894:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2895:                return;
                   2896:            }
1.67      bertrand 2897: #      else // OS/2
                   2898: #      endif
                   2899: #  else // POSIX
1.72      bertrand 2900: #      ifndef SEMAPHORES_NOMMES
                   2901:            sem_close(&((*s_queue_signaux).semaphore));
                   2902: #      else
                   2903:            sem_close(semaphore_queue_signaux);
                   2904: #      endif
1.70      bertrand 2905: 
1.67      bertrand 2906:        if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
1.66      bertrand 2907:        {
1.67      bertrand 2908:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2909:            return;
1.66      bertrand 2910:        }
1.69      bertrand 2911: 
                   2912:        close(f_queue_signaux);
1.67      bertrand 2913: #  endif
1.66      bertrand 2914: 
                   2915:    return;
                   2916: }
                   2917: 
1.67      bertrand 2918: 
                   2919: /*
                   2920: ================================================================================
                   2921:   Fonction détruisant le segment de mémoire partagée destiné à contenir
                   2922:   la queue des signaux.
                   2923: ================================================================================
                   2924:   Entrée : structure de description du processus
                   2925: --------------------------------------------------------------------------------
                   2926:   Sortie : Néant
                   2927: --------------------------------------------------------------------------------
                   2928:   Effet de bord : Néant
                   2929: ================================================================================
                   2930: */
                   2931: 
1.66      bertrand 2932: void
1.67      bertrand 2933: destruction_queue_signaux(struct_processus *s_etat_processus)
1.66      bertrand 2934: {
1.83    ! bertrand 2935: #  ifndef OS2
        !          2936:        unsigned char       *nom;
        !          2937: #  endif
1.66      bertrand 2938: 
1.67      bertrand 2939: #  ifdef IPCS_SYSV // SystemV
1.71      bertrand 2940: #      ifndef OS2
1.75      bertrand 2941:            // Il faut commencer par éliminer le sémaphore.
                   2942: 
                   2943:            if (semctl((*s_queue_signaux).semaphore.sem, 0, IPC_RMID) == -1)
                   2944:            {
                   2945:                (*s_etat_processus).erreur_systeme = d_es_processus;
                   2946:                return;
                   2947:            }
                   2948: 
                   2949:            unlink((*s_queue_signaux).semaphore.path);
                   2950: 
                   2951:            if (shmdt(s_queue_signaux) == -1)
1.71      bertrand 2952:            {
                   2953:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2954:                return;
                   2955:            }
                   2956: 
1.75      bertrand 2957:            if (shmctl(f_queue_signaux, IPC_RMID, 0) == -1)
1.71      bertrand 2958:            {
                   2959:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2960:                return;
                   2961:            }
                   2962: 
                   2963:            if ((nom = nom_segment((*s_etat_processus)
                   2964:                    .chemin_fichiers_temporaires, getpid())) == NULL)
                   2965:            {
                   2966:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2967:                return;
                   2968:            }
1.66      bertrand 2969: 
1.71      bertrand 2970:            unlink(nom);
                   2971:            free(nom);
                   2972: #      else
1.83    ! bertrand 2973:            sem_close(&((*s_queue_signaux).semaphore));
        !          2974:            sem_destroy(&((*s_queue_signaux).semaphore));
        !          2975: 
        !          2976:            if (DosFreeMem(s_queue_signaux) != 0)
1.71      bertrand 2977:            {
                   2978:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2979:                return;
                   2980:            }
                   2981: #      endif
1.67      bertrand 2982: #  else // POSIX
1.72      bertrand 2983: #      ifndef SEMAPHORES_NOMMES
                   2984:            sem_close(&((*s_queue_signaux).semaphore));
                   2985:            sem_destroy(&((*s_queue_signaux).semaphore));
                   2986: #      else
                   2987:            sem_close(semaphore_queue_signaux);
1.80      bertrand 2988:            sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);
1.72      bertrand 2989: #      endif
1.67      bertrand 2990: 
1.70      bertrand 2991:        if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
                   2992:        {
                   2993:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2994:            return;
                   2995:        }
                   2996: 
                   2997:        if ((nom = nom_segment(NULL, getpid())) == NULL)
                   2998:        {
                   2999:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3000:            return;
                   3001:        }
1.66      bertrand 3002: 
1.70      bertrand 3003:        close(f_queue_signaux);
1.66      bertrand 3004: 
1.70      bertrand 3005:        if (shm_unlink(nom) != 0)
                   3006:        {
                   3007:            free(nom);
                   3008:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3009:            return;
                   3010:        }
1.69      bertrand 3011: 
1.67      bertrand 3012:        free(nom);
                   3013: #  endif
                   3014: 
1.66      bertrand 3015:    return;
                   3016: }
                   3017: 
1.1       bertrand 3018: // vim: ts=4

CVSweb interface <joel.bertrand@systella.fr>