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