1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.19
4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: Procédures de gestion par thread des variables issues des gestionnaires
29: de signaux
30: ================================================================================
31: Entrée : variable globale
32: --------------------------------------------------------------------------------
33: Sortie : variable globale modifiée
34: --------------------------------------------------------------------------------
35: Effets de bord : néant
36: ================================================================================
37: */
38:
39: typedef struct thread
40: {
41: pid_t pid;
42: pthread_t tid;
43:
44: logical1 thread_principal;
45:
46: struct_processus *s_etat_processus;
47: } struct_thread;
48:
49: typedef struct liste_chainee_volatile
50: {
51: volatile struct liste_chainee_volatile *suivant;
52: volatile void *donnee;
53: } struct_liste_chainee_volatile;
54:
55:
56: static volatile struct_liste_chainee_volatile *liste_threads
57: = NULL;
58: static volatile struct_liste_chainee_volatile *liste_threads_surveillance
59: = NULL;
60:
61: void
62: modification_pid_thread_pere(struct_processus *s_etat_processus)
63: {
64: // La variable existe toujours et aucun thread concurrent ne peut
65: // la modifier puisque cette routine ne peut être appelée que depuis
66: // DAEMON.
67:
68: (*((struct_thread *) (*liste_threads).donnee)).pid =
69: (*s_etat_processus).pid_processus_pere;
70:
71: return;
72: }
73:
74: void
75: insertion_thread(struct_processus *s_etat_processus, logical1 thread_principal)
76: {
77: sigset_t oldset;
78: sigset_t set;
79:
80: volatile struct_liste_chainee_volatile *l_nouvel_objet;
81:
82: sigfillset(&set);
83: pthread_sigmask(SIG_BLOCK, &set, &oldset);
84:
85: if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
86: == NULL)
87: {
88: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
89: sigpending(&set);
90:
91: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
92: return;
93: }
94:
95: if (((*l_nouvel_objet).donnee = malloc(sizeof(struct_thread))) == NULL)
96: {
97: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
98: sigpending(&set);
99:
100: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
101: return;
102: }
103:
104: (*((struct_thread *) (*l_nouvel_objet).donnee)).pid = getpid();
105: (*((struct_thread *) (*l_nouvel_objet).donnee)).tid = pthread_self();
106: (*((struct_thread *) (*l_nouvel_objet).donnee)).thread_principal =
107: thread_principal;
108: (*((struct_thread *) (*l_nouvel_objet).donnee)).s_etat_processus =
109: s_etat_processus;
110:
111: # ifndef SEMAPHORES_NOMMES
112: while(sem_wait(&semaphore_liste_threads) == -1)
113: # else
114: while(sem_wait(semaphore_liste_threads) == -1)
115: # endif
116: {
117: if (errno != EINTR)
118: {
119: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
120: sigpending(&set);
121:
122: (*s_etat_processus).erreur_systeme = d_es_processus;
123: return;
124: }
125: }
126:
127: (*l_nouvel_objet).suivant = liste_threads;
128: liste_threads = l_nouvel_objet;
129:
130: # ifndef SEMAPHORES_NOMMES
131: if (sem_post(&semaphore_liste_threads) != 0)
132: # else
133: if (sem_post(semaphore_liste_threads) != 0)
134: # endif
135: {
136: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
137: sigpending(&set);
138:
139: (*s_etat_processus).erreur_systeme = d_es_processus;
140: return;
141: }
142:
143: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
144: sigpending(&set);
145: return;
146: }
147:
148: void
149: insertion_thread_surveillance(struct_processus *s_etat_processus,
150: struct_descripteur_thread *s_argument_thread)
151: {
152: sigset_t oldset;
153: sigset_t set;
154:
155: volatile struct_liste_chainee_volatile *l_nouvel_objet;
156:
157: sigfillset(&set);
158: pthread_sigmask(SIG_BLOCK, &set, &oldset);
159:
160: if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
161: == NULL)
162: {
163: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
164: sigpending(&set);
165:
166: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
167: return;
168: }
169:
170: # ifndef SEMAPHORES_NOMMES
171: while(sem_wait(&semaphore_liste_threads) == -1)
172: # else
173: while(sem_wait(semaphore_liste_threads) == -1)
174: # endif
175: {
176: if (errno != EINTR)
177: {
178: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
179: sigpending(&set);
180:
181: (*s_etat_processus).erreur_systeme = d_es_processus;
182: return;
183: }
184: }
185:
186: pthread_mutex_lock(&((*s_argument_thread).mutex));
187: (*s_argument_thread).nombre_references++;
188: pthread_mutex_unlock(&((*s_argument_thread).mutex));
189:
190: (*l_nouvel_objet).suivant = liste_threads_surveillance;
191: (*l_nouvel_objet).donnee = (void *) s_argument_thread;
192:
193: liste_threads_surveillance = l_nouvel_objet;
194:
195: # ifndef SEMAPHORES_NOMMES
196: if (sem_post(&semaphore_liste_threads) != 0)
197: # else
198: if (sem_post(semaphore_liste_threads) != 0)
199: # endif
200: {
201: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
202: sigpending(&set);
203:
204: (*s_etat_processus).erreur_systeme = d_es_processus;
205: return;
206: }
207:
208: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
209: sigpending(&set);
210: return;
211: }
212:
213: void
214: retrait_thread(struct_processus *s_etat_processus)
215: {
216: sigset_t oldset;
217: sigset_t set;
218:
219: volatile struct_liste_chainee_volatile *l_element_precedent;
220: volatile struct_liste_chainee_volatile *l_element_courant;
221:
222: sigfillset(&set);
223: pthread_sigmask(SIG_BLOCK, &set, &oldset);
224:
225: # ifndef SEMAPHORES_NOMMES
226: while(sem_wait(&semaphore_liste_threads) == -1)
227: # else
228: while(sem_wait(semaphore_liste_threads) == -1)
229: # endif
230: {
231: if (errno != EINTR)
232: {
233: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
234: sigpending(&set);
235:
236: (*s_etat_processus).erreur_systeme = d_es_processus;
237: return;
238: }
239: }
240:
241: l_element_precedent = NULL;
242: l_element_courant = liste_threads;
243:
244: while(l_element_courant != NULL)
245: {
246: if (((*((struct_thread *) (*l_element_courant).donnee)).pid
247: == getpid()) && (pthread_equal((*((struct_thread *)
248: (*l_element_courant).donnee)).tid, pthread_self()) != 0))
249: {
250: break;
251: }
252:
253: l_element_precedent = l_element_courant;
254: l_element_courant = (*l_element_courant).suivant;
255: }
256:
257: if (l_element_courant == NULL)
258: {
259: # ifndef SEMAPHORES_NOMMES
260: sem_post(&semaphore_liste_threads);
261: # else
262: sem_post(semaphore_liste_threads);
263: # endif
264: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
265: sigpending(&set);
266:
267: (*s_etat_processus).erreur_systeme = d_es_processus;
268: return;
269: }
270:
271: if (l_element_precedent == NULL)
272: {
273: liste_threads = (*l_element_courant).suivant;
274: }
275: else
276: {
277: (*l_element_precedent).suivant = (*l_element_courant).suivant;
278: }
279:
280: if (pthread_setspecific(semaphore_fork_processus_courant, NULL) != 0)
281: {
282: (*s_etat_processus).erreur_systeme = d_es_processus;
283:
284: # ifndef SEMAPHORES_NOMMES
285: sem_post(&semaphore_liste_threads);
286: # else
287: sem_post(semaphore_liste_threads);
288: # endif
289: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
290: sigpending(&set);
291: return;
292: }
293:
294: # ifndef SEMAPHORES_NOMMES
295: if (sem_post(&semaphore_liste_threads) != 0)
296: # else
297: if (sem_post(semaphore_liste_threads) != 0)
298: # endif
299: {
300: (*s_etat_processus).erreur_systeme = d_es_processus;
301:
302: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
303: sigpending(&set);
304: return;
305: }
306:
307: free((void *) (*l_element_courant).donnee);
308: free((struct_liste_chainee_volatile *) l_element_courant);
309:
310: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
311: sigpending(&set);
312: return;
313: }
314:
315: void
316: retrait_thread_surveillance(struct_processus *s_etat_processus,
317: struct_descripteur_thread *s_argument_thread)
318: {
319: sigset_t set;
320: sigset_t oldset;
321:
322: volatile struct_liste_chainee_volatile *l_element_precedent;
323: volatile struct_liste_chainee_volatile *l_element_courant;
324:
325: sigfillset(&set);
326: pthread_sigmask(SIG_BLOCK, &set, &oldset);
327:
328: # ifndef SEMAPHORES_NOMMES
329: while(sem_wait(&semaphore_liste_threads) == -1)
330: # else
331: while(sem_wait(semaphore_liste_threads) == -1)
332: # endif
333: {
334: if (errno != EINTR)
335: {
336: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
337: sigpending(&set);
338:
339: (*s_etat_processus).erreur_systeme = d_es_processus;
340: return;
341: }
342: }
343:
344: l_element_precedent = NULL;
345: l_element_courant = liste_threads_surveillance;
346:
347: while(l_element_courant != NULL)
348: {
349: if ((*l_element_courant).donnee == (void *) s_argument_thread)
350: {
351: break;
352: }
353:
354: l_element_precedent = l_element_courant;
355: l_element_courant = (*l_element_courant).suivant;
356: }
357:
358: if (l_element_courant == NULL)
359: {
360: # ifndef SEMAPHORES_NOMMES
361: sem_post(&semaphore_liste_threads);
362: # else
363: sem_post(semaphore_liste_threads);
364: # endif
365: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
366: sigpending(&set);
367:
368: (*s_etat_processus).erreur_systeme = d_es_processus;
369: return;
370: }
371:
372: if (l_element_precedent == NULL)
373: {
374: liste_threads_surveillance = (*l_element_courant).suivant;
375: }
376: else
377: {
378: (*l_element_precedent).suivant = (*l_element_courant).suivant;
379: }
380:
381: if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)
382: {
383: # ifndef SEMAPHORES_NOMMES
384: sem_post(&semaphore_liste_threads);
385: # else
386: sem_post(semaphore_liste_threads);
387: # endif
388: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
389: sigpending(&set);
390:
391: (*s_etat_processus).erreur_systeme = d_es_processus;
392: return;
393: }
394:
395: (*s_argument_thread).nombre_references--;
396:
397: BUG((*s_argument_thread).nombre_references < 0,
398: printf("(*s_argument_thread).nombre_references = %d\n",
399: (int) (*s_argument_thread).nombre_references));
400:
401: if ((*s_argument_thread).nombre_references == 0)
402: {
403: if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
404: {
405: # ifndef SEMAPHORES_NOMMES
406: sem_post(&semaphore_liste_threads);
407: # else
408: sem_post(semaphore_liste_threads);
409: # endif
410: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
411: sigpending(&set);
412:
413: (*s_etat_processus).erreur_systeme = d_es_processus;
414: return;
415: }
416:
417: pthread_mutex_destroy(&((*s_argument_thread).mutex));
418: free(s_argument_thread);
419: }
420: else
421: {
422: if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
423: {
424: # ifndef SEMAPHORES_NOMMES
425: sem_post(&semaphore_liste_threads);
426: # else
427: sem_post(semaphore_liste_threads);
428: # endif
429: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
430: sigpending(&set);
431:
432: (*s_etat_processus).erreur_systeme = d_es_processus;
433: return;
434: }
435: }
436:
437: # ifndef SEMAPHORES_NOMMES
438: if (sem_post(&semaphore_liste_threads) != 0)
439: # else
440: if (sem_post(semaphore_liste_threads) != 0)
441: # endif
442: {
443: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
444: sigpending(&set);
445:
446: (*s_etat_processus).erreur_systeme = d_es_processus;
447: return;
448: }
449:
450: free((struct_liste_chainee_volatile *) l_element_courant);
451:
452: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
453: sigpending(&set);
454:
455: return;
456: }
457:
458: void
459: verrouillage_threads_concurrents(struct_processus *s_etat_processus)
460: {
461: volatile struct_liste_chainee_volatile *l_element_courant;
462:
463: # ifndef SEMAPHORES_NOMMES
464: while(sem_wait(&semaphore_liste_threads) == -1)
465: # else
466: while(sem_wait(semaphore_liste_threads) == -1)
467: # endif
468: {
469: if (errno != EINTR)
470: {
471: (*s_etat_processus).erreur_systeme = d_es_processus;
472: return;
473: }
474: }
475:
476: l_element_courant = liste_threads;
477:
478: while(l_element_courant != NULL)
479: {
480: if (((*((struct_thread *) (*l_element_courant).donnee)).pid
481: == getpid()) && (pthread_equal((*((struct_thread *)
482: (*l_element_courant).donnee)).tid, pthread_self()) == 0))
483: {
484: # ifndef SEMAPHORES_NOMMES
485: while(sem_wait(&((*(*((struct_thread *) (*l_element_courant)
486: .donnee)).s_etat_processus).semaphore_fork)) == -1)
487: # else
488: while(sem_wait((*(*((struct_thread *) (*l_element_courant)
489: .donnee)).s_etat_processus).semaphore_fork) == -1)
490: # endif
491: {
492: if (errno != EINTR)
493: {
494: (*s_etat_processus).erreur_systeme = d_es_processus;
495: return;
496: }
497: }
498: }
499:
500: l_element_courant = (*l_element_courant).suivant;
501: }
502:
503: return;
504: }
505:
506: void
507: deverrouillage_threads_concurrents(struct_processus *s_etat_processus)
508: {
509: volatile struct_liste_chainee_volatile *l_element_courant;
510:
511: l_element_courant = liste_threads;
512:
513: while(l_element_courant != NULL)
514: {
515: if (((*((struct_thread *) (*l_element_courant).donnee)).pid
516: == getpid()) && (pthread_equal((*((struct_thread *)
517: (*l_element_courant).donnee)).tid, pthread_self()) == 0))
518: {
519: # ifndef SEMAPHORES_NOMMES
520: if (sem_post(&((*(*((struct_thread *)
521: (*l_element_courant).donnee)).s_etat_processus)
522: .semaphore_fork)) != 0)
523: # else
524: if (sem_post((*(*((struct_thread *)
525: (*l_element_courant).donnee)).s_etat_processus)
526: .semaphore_fork) != 0)
527: # endif
528: {
529: # ifndef SEMAPHORES_NOMMES
530: if (sem_post(&semaphore_liste_threads) != 0)
531: {
532: (*s_etat_processus).erreur_systeme = d_es_processus;
533: return;
534: }
535: # else
536: if (sem_post(semaphore_liste_threads) != 0)
537: {
538: (*s_etat_processus).erreur_systeme = d_es_processus;
539: return;
540: }
541: # endif
542:
543: (*s_etat_processus).erreur_systeme = d_es_processus;
544: return;
545: }
546: }
547:
548: l_element_courant = (*l_element_courant).suivant;
549: }
550:
551: # ifndef SEMAPHORES_NOMMES
552: if (sem_post(&semaphore_liste_threads) != 0)
553: # else
554: if (sem_post(semaphore_liste_threads) != 0)
555: # endif
556: {
557: (*s_etat_processus).erreur_systeme = d_es_processus;
558: return;
559: }
560:
561: return;
562: }
563:
564: void
565: liberation_threads(struct_processus *s_etat_processus)
566: {
567: logical1 suppression_variables_partagees;
568:
569: sigset_t oldset;
570: sigset_t set;
571:
572: struct_descripteur_thread *s_argument_thread;
573:
574: struct_processus *candidat;
575:
576: unsigned long i;
577:
578: void *element_candidat;
579: void *element_courant;
580: void *element_suivant;
581:
582: volatile struct_liste_chainee_volatile *l_element_courant;
583: volatile struct_liste_chainee_volatile *l_element_suivant;
584:
585: sigfillset(&set);
586: pthread_sigmask(SIG_BLOCK, &set, &oldset);
587:
588: # ifndef SEMAPHORES_NOMMES
589: while(sem_wait(&semaphore_liste_threads) == -1)
590: # else
591: while(sem_wait(semaphore_liste_threads) == -1)
592: # endif
593: {
594: if (errno != EINTR)
595: {
596: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
597: (*s_etat_processus).erreur_systeme = d_es_processus;
598: return;
599: }
600: }
601:
602: l_element_courant = liste_threads;
603: suppression_variables_partagees = d_faux;
604:
605: while(l_element_courant != NULL)
606: {
607: if ((*((struct_thread *) (*l_element_courant).donnee)).s_etat_processus
608: != s_etat_processus)
609: {
610: candidat = s_etat_processus;
611: s_etat_processus = (*((struct_thread *)
612: (*l_element_courant).donnee)).s_etat_processus;
613: free((*s_etat_processus).localisation);
614:
615: // (*s_etat_processus).instruction_courante peut pointer sur
616: // n'importe quoi (une instruction courante ou un champ d'une
617: // structure objet). On ne le libère pas quitte à avoir une
618: // petite fuite mémoire dans le processus fils.
619:
620: if ((*s_etat_processus).instruction_courante != NULL)
621: {
622: //free((*s_etat_processus).instruction_courante);
623: }
624:
625: close((*s_etat_processus).pipe_acquittement);
626: close((*s_etat_processus).pipe_donnees);
627: close((*s_etat_processus).pipe_injections);
628: close((*s_etat_processus).pipe_nombre_injections);
629: close((*s_etat_processus).pipe_interruptions);
630: close((*s_etat_processus).pipe_nombre_objets_attente);
631: close((*s_etat_processus).pipe_nombre_interruptions_attente);
632:
633: liberation(s_etat_processus, (*s_etat_processus).at_exit);
634:
635: if ((*s_etat_processus).nom_fichier_impression != NULL)
636: {
637: free((*s_etat_processus).nom_fichier_impression);
638: }
639:
640: while((*s_etat_processus).fichiers_graphiques != NULL)
641: {
642: free((*(*s_etat_processus).fichiers_graphiques).nom);
643:
644: if ((*(*s_etat_processus).fichiers_graphiques).legende != NULL)
645: {
646: free((*(*s_etat_processus).fichiers_graphiques).legende);
647: }
648:
649: element_courant = (*s_etat_processus).fichiers_graphiques;
650: (*s_etat_processus).fichiers_graphiques =
651: (*(*s_etat_processus).fichiers_graphiques).suivant;
652:
653: free(element_courant);
654: }
655:
656: if ((*s_etat_processus).entree_standard != NULL)
657: {
658: pclose((*s_etat_processus).entree_standard);
659: }
660:
661: if ((*s_etat_processus).generateur_aleatoire != NULL)
662: {
663: liberation_generateur_aleatoire(s_etat_processus);
664: }
665:
666: if ((*s_etat_processus).instruction_derniere_erreur != NULL)
667: {
668: free((*s_etat_processus).instruction_derniere_erreur);
669: (*s_etat_processus).instruction_derniere_erreur = NULL;
670: }
671:
672: element_courant = (void *) (*s_etat_processus)
673: .l_base_pile_processus;
674: while(element_courant != NULL)
675: {
676: s_argument_thread = (struct_descripteur_thread *)
677: (*((struct_liste_chainee *) element_courant)).donnee;
678:
679: if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)
680: {
681: (*s_etat_processus).erreur_systeme = d_es_processus;
682: sem_post(&semaphore_liste_threads);
683: return;
684: }
685:
686: (*s_argument_thread).nombre_references--;
687:
688: BUG((*s_argument_thread).nombre_references < 0,
689: printf("(*s_argument_thread).nombre_references = %d\n",
690: (int) (*s_argument_thread).nombre_references));
691:
692: if ((*s_argument_thread).nombre_references == 0)
693: {
694: close((*s_argument_thread).pipe_objets[0]);
695: close((*s_argument_thread).pipe_acquittement[1]);
696: close((*s_argument_thread).pipe_injections[1]);
697: close((*s_argument_thread).pipe_nombre_injections[1]);
698: close((*s_argument_thread).pipe_nombre_objets_attente[0]);
699: close((*s_argument_thread).pipe_interruptions[0]);
700: close((*s_argument_thread)
701: .pipe_nombre_interruptions_attente[0]);
702:
703: if (pthread_mutex_unlock(&((*s_argument_thread).mutex))
704: != 0)
705: {
706: (*s_etat_processus).erreur_systeme = d_es_processus;
707: sem_post(&semaphore_liste_threads);
708: return;
709: }
710:
711: pthread_mutex_destroy(&((*s_argument_thread).mutex));
712:
713: if ((*s_argument_thread).processus_detache == d_faux)
714: {
715: if ((*s_argument_thread).destruction_objet == d_vrai)
716: {
717: liberation(s_etat_processus, (*s_argument_thread)
718: .argument);
719: }
720: }
721:
722: free(s_argument_thread);
723: }
724: else
725: {
726: if (pthread_mutex_unlock(&((*s_argument_thread).mutex))
727: != 0)
728: {
729: (*s_etat_processus).erreur_systeme = d_es_processus;
730: sem_post(&semaphore_liste_threads);
731: return;
732: }
733: }
734:
735: element_suivant = (*((struct_liste_chainee *) element_courant))
736: .suivant;
737: free(element_courant);
738: element_courant = element_suivant;
739: }
740:
741: (*s_etat_processus).l_base_pile_processus = NULL;
742:
743: pthread_mutex_trylock(&((*(*s_etat_processus).indep).mutex));
744: pthread_mutex_unlock(&((*(*s_etat_processus).indep).mutex));
745: liberation(s_etat_processus, (*s_etat_processus).indep);
746:
747: pthread_mutex_trylock(&((*(*s_etat_processus).depend).mutex));
748: pthread_mutex_unlock(&((*(*s_etat_processus).depend).mutex));
749: liberation(s_etat_processus, (*s_etat_processus).depend);
750:
751: free((*s_etat_processus).label_x);
752: free((*s_etat_processus).label_y);
753: free((*s_etat_processus).label_z);
754: free((*s_etat_processus).titre);
755: free((*s_etat_processus).legende);
756:
757: pthread_mutex_trylock(&((*(*s_etat_processus)
758: .parametres_courbes_de_niveau).mutex));
759: pthread_mutex_unlock(&((*(*s_etat_processus)
760: .parametres_courbes_de_niveau).mutex));
761: liberation(s_etat_processus, (*s_etat_processus)
762: .parametres_courbes_de_niveau);
763:
764: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
765: {
766: if ((*s_etat_processus).corps_interruptions[i] != NULL)
767: {
768: pthread_mutex_trylock(&((*(*s_etat_processus)
769: .corps_interruptions[i]).mutex));
770: pthread_mutex_unlock(&((*(*s_etat_processus)
771: .corps_interruptions[i]).mutex));
772:
773: liberation(s_etat_processus,
774: (*s_etat_processus).corps_interruptions[i]);
775: }
776:
777: element_courant = (*s_etat_processus)
778: .pile_origine_interruptions[i];
779:
780: while(element_courant != NULL)
781: {
782: element_suivant = (*((struct_liste_chainee *)
783: element_courant)).suivant;
784:
785: pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
786: element_courant)).donnee).mutex));
787: pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
788: element_courant)).donnee).mutex));
789:
790: liberation(s_etat_processus,
791: (*((struct_liste_chainee *) element_courant))
792: .donnee);
793: free(element_courant);
794:
795: element_courant = element_suivant;
796: }
797: }
798:
799: for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
800: {
801: pthread_mutex_trylock(&((*(*s_etat_processus)
802: .s_liste_variables[i].objet).mutex));
803: pthread_mutex_unlock(&((*(*s_etat_processus)
804: .s_liste_variables[i].objet).mutex));
805:
806: // Les variables de niveau 0 sont des définitions qui
807: // ne sont pas copiées entre threads.
808: if ((*s_etat_processus).s_liste_variables[i].niveau > 0)
809: {
810: liberation(s_etat_processus,
811: (*s_etat_processus).s_liste_variables[i].objet);
812: }
813:
814: free((*s_etat_processus).s_liste_variables[i].nom);
815: }
816:
817: free((*s_etat_processus).s_liste_variables);
818:
819: for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
820: {
821: pthread_mutex_trylock(&((*(*s_etat_processus)
822: .s_liste_variables_statiques[i].objet).mutex));
823: pthread_mutex_unlock(&((*(*s_etat_processus)
824: .s_liste_variables_statiques[i].objet).mutex));
825:
826: liberation(s_etat_processus, (*s_etat_processus)
827: .s_liste_variables_statiques[i].objet);
828: free((*s_etat_processus).s_liste_variables_statiques[i].nom);
829: }
830:
831: free((*s_etat_processus).s_liste_variables_statiques);
832:
833: // Ne peut être effacé qu'une seule fois
834: if (suppression_variables_partagees == d_faux)
835: {
836: suppression_variables_partagees = d_vrai;
837:
838: for(i = 0; i < (*(*s_etat_processus)
839: .s_liste_variables_partagees).nombre_variables; i++)
840: {
841: pthread_mutex_trylock(&((*(*(*s_etat_processus)
842: .s_liste_variables_partagees).table[i].objet)
843: .mutex));
844: pthread_mutex_unlock(&((*(*(*s_etat_processus)
845: .s_liste_variables_partagees).table[i].objet)
846: .mutex));
847:
848: liberation(s_etat_processus, (*(*s_etat_processus)
849: .s_liste_variables_partagees).table[i].objet);
850: free((*(*s_etat_processus).s_liste_variables_partagees)
851: .table[i].nom);
852: }
853:
854: if ((*(*s_etat_processus).s_liste_variables_partagees).table
855: != NULL)
856: {
857: free((struct_variable_partagee *) (*(*s_etat_processus)
858: .s_liste_variables_partagees).table);
859: }
860:
861: pthread_mutex_trylock(&((*(*s_etat_processus)
862: .s_liste_variables_partagees).mutex));
863: pthread_mutex_unlock(&((*(*s_etat_processus)
864: .s_liste_variables_partagees).mutex));
865: }
866:
867: element_courant = (*s_etat_processus).l_base_pile;
868: while(element_courant != NULL)
869: {
870: element_suivant = (*((struct_liste_chainee *)
871: element_courant)).suivant;
872:
873: pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
874: element_courant)).donnee).mutex));
875: pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
876: element_courant)).donnee).mutex));
877:
878: liberation(s_etat_processus,
879: (*((struct_liste_chainee *)
880: element_courant)).donnee);
881: free((struct_liste_chainee *) element_courant);
882:
883: element_courant = element_suivant;
884: }
885:
886: element_courant = (*s_etat_processus).l_base_pile_contextes;
887: while(element_courant != NULL)
888: {
889: element_suivant = (*((struct_liste_chainee *)
890: element_courant)).suivant;
891:
892: pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
893: element_courant)).donnee).mutex));
894: pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
895: element_courant)).donnee).mutex));
896: liberation(s_etat_processus, (*((struct_liste_chainee *)
897: element_courant)).donnee);
898: free((struct_liste_chainee *) element_courant);
899:
900: element_courant = element_suivant;
901: }
902:
903: element_courant = (*s_etat_processus).l_base_pile_taille_contextes;
904: while(element_courant != NULL)
905: {
906: element_suivant = (*((struct_liste_chainee *)
907: element_courant)).suivant;
908:
909: pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
910: element_courant)).donnee).mutex));
911: pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
912: element_courant)).donnee).mutex));
913: liberation(s_etat_processus,
914: (*((struct_liste_chainee *)
915: element_courant)).donnee);
916: free((struct_liste_chainee *) element_courant);
917:
918: element_courant = element_suivant;
919: }
920:
921: for(i = 0; i < (*s_etat_processus).nombre_instructions_externes;
922: i++)
923: {
924: free((*s_etat_processus).s_instructions_externes[i].nom);
925: free((*s_etat_processus).s_instructions_externes[i]
926: .nom_bibliotheque);
927: }
928:
929: if ((*s_etat_processus).nombre_instructions_externes != 0)
930: {
931: free((*s_etat_processus).s_instructions_externes);
932: }
933:
934: element_courant = (*s_etat_processus).s_bibliotheques;
935: while(element_courant != NULL)
936: {
937: element_suivant = (*((struct_liste_chainee *)
938: element_courant)).suivant;
939:
940: element_candidat = (*candidat).s_bibliotheques;
941: while(element_candidat != NULL)
942: {
943: if (((*((struct_bibliotheque *) (*((struct_liste_chainee *)
944: element_courant)).donnee))
945: .descripteur == (*((struct_bibliotheque *)
946: (*((struct_liste_chainee *) element_candidat))
947: .donnee)).descripteur) &&
948: ((*((struct_bibliotheque *)
949: (*((struct_liste_chainee *) element_courant))
950: .donnee)).pid == (*((struct_bibliotheque *)
951: (*((struct_liste_chainee *) element_candidat))
952: .donnee)).pid) && (pthread_equal(
953: (*((struct_bibliotheque *)
954: (*((struct_liste_chainee *) element_courant))
955: .donnee)).tid, (*((struct_bibliotheque *)
956: (*((struct_liste_chainee *) element_candidat))
957: .donnee)).tid) != 0))
958: {
959: break;
960: }
961:
962: element_candidat = (*((struct_liste_chainee *)
963: element_candidat)).suivant;
964: }
965:
966: if (element_candidat == NULL)
967: {
968: dlclose((*((struct_bibliotheque *)
969: (*((struct_liste_chainee *) element_courant))
970: .donnee)).descripteur);
971: }
972:
973: free((*((struct_bibliotheque *)
974: (*((struct_liste_chainee *)
975: element_courant)).donnee)).nom);
976: free((*((struct_liste_chainee *) element_courant)).donnee);
977: free(element_courant);
978:
979: element_courant = element_suivant;
980: }
981:
982: element_courant = (*s_etat_processus).l_base_pile_last;
983: while(element_courant != NULL)
984: {
985: element_suivant = (*((struct_liste_chainee *)
986: element_courant)).suivant;
987:
988: pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
989: element_courant)).donnee).mutex));
990: pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
991: element_courant)).donnee).mutex));
992: liberation(s_etat_processus,
993: (*((struct_liste_chainee *) element_courant)).donnee);
994: free(element_courant);
995:
996: element_courant = element_suivant;
997: }
998:
999: element_courant = (*s_etat_processus).l_base_pile_systeme;
1000: while(element_courant != NULL)
1001: {
1002: element_suivant = (*((struct_liste_pile_systeme *)
1003: element_courant)).suivant;
1004:
1005: if ((*((struct_liste_pile_systeme *)
1006: element_courant)).indice_boucle != NULL)
1007: {
1008: pthread_mutex_trylock(&((*(*((struct_liste_pile_systeme *)
1009: element_courant)).indice_boucle).mutex));
1010: pthread_mutex_unlock(&((*(*((struct_liste_pile_systeme *)
1011: element_courant)).indice_boucle).mutex));
1012: }
1013:
1014: liberation(s_etat_processus,
1015: (*((struct_liste_pile_systeme *)
1016: element_courant)).indice_boucle);
1017:
1018: if ((*((struct_liste_pile_systeme *)
1019: element_courant)).limite_indice_boucle != NULL)
1020: {
1021: pthread_mutex_trylock(&((*(*((struct_liste_pile_systeme *)
1022: element_courant)).limite_indice_boucle).mutex));
1023: pthread_mutex_unlock(&((*(*((struct_liste_pile_systeme *)
1024: element_courant)).limite_indice_boucle).mutex));
1025: }
1026:
1027: liberation(s_etat_processus,
1028: (*((struct_liste_pile_systeme *)
1029: element_courant)).limite_indice_boucle);
1030:
1031: if ((*((struct_liste_pile_systeme *)
1032: element_courant)).objet_de_test != NULL)
1033: {
1034: pthread_mutex_trylock(&((*(*((struct_liste_pile_systeme *)
1035: element_courant)).objet_de_test).mutex));
1036: pthread_mutex_unlock(&((*(*((struct_liste_pile_systeme *)
1037: element_courant)).objet_de_test).mutex));
1038: }
1039:
1040: liberation(s_etat_processus,
1041: (*((struct_liste_pile_systeme *)
1042: element_courant)).objet_de_test);
1043:
1044: if ((*((struct_liste_pile_systeme *)
1045: element_courant)).nom_variable != NULL)
1046: {
1047: free((*((struct_liste_pile_systeme *)
1048: element_courant)).nom_variable);
1049: }
1050:
1051: free(element_courant);
1052:
1053: element_courant = element_suivant;
1054: }
1055:
1056: element_courant = (*s_etat_processus).s_fichiers;
1057: while(element_courant != NULL)
1058: {
1059: element_suivant = (*((struct_liste_chainee *)
1060: element_courant)).suivant;
1061:
1062: element_candidat = (*candidat).s_fichiers;
1063: while(element_candidat != NULL)
1064: {
1065: if (((*((struct_descripteur_fichier *)
1066: (*((struct_liste_chainee *) element_courant))
1067: .donnee)).pid ==
1068: (*((struct_descripteur_fichier *)
1069: (*((struct_liste_chainee *) element_candidat))
1070: .donnee)).pid) && (pthread_equal(
1071: (*((struct_descripteur_fichier *)
1072: (*((struct_liste_chainee *) element_courant))
1073: .donnee)).tid, (*((struct_descripteur_fichier *)
1074: (*((struct_liste_chainee *) element_candidat))
1075: .donnee)).tid) != 0))
1076: {
1077: if ((*((struct_descripteur_fichier *)
1078: (*((struct_liste_chainee *) element_courant))
1079: .donnee)).type ==
1080: (*((struct_descripteur_fichier *)
1081: (*((struct_liste_chainee *) element_candidat))
1082: .donnee)).type)
1083: {
1084: if ((*((struct_descripteur_fichier *)
1085: (*((struct_liste_chainee *)
1086: element_candidat)).donnee)).type == 'C')
1087: {
1088: if ((*((struct_descripteur_fichier *)
1089: (*((struct_liste_chainee *)
1090: element_courant)).donnee))
1091: .descripteur_c ==
1092: (*((struct_descripteur_fichier *)
1093: (*((struct_liste_chainee *)
1094: element_candidat)).donnee))
1095: .descripteur_c)
1096: {
1097: break;
1098: }
1099: }
1100: else
1101: {
1102: if (((*((struct_descripteur_fichier *)
1103: (*((struct_liste_chainee *)
1104: element_courant)).donnee))
1105: .descripteur_sqlite ==
1106: (*((struct_descripteur_fichier *)
1107: (*((struct_liste_chainee *)
1108: element_candidat)).donnee))
1109: .descripteur_sqlite) &&
1110: ((*((struct_descripteur_fichier *)
1111: (*((struct_liste_chainee *)
1112: element_courant)).donnee))
1113: .descripteur_c ==
1114: (*((struct_descripteur_fichier *)
1115: (*((struct_liste_chainee *)
1116: element_candidat)).donnee))
1117: .descripteur_c))
1118: {
1119: break;
1120: }
1121: }
1122: }
1123: }
1124:
1125: element_candidat = (*((struct_liste_chainee *)
1126: element_candidat)).suivant;
1127: }
1128:
1129: if (element_candidat == NULL)
1130: {
1131: fclose((*((struct_descripteur_fichier *)
1132: (*((struct_liste_chainee *) element_courant))
1133: .donnee)).descripteur_c);
1134:
1135: if ((*((struct_descripteur_fichier *)
1136: (*((struct_liste_chainee *) element_courant))
1137: .donnee)).type != 'C')
1138: {
1139: sqlite3_close((*((struct_descripteur_fichier *)
1140: (*((struct_liste_chainee *) element_courant))
1141: .donnee)).descripteur_sqlite);
1142: }
1143: }
1144:
1145: free((*((struct_descripteur_fichier *)
1146: (*((struct_liste_chainee *)
1147: element_courant)).donnee)).nom);
1148: free((struct_descripteur_fichier *)
1149: (*((struct_liste_chainee *)
1150: element_courant)).donnee);
1151: free(element_courant);
1152:
1153: element_courant = element_suivant;
1154: }
1155:
1156: element_courant = (*s_etat_processus).s_sockets;
1157: while(element_courant != NULL)
1158: {
1159: element_suivant = (*((struct_liste_chainee *)
1160: element_courant)).suivant;
1161:
1162: element_candidat = (*candidat).s_sockets;
1163: while(element_candidat != NULL)
1164: {
1165: if (((*((struct_socket *)
1166: (*((struct_liste_chainee *) element_courant))
1167: .donnee)).socket == (*((struct_socket *)
1168: (*((struct_liste_chainee *) element_candidat))
1169: .donnee)).socket) &&
1170: ((*((struct_socket *)
1171: (*((struct_liste_chainee *) element_courant))
1172: .donnee)).pid == (*((struct_socket *)
1173: (*((struct_liste_chainee *) element_candidat))
1174: .donnee)).pid) && (pthread_equal(
1175: (*((struct_socket *)
1176: (*((struct_liste_chainee *) element_courant))
1177: .donnee)).tid, (*((struct_socket *)
1178: (*((struct_liste_chainee *) element_candidat))
1179: .donnee)).tid) != 0))
1180: {
1181: break;
1182: }
1183:
1184: element_candidat = (*((struct_liste_chainee *)
1185: element_candidat)).suivant;
1186: }
1187:
1188: if (element_candidat == NULL)
1189: {
1190: if ((*((struct_socket *) (*((struct_liste_chainee *)
1191: element_courant)).donnee)).socket_connectee
1192: == d_vrai)
1193: {
1194: shutdown((*((struct_socket *)
1195: (*((struct_liste_chainee *) element_courant))
1196: .donnee)).socket, SHUT_RDWR);
1197: }
1198:
1199: close((*((struct_socket *)
1200: (*((struct_liste_chainee *) element_courant))
1201: .donnee)).socket);
1202: }
1203:
1204: pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
1205: element_courant)).donnee).mutex));
1206: pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
1207: element_courant)).donnee).mutex));
1208:
1209: liberation(s_etat_processus,
1210: (*((struct_liste_chainee *)
1211: element_courant)).donnee);
1212: free(element_courant);
1213:
1214: element_courant = element_suivant;
1215: }
1216:
1217: /*
1218: ================================================================================
1219: À noter : on ne ferme pas la connexion car la conséquence immédiate est
1220: une destruction de l'objet pour le processus père.
1221: ================================================================================
1222:
1223: element_courant = (*s_etat_processus).s_connecteurs_sql;
1224: while(element_courant != NULL)
1225: {
1226: element_suivant = (*((struct_liste_chainee *)
1227: element_courant)).suivant;
1228:
1229: element_candidat = (*candidat).s_connecteurs_sql;
1230: while(element_candidat != NULL)
1231: {
1232: if (((
1233: #ifdef MYSQL_SUPPORT
1234: ((*((struct_connecteur_sql *)
1235: (*((struct_liste_chainee *) element_courant))
1236: .donnee)).descripteur.mysql ==
1237: (*((struct_connecteur_sql *)
1238: (*((struct_liste_chainee *) element_candidat))
1239: .donnee)).descripteur.mysql)
1240: &&
1241: (strcmp((*((struct_connecteur_sql *)
1242: (*((struct_liste_chainee *) element_courant))
1243: .donnee)).type, "MYSQL") == 0)
1244: &&
1245: (strcmp((*((struct_connecteur_sql *)
1246: (*((struct_liste_chainee *) element_candidat))
1247: .donnee)).type, "MYSQL") == 0)
1248: #else
1249: 0
1250: #endif
1251: ) || (
1252: #ifdef POSTGRESQL_SUPPORT
1253: ((*((struct_connecteur_sql *)
1254: (*((struct_liste_chainee *) element_courant))
1255: .donnee)).descripteur.postgresql ==
1256: (*((struct_connecteur_sql *)
1257: (*((struct_liste_chainee *) element_candidat))
1258: .donnee)).descripteur.postgresql)
1259: &&
1260: (strcmp((*((struct_connecteur_sql *)
1261: (*((struct_liste_chainee *) element_courant))
1262: .donnee)).type, "POSTGRESQL") == 0)
1263: &&
1264: (strcmp((*((struct_connecteur_sql *)
1265: (*((struct_liste_chainee *) element_candidat))
1266: .donnee)).type, "POSTGRESQL") == 0)
1267: #else
1268: 0
1269: #endif
1270: )) &&
1271: ((*((struct_connecteur_sql *)
1272: (*((struct_liste_chainee *) element_courant))
1273: .donnee)).pid == (*((struct_connecteur_sql *)
1274: (*((struct_liste_chainee *) element_candidat))
1275: .donnee)).pid) && (pthread_equal(
1276: (*((struct_connecteur_sql *)
1277: (*((struct_liste_chainee *) element_courant))
1278: .donnee)).tid, (*((struct_connecteur_sql *)
1279: (*((struct_liste_chainee *) element_candidat))
1280: .donnee)).tid) != 0))
1281: {
1282: break;
1283: }
1284:
1285: element_candidat = (*((struct_liste_chainee *)
1286: element_candidat)).suivant;
1287: }
1288:
1289: if (element_candidat == NULL)
1290: {
1291: sqlclose((*((struct_liste_chainee *) element_courant))
1292: .donnee);
1293: }
1294:
1295: pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
1296: element_courant)).donnee).mutex));
1297: pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
1298: element_courant)).donnee).mutex));
1299:
1300: liberation(s_etat_processus, (*((struct_liste_chainee *)
1301: element_courant)).donnee);
1302: free(element_courant);
1303:
1304: element_courant = element_suivant;
1305: }
1306: */
1307:
1308: (*s_etat_processus).s_connecteurs_sql = NULL;
1309:
1310: element_courant = (*s_etat_processus).s_marques;
1311: while(element_courant != NULL)
1312: {
1313: free((*((struct_marque *) element_courant)).label);
1314: free((*((struct_marque *) element_courant)).position);
1315: element_suivant = (*((struct_marque *) element_courant))
1316: .suivant;
1317: free(element_courant);
1318: element_courant = element_suivant;
1319: }
1320:
1321: liberation_allocateur(s_etat_processus);
1322:
1323: # ifndef SEMAPHORES_NOMMES
1324: sem_post(&((*s_etat_processus).semaphore_fork));
1325: sem_destroy(&((*s_etat_processus).semaphore_fork));
1326: # else
1327: sem_post((*s_etat_processus).semaphore_fork);
1328: sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork);
1329: # endif
1330:
1331: free(s_etat_processus);
1332:
1333: s_etat_processus = candidat;
1334: }
1335:
1336: l_element_suivant = (*l_element_courant).suivant;
1337:
1338: free((struct_thread *) (*l_element_courant).donnee);
1339: free((struct_liste_chainee *) l_element_courant);
1340:
1341: l_element_courant = l_element_suivant;
1342: }
1343:
1344: liste_threads = NULL;
1345:
1346: l_element_courant = liste_threads_surveillance;
1347:
1348: while(l_element_courant != NULL)
1349: {
1350: s_argument_thread = (struct_descripteur_thread *)
1351: (*l_element_courant).donnee;
1352:
1353: if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)
1354: {
1355: (*s_etat_processus).erreur_systeme = d_es_processus;
1356: sem_post(&semaphore_liste_threads);
1357: return;
1358: }
1359:
1360: (*s_argument_thread).nombre_references--;
1361:
1362: BUG((*s_argument_thread).nombre_references < 0,
1363: printf("(*s_argument_thread).nombre_references = %d\n",
1364: (int) (*s_argument_thread).nombre_references));
1365:
1366: if ((*s_argument_thread).nombre_references == 0)
1367: {
1368: close((*s_argument_thread).pipe_objets[0]);
1369: close((*s_argument_thread).pipe_acquittement[1]);
1370: close((*s_argument_thread).pipe_injections[1]);
1371: close((*s_argument_thread).pipe_nombre_injections[1]);
1372: close((*s_argument_thread).pipe_nombre_objets_attente[0]);
1373: close((*s_argument_thread).pipe_interruptions[0]);
1374: close((*s_argument_thread).pipe_nombre_interruptions_attente[0]);
1375:
1376: if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
1377: {
1378: (*s_etat_processus).erreur_systeme = d_es_processus;
1379: sem_post(&semaphore_liste_threads);
1380: return;
1381: }
1382:
1383: pthread_mutex_destroy(&((*s_argument_thread).mutex));
1384:
1385: if ((*s_argument_thread).processus_detache == d_faux)
1386: {
1387: if ((*s_argument_thread).destruction_objet == d_vrai)
1388: {
1389: liberation(s_etat_processus, (*s_argument_thread).argument);
1390: }
1391: }
1392:
1393: free(s_argument_thread);
1394: }
1395: else
1396: {
1397: if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
1398: {
1399: (*s_etat_processus).erreur_systeme = d_es_processus;
1400: sem_post(&semaphore_liste_threads);
1401: return;
1402: }
1403: }
1404:
1405: l_element_suivant = (*l_element_courant).suivant;
1406: free((struct_liste_chainee *) l_element_courant);
1407: l_element_courant = l_element_suivant;
1408: }
1409:
1410: liste_threads_surveillance = NULL;
1411:
1412: # ifndef SEMAPHORES_NOMMES
1413: if (sem_post(&semaphore_liste_threads) != 0)
1414: # else
1415: if (sem_post(semaphore_liste_threads) != 0)
1416: # endif
1417: {
1418: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1419: (*s_etat_processus).erreur_systeme = d_es_processus;
1420: return;
1421: }
1422:
1423: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1424: sigpending(&set);
1425: return;
1426: }
1427:
1428: static struct_processus *
1429: recherche_thread(pid_t pid, pthread_t tid)
1430: {
1431: volatile struct_liste_chainee_volatile *l_element_courant;
1432:
1433: struct_processus *s_etat_processus;
1434:
1435: l_element_courant = liste_threads;
1436:
1437: while(l_element_courant != NULL)
1438: {
1439: if ((pthread_equal((*((struct_thread *) (*l_element_courant).donnee))
1440: .tid, tid) != 0) && ((*((struct_thread *)
1441: (*l_element_courant).donnee)).pid == pid))
1442: {
1443: break;
1444: }
1445:
1446: l_element_courant = (*l_element_courant).suivant;
1447: }
1448:
1449: if (l_element_courant == NULL)
1450: {
1451: /*
1452: * Le processus n'existe plus. On ne distribue aucun signal.
1453: */
1454:
1455: return(NULL);
1456: }
1457:
1458: s_etat_processus = (*((struct_thread *)
1459: (*l_element_courant).donnee)).s_etat_processus;
1460:
1461: return(s_etat_processus);
1462: }
1463:
1464: static logical1
1465: recherche_thread_principal(pid_t pid, pthread_t *thread)
1466: {
1467: volatile struct_liste_chainee_volatile *l_element_courant;
1468:
1469: l_element_courant = liste_threads;
1470:
1471: while(l_element_courant != NULL)
1472: {
1473: if (((*((struct_thread *) (*l_element_courant).donnee)).thread_principal
1474: == d_vrai) && ((*((struct_thread *)
1475: (*l_element_courant).donnee)).pid == pid))
1476: {
1477: break;
1478: }
1479:
1480: l_element_courant = (*l_element_courant).suivant;
1481: }
1482:
1483: if (l_element_courant == NULL)
1484: {
1485: /*
1486: * Le processus n'existe plus. On ne distribue aucun signal.
1487: */
1488:
1489: return(d_faux);
1490: }
1491:
1492: (*thread) = (*((struct_thread *) (*l_element_courant).donnee)).tid;
1493:
1494: return(d_vrai);
1495: }
1496:
1497:
1498: /*
1499: ================================================================================
1500: Procédures de gestion des signaux d'interruption
1501: ================================================================================
1502: Entrée : variable globale
1503: --------------------------------------------------------------------------------
1504: Sortie : variable globale modifiée
1505: --------------------------------------------------------------------------------
1506: Effets de bord : néant
1507: ================================================================================
1508: */
1509:
1510: // Les routines suivantes sont uniquement appelées depuis les gestionnaires
1511: // des signaux asynchrones. Elles ne doivent pas bloquer dans le cas où
1512: // les sémaphores sont déjà bloqués par un gestionnaire de signal.
1513:
1514: static inline void
1515: verrouillage_gestionnaire_signaux()
1516: {
1517: int semaphore;
1518:
1519: sigset_t oldset;
1520: sigset_t set;
1521:
1522: sem_t *sem;
1523:
1524: if ((sem = pthread_getspecific(semaphore_fork_processus_courant))
1525: != NULL)
1526: {
1527: if (sem_post(sem) != 0)
1528: {
1529: BUG(1, uprintf("Lock error !\n"));
1530: return;
1531: }
1532: }
1533:
1534: // Il faut respecteur l'atomicité des deux opérations suivantes !
1535:
1536: sigfillset(&set);
1537: pthread_sigmask(SIG_BLOCK, &set, &oldset);
1538:
1539: # ifndef SEMAPHORES_NOMMES
1540: while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1)
1541: # else
1542: while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1)
1543: # endif
1544: {
1545: if (errno != EINTR)
1546: {
1547: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1548: BUG(1, uprintf("Unlock error !\n"));
1549: return;
1550: }
1551: }
1552:
1553: # ifndef SEMAPHORES_NOMMES
1554: if (sem_post(&semaphore_gestionnaires_signaux) == -1)
1555: # else
1556: if (sem_post(semaphore_gestionnaires_signaux) == -1)
1557: # endif
1558: {
1559: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1560: BUG(1, uprintf("Lock error !\n"));
1561: return;
1562: }
1563:
1564: # ifndef SEMAPHORES_NOMMES
1565: if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)
1566: # else
1567: if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
1568: # endif
1569: {
1570: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1571: BUG(1, uprintf("Lock error !\n"));
1572: return;
1573: }
1574:
1575: # ifndef SEMAPHORES_NOMMES
1576: if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0)
1577: # else
1578: if (sem_post(semaphore_gestionnaires_signaux_atomique) != 0)
1579: # endif
1580: {
1581: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1582: BUG(1, uprintf("Unlock error !\n"));
1583: return;
1584: }
1585:
1586: if (semaphore == 1)
1587: {
1588: // Le semaphore ne peut être pris par le thread qui a appelé
1589: // le gestionnaire de signal car le signal est bloqué par ce thread
1590: // dans les zones critiques. Ce sémaphore ne peut donc être bloqué que
1591: // par un thread concurrent. On essaye donc de le bloquer jusqu'à
1592: // ce que ce soit possible.
1593:
1594: # ifndef SEMAPHORES_NOMMES
1595: while(sem_trywait(&semaphore_liste_threads) == -1)
1596: # else
1597: while(sem_trywait(semaphore_liste_threads) == -1)
1598: # endif
1599: {
1600: perror("sem_trywait");
1601: if ((errno != EINTR) && (errno != EAGAIN))
1602: {
1603: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1604:
1605: while(sem_wait(sem) == -1)
1606: {
1607: if (errno != EINTR)
1608: {
1609: BUG(1, uprintf("Lock error !\n"));
1610: return;
1611: }
1612: }
1613:
1614: BUG(1, uprintf("Lock error !\n"));
1615: return;
1616: }
1617:
1618: sched_yield();
1619: }
1620: }
1621:
1622: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1623: sigpending(&set);
1624:
1625: return;
1626: }
1627:
1628: static inline void
1629: deverrouillage_gestionnaire_signaux()
1630: {
1631: int semaphore;
1632:
1633: sem_t *sem;
1634:
1635: sigset_t oldset;
1636: sigset_t set;
1637:
1638: // Il faut respecteur l'atomicité des deux opérations suivantes !
1639:
1640: sigfillset(&set);
1641: pthread_sigmask(SIG_BLOCK, &set, &oldset);
1642:
1643: # ifndef SEMAPHORES_NOMMES
1644: while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1)
1645: # else
1646: while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1)
1647: # endif
1648: {
1649: if (errno != EINTR)
1650: {
1651: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1652: BUG(1, uprintf("Unlock error !\n"));
1653: return;
1654: }
1655: }
1656:
1657: # ifndef SEMAPHORES_NOMMES
1658: if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)
1659: # else
1660: if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
1661: # endif
1662: {
1663: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1664: BUG(1, uprintf("Unlock error !\n"));
1665: return;
1666: }
1667:
1668: # ifndef SEMAPHORES_NOMMES
1669: while(sem_wait(&semaphore_gestionnaires_signaux) == -1)
1670: # else
1671: while(sem_wait(semaphore_gestionnaires_signaux) == -1)
1672: # endif
1673: {
1674: if (errno != EINTR)
1675: {
1676: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1677: BUG(1, uprintf("Unlock error !\n"));
1678: return;
1679: }
1680: }
1681:
1682: # ifndef SEMAPHORES_NOMMES
1683: if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0)
1684: # else
1685: if (sem_post(semaphore_gestionnaires_signaux_atomique) != 0)
1686: # endif
1687: {
1688: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1689: BUG(1, uprintf("Unlock error !\n"));
1690: return;
1691: }
1692:
1693: if ((sem = pthread_getspecific(semaphore_fork_processus_courant))
1694: != NULL)
1695: {
1696: while(sem_wait(sem) == -1)
1697: {
1698: if (errno != EINTR)
1699: {
1700: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1701: BUG(1, uprintf("Unlock error !\n"));
1702: return;
1703: }
1704: }
1705: }
1706:
1707: if (semaphore == 1)
1708: {
1709: # ifndef SEMAPHORES_NOMMES
1710: if (sem_post(&semaphore_liste_threads) != 0)
1711: # else
1712: if (sem_post(semaphore_liste_threads) != 0)
1713: # endif
1714: {
1715: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1716:
1717: BUG(1, uprintf("Unlock error !\n"));
1718: return;
1719: }
1720: }
1721:
1722: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1723: sigpending(&set);
1724:
1725: return;
1726: }
1727:
1728: void
1729: interruption1(SIGHANDLER_ARGS)
1730: {
1731: pid_t pid;
1732:
1733: pthread_t thread;
1734:
1735: struct_processus *s_etat_processus;
1736:
1737: volatile sig_atomic_t exclusion = 0;
1738:
1739: verrouillage_gestionnaire_signaux();
1740:
1741: # ifdef _BROKEN_SIGINFO
1742: if (signal == SIGINT)
1743: {
1744: // Si l'interruption provient du clavier, il n'y a pas eu d'appel
1745: // à queue_in().
1746:
1747: pid = getpid();
1748: }
1749: else
1750: {
1751: pid = origine_signal(signal);
1752: }
1753: # else
1754: pid = (*siginfo).si_pid;
1755: # endif
1756:
1757: switch(signal)
1758: {
1759: case SIGALRM :
1760: {
1761: if (pid == getpid())
1762: {
1763: if ((s_etat_processus = recherche_thread(getpid(),
1764: pthread_self())) == NULL)
1765: {
1766: deverrouillage_gestionnaire_signaux();
1767: return;
1768: }
1769:
1770: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
1771: {
1772: printf("[%d] SIGALRM (thread %llu)\n", (int) getpid(),
1773: (unsigned long long) pthread_self());
1774: fflush(stdout);
1775: }
1776:
1777: if ((*s_etat_processus).pid_processus_pere != getpid())
1778: {
1779: kill((*s_etat_processus).pid_processus_pere, signal);
1780: }
1781: else
1782: {
1783: (*s_etat_processus).var_volatile_alarme = -1;
1784: (*s_etat_processus).var_volatile_requete_arret = -1;
1785: }
1786: }
1787: else
1788: {
1789: if (recherche_thread_principal(getpid(), &thread) == d_vrai)
1790: {
1791: pthread_kill(thread, signal);
1792: }
1793: }
1794:
1795: break;
1796: }
1797:
1798: case SIGINT :
1799: {
1800: /*
1801: * Une vieille spécification POSIX permet au pointeur siginfo
1802: * d'être nul dans le cas d'un ^C envoyé depuis le clavier.
1803: * Solaris suit en particulier cette spécification.
1804: */
1805:
1806: # ifndef _BROKEN_SIGINFO
1807: if (siginfo == NULL)
1808: {
1809: kill(getpid(), signal);
1810: }
1811: else
1812: # endif
1813: if (pid == getpid())
1814: {
1815: if ((s_etat_processus = recherche_thread(getpid(),
1816: pthread_self())) == NULL)
1817: {
1818: deverrouillage_gestionnaire_signaux();
1819: return;
1820: }
1821:
1822: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
1823: {
1824: printf("[%d] SIGINT (thread %llu)\n", (int) getpid(),
1825: (unsigned long long) pthread_self());
1826: fflush(stdout);
1827: }
1828:
1829: if ((*s_etat_processus).pid_processus_pere != getpid())
1830: {
1831: kill((*s_etat_processus).pid_processus_pere, signal);
1832: }
1833: else
1834: {
1835: (*s_etat_processus).var_volatile_traitement_sigint = -1;
1836:
1837: while(exclusion == 1);
1838: exclusion = 1;
1839:
1840: if ((*s_etat_processus).var_volatile_requete_arret == -1)
1841: {
1842: deverrouillage_gestionnaire_signaux();
1843: exclusion = 0;
1844: return;
1845: }
1846:
1847: if (strncmp(getenv("LANG"), "fr", 2) == 0)
1848: {
1849: printf("+++Interruption\n");
1850: }
1851: else
1852: {
1853: printf("+++Interrupt\n");
1854: }
1855:
1856: fflush(stdout);
1857:
1858: (*s_etat_processus).var_volatile_requete_arret = -1;
1859: (*s_etat_processus).var_volatile_alarme = -1;
1860:
1861: exclusion = 0;
1862: }
1863: }
1864: else
1865: {
1866: if (recherche_thread_principal(getpid(), &thread) == d_vrai)
1867: {
1868: pthread_kill(thread, signal);
1869: }
1870: }
1871:
1872: break;
1873: }
1874:
1875: default :
1876: {
1877: BUG(1, uprintf("[%d] Unknown signal %d in this context\n",
1878: (int) getpid(), signal));
1879: break;
1880: }
1881: }
1882:
1883: deverrouillage_gestionnaire_signaux();
1884: return;
1885: }
1886:
1887: void
1888: interruption2(SIGHANDLER_ARGS)
1889: {
1890: pid_t pid;
1891:
1892: pthread_t thread;
1893:
1894: struct_processus *s_etat_processus;
1895:
1896: verrouillage_gestionnaire_signaux();
1897:
1898: # ifdef _BROKEN_SIGINFO
1899: pid = origine_signal(signal);
1900: # else
1901: pid = (*siginfo).si_pid;
1902: # endif
1903:
1904: # ifndef _BROKEN_SIGINFO
1905: if (siginfo == NULL)
1906: {
1907: /*
1908: * Le signal SIGFSTP provient de la mort du processus de contrôle.
1909: * Sous certains systèmes (Linux...), la mort du terminal de contrôle
1910: * se traduit par l'envoi d'un SIGHUP au processus. Sur d'autres
1911: * (SunOS), le processus reçoit un SIGFSTP avec une structure siginfo
1912: * non initialisée (pointeur NULL) issue de TERMIO.
1913: */
1914:
1915: if (recherche_thread_principal(getpid(), &thread) == d_vrai)
1916: {
1917: pthread_kill(thread, SIGHUP);
1918: deverrouillage_gestionnaire_signaux();
1919: return;
1920: }
1921: }
1922: else
1923: # endif
1924: if (pid == getpid())
1925: {
1926: if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
1927: == NULL)
1928: {
1929: deverrouillage_gestionnaire_signaux();
1930: return;
1931: }
1932:
1933: /*
1934: * 0 => fonctionnement normal
1935: * -1 => requête
1936: * 1 => requête acceptée en attente de traitement
1937: */
1938:
1939: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
1940: {
1941: printf("[%d] SIGTSTP (thread %llu)\n", (int) getpid(),
1942: (unsigned long long) pthread_self());
1943: fflush(stdout);
1944: }
1945:
1946: if ((*s_etat_processus).var_volatile_processus_pere == 0)
1947: {
1948: kill((*s_etat_processus).pid_processus_pere, signal);
1949: }
1950: else
1951: {
1952: (*s_etat_processus).var_volatile_requete_arret2 = -1;
1953: }
1954: }
1955: else
1956: {
1957: // Envoi d'un signal au thread maître du groupe.
1958:
1959: if (recherche_thread_principal(getpid(), &thread) == d_vrai)
1960: {
1961: pthread_kill(thread, SIGTSTP);
1962: deverrouillage_gestionnaire_signaux();
1963: return;
1964: }
1965: }
1966:
1967: deverrouillage_gestionnaire_signaux();
1968: return;
1969: }
1970:
1971: void
1972: interruption3(SIGHANDLER_ARGS)
1973: {
1974: pid_t pid;
1975:
1976: struct_processus *s_etat_processus;
1977:
1978: static int compteur = 0;
1979:
1980: verrouillage_gestionnaire_signaux();
1981:
1982: # ifdef _BROKEN_SIGINFO
1983: pid = origine_signal(signal);
1984: # else
1985: pid = (*siginfo).si_pid;
1986: # endif
1987:
1988: if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
1989: {
1990: deverrouillage_gestionnaire_signaux();
1991: return;
1992: }
1993:
1994: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
1995: {
1996: printf("[%d] SIGSEGV (thread %llu)\n", (int) getpid(),
1997: (unsigned long long) pthread_self());
1998: fflush(stdout);
1999: }
2000:
2001: if ((*s_etat_processus).var_volatile_recursivite == -1)
2002: {
2003: // Segfault dans un appel de fonction récursive
2004: deverrouillage_gestionnaire_signaux();
2005: longjmp(contexte, -1);
2006: }
2007: else
2008: {
2009: // Segfault dans une routine interne
2010: if (strncmp(getenv("LANG"), "fr", 2) == 0)
2011: {
2012: printf("+++Système : Violation d'accès (dépassement de pile)\n");
2013: }
2014: else
2015: {
2016: printf("+++System : Access violation (stack overflow)\n");
2017: }
2018:
2019: fflush(stdout);
2020:
2021: compteur++;
2022:
2023: if (compteur > 1)
2024: {
2025: deverrouillage_gestionnaire_signaux();
2026: exit(EXIT_FAILURE);
2027: }
2028: else
2029: {
2030: deverrouillage_gestionnaire_signaux();
2031: longjmp(contexte_initial, -1);
2032: }
2033: }
2034:
2035: deverrouillage_gestionnaire_signaux();
2036: return;
2037: }
2038:
2039: void
2040: interruption4(SIGHANDLER_ARGS)
2041: {
2042: pid_t pid;
2043:
2044: struct_processus *s_etat_processus;
2045:
2046: verrouillage_gestionnaire_signaux();
2047:
2048: # ifdef _BROKEN_SIGINFO
2049: pid = origine_signal(signal);
2050: # else
2051: pid = (*siginfo).si_pid;
2052: # endif
2053:
2054: if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
2055: {
2056: deverrouillage_gestionnaire_signaux();
2057: return;
2058: }
2059:
2060: /*
2061: * Démarrage d'un processus fils ou gestion de SIGCONT (SUSPEND)
2062: */
2063:
2064: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
2065: {
2066: printf("[%d] SIGSTART/SIGCONT (thread %llu)\n", (int) getpid(),
2067: (unsigned long long) pthread_self());
2068: fflush(stdout);
2069: }
2070:
2071: deverrouillage_gestionnaire_signaux();
2072: return;
2073: }
2074:
2075: void
2076: interruption5(SIGHANDLER_ARGS)
2077: {
2078: pid_t pid;
2079:
2080: pthread_t thread;
2081:
2082: struct_processus *s_etat_processus;
2083:
2084: verrouillage_gestionnaire_signaux();
2085:
2086: # ifdef _BROKEN_SIGINFO
2087: pid = origine_signal(signal);
2088: # else
2089: pid = (*siginfo).si_pid;
2090: # endif
2091:
2092: if (pid == getpid())
2093: {
2094: if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
2095: == NULL)
2096: {
2097: deverrouillage_gestionnaire_signaux();
2098: return;
2099: }
2100:
2101: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
2102: {
2103: printf("[%d] SIGFSTOP (thread %llu)\n", (int) getpid(),
2104: (unsigned long long) pthread_self());
2105: fflush(stdout);
2106: }
2107:
2108: /*
2109: * var_globale_traitement_retarde_stop :
2110: * 0 -> traitement immédiat
2111: * 1 -> traitement retardé (aucun signal reçu)
2112: * -1 -> traitement retardé (un ou plusieurs signaux stop reçus)
2113: */
2114:
2115: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)
2116: {
2117: (*s_etat_processus).var_volatile_requete_arret = -1;
2118: }
2119: else
2120: {
2121: (*s_etat_processus).var_volatile_traitement_retarde_stop = -1;
2122: }
2123: }
2124: else
2125: {
2126: if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
2127: == NULL)
2128: {
2129: deverrouillage_gestionnaire_signaux();
2130: return;
2131: }
2132:
2133: // Envoi d'un signal au thread maître du groupe.
2134:
2135: if (recherche_thread_principal(getpid(), &thread) == d_vrai)
2136: {
2137: pthread_kill(thread, signal);
2138: deverrouillage_gestionnaire_signaux();
2139: return;
2140: }
2141: }
2142:
2143: deverrouillage_gestionnaire_signaux();
2144: return;
2145: }
2146:
2147: void
2148: interruption6(SIGHANDLER_ARGS)
2149: {
2150: pid_t pid;
2151:
2152: struct_processus *s_etat_processus;
2153:
2154: verrouillage_gestionnaire_signaux();
2155:
2156: # ifdef _BROKEN_SIGINFO
2157: pid = origine_signal(signal);
2158: # else
2159: pid = (*siginfo).si_pid;
2160: # endif
2161:
2162: if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
2163: {
2164: deverrouillage_gestionnaire_signaux();
2165: return;
2166: }
2167:
2168: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
2169: {
2170: printf("[%d] SIGINJECT/SIGQUIT (thread %llu)\n", (int) getpid(),
2171: (unsigned long long) pthread_self());
2172: fflush(stdout);
2173: }
2174:
2175: deverrouillage_gestionnaire_signaux();
2176: return;
2177: }
2178:
2179: void
2180: interruption7(SIGHANDLER_ARGS)
2181: {
2182: pid_t pid;
2183:
2184: struct_processus *s_etat_processus;
2185:
2186: verrouillage_gestionnaire_signaux();
2187:
2188: # ifdef _BROKEN_SIGINFO
2189: pid = origine_signal(signal);
2190: # else
2191: pid = (*siginfo).si_pid;
2192: # endif
2193:
2194: if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
2195: {
2196: deverrouillage_gestionnaire_signaux();
2197: return;
2198: }
2199:
2200: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
2201: {
2202: printf("[%d] SIGPIPE (thread %llu)\n", (int) getpid(),
2203: (unsigned long long) pthread_self());
2204: fflush(stdout);
2205: }
2206:
2207: (*s_etat_processus).var_volatile_requete_arret = -1;
2208: deverrouillage_gestionnaire_signaux();
2209:
2210: BUG(1, printf("[%d] SIGPIPE\n", (int) getpid()));
2211: return;
2212: }
2213:
2214: void
2215: interruption8(SIGHANDLER_ARGS)
2216: {
2217: pid_t pid;
2218:
2219: pthread_t thread;
2220:
2221: struct_processus *s_etat_processus;
2222:
2223: verrouillage_gestionnaire_signaux();
2224:
2225: # ifdef _BROKEN_SIGINFO
2226: pid = origine_signal(signal);
2227: # else
2228: pid = (*siginfo).si_pid;
2229: # endif
2230:
2231: if (pid == getpid())
2232: {
2233: if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
2234: == NULL)
2235: {
2236: deverrouillage_gestionnaire_signaux();
2237: return;
2238: }
2239:
2240: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
2241: {
2242: printf("[%d] SIGURG (thread %llu)\n", (int) getpid(),
2243: (unsigned long long) pthread_self());
2244: fflush(stdout);
2245: }
2246:
2247: (*s_etat_processus).var_volatile_alarme = -1;
2248: (*s_etat_processus).var_volatile_requete_arret = -1;
2249: }
2250: else
2251: {
2252: // Envoi d'un signal au thread maître du groupe.
2253:
2254: if (recherche_thread_principal(getpid(), &thread) == d_vrai)
2255: {
2256: pthread_kill(thread, SIGURG);
2257: deverrouillage_gestionnaire_signaux();
2258: return;
2259: }
2260: }
2261:
2262: deverrouillage_gestionnaire_signaux();
2263: return;
2264: }
2265:
2266: void
2267: interruption9(SIGHANDLER_ARGS)
2268: {
2269: pid_t pid;
2270:
2271: struct_processus *s_etat_processus;
2272:
2273: verrouillage_gestionnaire_signaux();
2274:
2275: # ifdef _BROKEN_SIGINFO
2276: pid = origine_signal(signal);
2277: # else
2278: pid = (*siginfo).si_pid;
2279: # endif
2280:
2281: if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
2282: {
2283: deverrouillage_gestionnaire_signaux();
2284: return;
2285: }
2286:
2287: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
2288: {
2289: printf("[%d] SIGABORT/SIGPROF (thread %llu)\n", (int) getpid(),
2290: (unsigned long long) pthread_self());
2291: fflush(stdout);
2292: }
2293:
2294: # ifdef _BROKEN_SIGINFO
2295: if (queue_in(getpid(), signal) != 0)
2296: {
2297: return;
2298: }
2299:
2300: deverrouillage_gestionnaire_signaux();
2301: interruption11(signal);
2302: # else
2303: deverrouillage_gestionnaire_signaux();
2304: interruption11(signal, siginfo, context);
2305: # endif
2306: return;
2307: }
2308:
2309: void
2310: interruption10(SIGHANDLER_ARGS)
2311: {
2312: file *fichier;
2313:
2314: pid_t pid;
2315:
2316: struct_processus *s_etat_processus;
2317:
2318: unsigned char nom[8 + 64 + 1];
2319:
2320: verrouillage_gestionnaire_signaux();
2321:
2322: # ifdef _BROKEN_SIGINFO
2323: pid = origine_signal(signal);
2324: # else
2325: pid = (*siginfo).si_pid;
2326: # endif
2327:
2328: if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
2329: {
2330: deverrouillage_gestionnaire_signaux();
2331: return;
2332: }
2333:
2334: snprintf(nom, 8 + 64 + 1, "rpl-out-%lu-%lu", (unsigned long) getpid(),
2335: (unsigned long) pthread_self());
2336:
2337: if ((fichier = fopen(nom, "w+")) != NULL)
2338: {
2339: fclose(fichier);
2340:
2341: freopen(nom, "w", stdout);
2342: freopen(nom, "w", stderr);
2343: }
2344:
2345: freopen("/dev/null", "r", stdin);
2346:
2347: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
2348: {
2349: printf("[%d] SIGHUP (thread %llu)\n", (int) getpid(),
2350: (unsigned long long) pthread_self());
2351: fflush(stdout);
2352: }
2353:
2354: deverrouillage_gestionnaire_signaux();
2355: return;
2356: }
2357:
2358: void
2359: interruption11(SIGHANDLER_ARGS)
2360: {
2361: pid_t pid;
2362:
2363: pthread_t thread;
2364:
2365: struct_processus *s_etat_processus;
2366:
2367: verrouillage_gestionnaire_signaux();
2368:
2369: # ifdef _BROKEN_SIGINFO
2370: pid = origine_signal(signal);
2371: # else
2372: pid = (*siginfo).si_pid;
2373: # endif
2374:
2375: if (pid == getpid())
2376: {
2377: if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
2378: == NULL)
2379: {
2380: deverrouillage_gestionnaire_signaux();
2381: return;
2382: }
2383:
2384: (*s_etat_processus).arret_depuis_abort = -1;
2385:
2386: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
2387: {
2388: printf("[%d] SIGFABORT (thread %llu)\n", (int) getpid(),
2389: (unsigned long long) pthread_self());
2390: fflush(stdout);
2391: }
2392:
2393: /*
2394: * var_globale_traitement_retarde_stop :
2395: * 0 -> traitement immédiat
2396: * 1 -> traitement retardé (aucun signal reçu)
2397: * -1 -> traitement retardé (un ou plusieurs signaux stop reçus)
2398: */
2399:
2400: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)
2401: {
2402: (*s_etat_processus).var_volatile_requete_arret = -1;
2403: }
2404: else
2405: {
2406: (*s_etat_processus).var_volatile_traitement_retarde_stop = -1;
2407: }
2408: }
2409: else
2410: {
2411: if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
2412: == NULL)
2413: {
2414: deverrouillage_gestionnaire_signaux();
2415: return;
2416: }
2417:
2418: (*s_etat_processus).arret_depuis_abort = -1;
2419:
2420: // Envoi d'un signal au thread maître du groupe.
2421:
2422: if (recherche_thread_principal(getpid(), &thread) == d_vrai)
2423: {
2424: pthread_kill(thread, signal);
2425: deverrouillage_gestionnaire_signaux();
2426: return;
2427: }
2428: }
2429:
2430: deverrouillage_gestionnaire_signaux();
2431: return;
2432: }
2433:
2434: void
2435: traitement_exceptions_gsl(const char *reason, const char *file,
2436: int line, int gsl_errno)
2437: {
2438: struct_processus *s_etat_processus;
2439:
2440: verrouillage_gestionnaire_signaux();
2441:
2442: if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
2443: {
2444: deverrouillage_gestionnaire_signaux();
2445: return;
2446: }
2447:
2448: (*s_etat_processus).var_volatile_exception_gsl = gsl_errno;
2449: deverrouillage_gestionnaire_signaux();
2450: return;
2451: }
2452:
2453: // 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