1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.9
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: while(sem_wait(&semaphore_liste_threads) == -1)
86: {
87: if (errno != EINTR)
88: {
89: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
90: sigpending(&set);
91:
92: (*s_etat_processus).erreur_systeme = d_es_processus;
93: return;
94: }
95: }
96:
97: if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
98: == NULL)
99: {
100: sem_post(&semaphore_liste_threads);
101: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
102: sigpending(&set);
103:
104: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
105: return;
106: }
107:
108: (*l_nouvel_objet).suivant = liste_threads;
109:
110: if (((*l_nouvel_objet).donnee = malloc(sizeof(struct_thread))) == NULL)
111: {
112: sem_post(&semaphore_liste_threads);
113: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
114: sigpending(&set);
115:
116: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
117: return;
118: }
119:
120: (*((struct_thread *) (*l_nouvel_objet).donnee)).pid = getpid();
121: (*((struct_thread *) (*l_nouvel_objet).donnee)).tid = pthread_self();
122: (*((struct_thread *) (*l_nouvel_objet).donnee)).thread_principal =
123: thread_principal;
124: (*((struct_thread *) (*l_nouvel_objet).donnee)).s_etat_processus =
125: s_etat_processus;
126:
127: liste_threads = l_nouvel_objet;
128:
129: if (sem_post(&semaphore_liste_threads) != 0)
130: {
131: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
132: sigpending(&set);
133:
134: (*s_etat_processus).erreur_systeme = d_es_processus;
135: return;
136: }
137:
138: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
139: sigpending(&set);
140: return;
141: }
142:
143: void
144: insertion_thread_surveillance(struct_processus *s_etat_processus,
145: struct_descripteur_thread *s_argument_thread)
146: {
147: sigset_t oldset;
148: sigset_t set;
149:
150: volatile struct_liste_chainee_volatile *l_nouvel_objet;
151:
152: sigfillset(&set);
153: pthread_sigmask(SIG_BLOCK, &set, &oldset);
154:
155: while(sem_wait(&semaphore_liste_threads) == -1)
156: {
157: if (errno != EINTR)
158: {
159: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
160: sigpending(&set);
161:
162: (*s_etat_processus).erreur_systeme = d_es_processus;
163: return;
164: }
165: }
166:
167: if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
168: == NULL)
169: {
170: sem_post(&semaphore_liste_threads);
171: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
172: sigpending(&set);
173:
174: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
175: return;
176: }
177:
178: (*l_nouvel_objet).suivant = liste_threads_surveillance;
179: (*l_nouvel_objet).donnee = (void *) s_argument_thread;
180:
181: liste_threads_surveillance = l_nouvel_objet;
182:
183: if (sem_post(&semaphore_liste_threads) != 0)
184: {
185: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
186: sigpending(&set);
187:
188: (*s_etat_processus).erreur_systeme = d_es_processus;
189: return;
190: }
191:
192: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
193: sigpending(&set);
194: return;
195: }
196:
197: void
198: retrait_thread(struct_processus *s_etat_processus)
199: {
200: sigset_t oldset;
201: sigset_t set;
202:
203: volatile struct_liste_chainee_volatile *l_element_precedent;
204: volatile struct_liste_chainee_volatile *l_element_courant;
205:
206: sigfillset(&set);
207: pthread_sigmask(SIG_BLOCK, &set, &oldset);
208:
209: while(sem_wait(&semaphore_liste_threads) == -1)
210: {
211: if (errno != EINTR)
212: {
213: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
214: sigpending(&set);
215:
216: (*s_etat_processus).erreur_systeme = d_es_processus;
217: return;
218: }
219: }
220:
221: l_element_precedent = NULL;
222: l_element_courant = liste_threads;
223:
224: while(l_element_courant != NULL)
225: {
226: if (((*((struct_thread *) (*l_element_courant).donnee)).pid
227: == getpid()) && (pthread_equal((*((struct_thread *)
228: (*l_element_courant).donnee)).tid, pthread_self()) != 0))
229: {
230: break;
231: }
232:
233: l_element_precedent = l_element_courant;
234: l_element_courant = (*l_element_courant).suivant;
235: }
236:
237: if (l_element_courant == NULL)
238: {
239: sem_post(&semaphore_liste_threads);
240: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
241: sigpending(&set);
242:
243: (*s_etat_processus).erreur_systeme = d_es_processus;
244: return;
245: }
246:
247: if (l_element_precedent == NULL)
248: {
249: liste_threads = (*l_element_courant).suivant;
250: }
251: else
252: {
253: (*l_element_precedent).suivant = (*l_element_courant).suivant;
254: }
255:
256: free((void *) (*l_element_courant).donnee);
257: free((struct_liste_chainee_volatile *) l_element_courant);
258:
259: if (pthread_setspecific(semaphore_fork_processus_courant, NULL) != 0)
260: {
261: (*s_etat_processus).erreur_systeme = d_es_processus;
262:
263: sem_post(&semaphore_liste_threads);
264: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
265: sigpending(&set);
266: return;
267: }
268:
269: if (sem_post(&semaphore_liste_threads) != 0)
270: {
271: (*s_etat_processus).erreur_systeme = d_es_processus;
272:
273: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
274: sigpending(&set);
275: return;
276: }
277:
278: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
279: sigpending(&set);
280: return;
281: }
282:
283: void
284: retrait_thread_surveillance(struct_processus *s_etat_processus,
285: struct_descripteur_thread *s_argument_thread)
286: {
287: sigset_t set;
288: sigset_t oldset;
289:
290: volatile struct_liste_chainee_volatile *l_element_precedent;
291: volatile struct_liste_chainee_volatile *l_element_courant;
292:
293: sigfillset(&set);
294: pthread_sigmask(SIG_BLOCK, &set, &oldset);
295:
296: while(sem_wait(&semaphore_liste_threads) == -1)
297: {
298: if (errno != EINTR)
299: {
300: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
301: sigpending(&set);
302:
303: (*s_etat_processus).erreur_systeme = d_es_processus;
304: return;
305: }
306: }
307:
308: l_element_precedent = NULL;
309: l_element_courant = liste_threads_surveillance;
310:
311: while(l_element_courant != NULL)
312: {
313: if ((*l_element_courant).donnee == (void *) s_argument_thread)
314: {
315: break;
316: }
317:
318: l_element_precedent = l_element_courant;
319: l_element_courant = (*l_element_courant).suivant;
320: }
321:
322: if (l_element_courant == NULL)
323: {
324: sem_post(&semaphore_liste_threads);
325: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
326: sigpending(&set);
327:
328: (*s_etat_processus).erreur_systeme = d_es_processus;
329: return;
330: }
331:
332: if (l_element_precedent == NULL)
333: {
334: liste_threads_surveillance = (*l_element_courant).suivant;
335: }
336: else
337: {
338: (*l_element_precedent).suivant = (*l_element_courant).suivant;
339: }
340:
341: free((struct_liste_chainee_volatile *) l_element_courant);
342:
343: if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)
344: {
345: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
346: sigpending(&set);
347:
348: (*s_etat_processus).erreur_systeme = d_es_processus;
349: return;
350: }
351:
352: (*s_argument_thread).nombre_references--;
353:
354: BUG((*s_argument_thread).nombre_references < 0,
355: printf("(*s_argument_thread).nombre_references = %d\n",
356: (int) (*s_argument_thread).nombre_references));
357:
358: if ((*s_argument_thread).nombre_references == 0)
359: {
360: if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
361: {
362: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
363: sigpending(&set);
364:
365: (*s_etat_processus).erreur_systeme = d_es_processus;
366: return;
367: }
368:
369: pthread_mutex_destroy(&((*s_argument_thread).mutex));
370: free(s_argument_thread);
371: }
372: else
373: {
374: if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
375: {
376: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
377: sigpending(&set);
378:
379: (*s_etat_processus).erreur_systeme = d_es_processus;
380: return;
381: }
382: }
383:
384: if (sem_post(&semaphore_liste_threads) != 0)
385: {
386: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
387: sigpending(&set);
388:
389: (*s_etat_processus).erreur_systeme = d_es_processus;
390: return;
391: }
392:
393: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
394: sigpending(&set);
395: return;
396: }
397:
398: void
399: verrouillage_threads_concurrents(struct_processus *s_etat_processus)
400: {
401: volatile struct_liste_chainee_volatile *l_element_courant;
402:
403: while(sem_wait(&semaphore_liste_threads) == -1)
404: {
405: if (errno != EINTR)
406: {
407: (*s_etat_processus).erreur_systeme = d_es_processus;
408: return;
409: }
410: }
411:
412: l_element_courant = liste_threads;
413:
414: while(l_element_courant != NULL)
415: {
416: if (((*((struct_thread *) (*l_element_courant).donnee)).pid
417: == getpid()) && (pthread_equal((*((struct_thread *)
418: (*l_element_courant).donnee)).tid, pthread_self()) == 0))
419: {
420: while(sem_wait(&((*(*((struct_thread *) (*l_element_courant)
421: .donnee)).s_etat_processus).semaphore_fork)) == -1)
422: {
423: if (errno != EINTR)
424: {
425: (*s_etat_processus).erreur_systeme = d_es_processus;
426: return;
427: }
428: }
429: }
430:
431: l_element_courant = (*l_element_courant).suivant;
432: }
433:
434: return;
435: }
436:
437: void
438: deverrouillage_threads_concurrents(struct_processus *s_etat_processus)
439: {
440: volatile struct_liste_chainee_volatile *l_element_courant;
441:
442: l_element_courant = liste_threads;
443:
444: while(l_element_courant != NULL)
445: {
446: if (((*((struct_thread *) (*l_element_courant).donnee)).pid
447: == getpid()) && (pthread_equal((*((struct_thread *)
448: (*l_element_courant).donnee)).tid, pthread_self()) == 0))
449: {
450: if (sem_post(&((*(*((struct_thread *)
451: (*l_element_courant).donnee)).s_etat_processus)
452: .semaphore_fork)) != 0)
453: {
454: if (sem_post(&semaphore_liste_threads) != 0)
455: {
456: (*s_etat_processus).erreur_systeme = d_es_processus;
457: return;
458: }
459:
460: (*s_etat_processus).erreur_systeme = d_es_processus;
461: return;
462: }
463: }
464:
465: l_element_courant = (*l_element_courant).suivant;
466: }
467:
468: if (sem_post(&semaphore_liste_threads) != 0)
469: {
470: (*s_etat_processus).erreur_systeme = d_es_processus;
471: return;
472: }
473:
474: return;
475: }
476:
477: void
478: liberation_threads(struct_processus *s_etat_processus)
479: {
480: logical1 suppression_variables_partagees;
481:
482: sigset_t oldset;
483: sigset_t set;
484:
485: struct_descripteur_thread *s_argument_thread;
486:
487: struct_processus *candidat;
488:
489: unsigned long i;
490:
491: void *element_candidat;
492: void *element_courant;
493: void *element_suivant;
494:
495: volatile struct_liste_chainee_volatile *l_element_courant;
496: volatile struct_liste_chainee_volatile *l_element_suivant;
497:
498: sigfillset(&set);
499: pthread_sigmask(SIG_BLOCK, &set, &oldset);
500:
501: while(sem_wait(&semaphore_liste_threads) == -1)
502: {
503: if (errno != EINTR)
504: {
505: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
506: (*s_etat_processus).erreur_systeme = d_es_processus;
507: return;
508: }
509: }
510:
511: l_element_courant = liste_threads;
512: suppression_variables_partagees = d_faux;
513:
514: while(l_element_courant != NULL)
515: {
516: if ((*((struct_thread *) (*l_element_courant).donnee)).s_etat_processus
517: != s_etat_processus)
518: {
519: candidat = s_etat_processus;
520: s_etat_processus = (*((struct_thread *)
521: (*l_element_courant).donnee)).s_etat_processus;
522: free((*s_etat_processus).localisation);
523:
524: // (*s_etat_processus).instruction_courante peut pointer sur
525: // n'importe quoi (une instruction courante ou un champ d'une
526: // structure objet). On ne le libère pas quitte à avoir une
527: // petite fuite mémoire dans le processus fils.
528:
529: if ((*s_etat_processus).instruction_courante != NULL)
530: {
531: //free((*s_etat_processus).instruction_courante);
532: }
533:
534: close((*s_etat_processus).pipe_acquittement);
535: close((*s_etat_processus).pipe_donnees);
536: close((*s_etat_processus).pipe_injections);
537: close((*s_etat_processus).pipe_nombre_injections);
538: close((*s_etat_processus).pipe_interruptions);
539: close((*s_etat_processus).pipe_nombre_objets_attente);
540: close((*s_etat_processus).pipe_nombre_interruptions_attente);
541:
542: if ((*s_etat_processus).nom_fichier_impression != NULL)
543: {
544: free((*s_etat_processus).nom_fichier_impression);
545: }
546:
547: while((*s_etat_processus).fichiers_graphiques != NULL)
548: {
549: free((*(*s_etat_processus).fichiers_graphiques).nom);
550:
551: if ((*(*s_etat_processus).fichiers_graphiques).legende != NULL)
552: {
553: free((*(*s_etat_processus).fichiers_graphiques).legende);
554: }
555:
556: element_courant = (*s_etat_processus).fichiers_graphiques;
557: (*s_etat_processus).fichiers_graphiques =
558: (*(*s_etat_processus).fichiers_graphiques).suivant;
559:
560: free(element_courant);
561: }
562:
563: if ((*s_etat_processus).entree_standard != NULL)
564: {
565: pclose((*s_etat_processus).entree_standard);
566: }
567:
568: if ((*s_etat_processus).generateur_aleatoire != NULL)
569: {
570: liberation_generateur_aleatoire(s_etat_processus);
571: }
572:
573: if ((*s_etat_processus).instruction_derniere_erreur != NULL)
574: {
575: free((*s_etat_processus).instruction_derniere_erreur);
576: (*s_etat_processus).instruction_derniere_erreur = NULL;
577: }
578:
579: element_courant = (void *) (*s_etat_processus)
580: .l_base_pile_processus;
581: while(element_courant != NULL)
582: {
583: pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
584: element_courant)).donnee).mutex));
585: pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
586: element_courant)).donnee).mutex));
587: liberation(s_etat_processus,
588: (*((struct_liste_chainee *) element_courant)).donnee);
589: element_suivant = (*((struct_liste_chainee *) element_courant))
590: .suivant;
591: free((struct_liste_chainee *) element_courant);
592: element_courant = element_suivant;
593: }
594:
595: pthread_mutex_trylock(&((*(*s_etat_processus).indep).mutex));
596: pthread_mutex_unlock(&((*(*s_etat_processus).indep).mutex));
597: liberation(s_etat_processus, (*s_etat_processus).indep);
598:
599: pthread_mutex_trylock(&((*(*s_etat_processus).depend).mutex));
600: pthread_mutex_unlock(&((*(*s_etat_processus).depend).mutex));
601: liberation(s_etat_processus, (*s_etat_processus).depend);
602:
603: free((*s_etat_processus).label_x);
604: free((*s_etat_processus).label_y);
605: free((*s_etat_processus).label_z);
606: free((*s_etat_processus).titre);
607: free((*s_etat_processus).legende);
608:
609: pthread_mutex_trylock(&((*(*s_etat_processus)
610: .parametres_courbes_de_niveau).mutex));
611: pthread_mutex_unlock(&((*(*s_etat_processus)
612: .parametres_courbes_de_niveau).mutex));
613: liberation(s_etat_processus, (*s_etat_processus)
614: .parametres_courbes_de_niveau);
615:
616: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
617: {
618: if ((*s_etat_processus).corps_interruptions[i] != NULL)
619: {
620: pthread_mutex_trylock(&((*(*s_etat_processus)
621: .corps_interruptions[i]).mutex));
622: pthread_mutex_unlock(&((*(*s_etat_processus)
623: .corps_interruptions[i]).mutex));
624:
625: liberation(s_etat_processus,
626: (*s_etat_processus).corps_interruptions[i]);
627: }
628:
629: element_courant = (*s_etat_processus)
630: .pile_origine_interruptions[i];
631:
632: while(element_courant != NULL)
633: {
634: element_suivant = (*((struct_liste_chainee *)
635: element_courant)).suivant;
636:
637: pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
638: element_courant)).donnee).mutex));
639: pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
640: element_courant)).donnee).mutex));
641:
642: liberation(s_etat_processus,
643: (*((struct_liste_chainee *) element_courant))
644: .donnee);
645: free(element_courant);
646:
647: element_courant = element_suivant;
648: }
649: }
650:
651: for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
652: {
653: pthread_mutex_trylock(&((*(*s_etat_processus)
654: .s_liste_variables[i].objet).mutex));
655: pthread_mutex_unlock(&((*(*s_etat_processus)
656: .s_liste_variables[i].objet).mutex));
657:
658: // Les variables de niveau 0 sont des définitions qui
659: // ne sont pas copiées entre threads.
660: if ((*s_etat_processus).s_liste_variables[i].niveau > 0)
661: {
662: liberation(s_etat_processus,
663: (*s_etat_processus).s_liste_variables[i].objet);
664: }
665:
666: free((*s_etat_processus).s_liste_variables[i].nom);
667: }
668:
669: free((*s_etat_processus).s_liste_variables);
670:
671: for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
672: {
673: pthread_mutex_trylock(&((*(*s_etat_processus)
674: .s_liste_variables_statiques[i].objet).mutex));
675: pthread_mutex_unlock(&((*(*s_etat_processus)
676: .s_liste_variables_statiques[i].objet).mutex));
677:
678: liberation(s_etat_processus, (*s_etat_processus)
679: .s_liste_variables_statiques[i].objet);
680: free((*s_etat_processus).s_liste_variables_statiques[i].nom);
681: }
682:
683: free((*s_etat_processus).s_liste_variables_statiques);
684:
685: // Ne peut être effacé qu'une seule fois
686: if (suppression_variables_partagees == d_faux)
687: {
688: suppression_variables_partagees = d_vrai;
689:
690: for(i = 0; i < (*(*s_etat_processus)
691: .s_liste_variables_partagees).nombre_variables; i++)
692: {
693: pthread_mutex_trylock(&((*(*(*s_etat_processus)
694: .s_liste_variables_partagees).table[i].objet)
695: .mutex));
696: pthread_mutex_unlock(&((*(*(*s_etat_processus)
697: .s_liste_variables_partagees).table[i].objet)
698: .mutex));
699:
700: liberation(s_etat_processus, (*(*s_etat_processus)
701: .s_liste_variables_partagees).table[i].objet);
702: free((*(*s_etat_processus).s_liste_variables_partagees)
703: .table[i].nom);
704: }
705:
706: if ((*(*s_etat_processus).s_liste_variables_partagees).table
707: != NULL)
708: {
709: free((struct_variable_partagee *) (*(*s_etat_processus)
710: .s_liste_variables_partagees).table);
711: }
712:
713: pthread_mutex_trylock(&((*(*s_etat_processus)
714: .s_liste_variables_partagees).mutex));
715: pthread_mutex_unlock(&((*(*s_etat_processus)
716: .s_liste_variables_partagees).mutex));
717: }
718:
719: element_courant = (*s_etat_processus).l_base_pile;
720: while(element_courant != NULL)
721: {
722: element_suivant = (*((struct_liste_chainee *)
723: element_courant)).suivant;
724:
725: pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
726: element_courant)).donnee).mutex));
727: pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
728: element_courant)).donnee).mutex));
729:
730: liberation(s_etat_processus,
731: (*((struct_liste_chainee *)
732: element_courant)).donnee);
733: free((struct_liste_chainee *) element_courant);
734:
735: element_courant = element_suivant;
736: }
737:
738: element_courant = (*s_etat_processus).l_base_pile_contextes;
739: while(element_courant != NULL)
740: {
741: element_suivant = (*((struct_liste_chainee *)
742: element_courant)).suivant;
743:
744: pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
745: element_courant)).donnee).mutex));
746: pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
747: element_courant)).donnee).mutex));
748: liberation(s_etat_processus, (*((struct_liste_chainee *)
749: element_courant)).donnee);
750: free((struct_liste_chainee *) element_courant);
751:
752: element_courant = element_suivant;
753: }
754:
755: element_courant = (*s_etat_processus).l_base_pile_taille_contextes;
756: while(element_courant != NULL)
757: {
758: element_suivant = (*((struct_liste_chainee *)
759: element_courant)).suivant;
760:
761: pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
762: element_courant)).donnee).mutex));
763: pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
764: element_courant)).donnee).mutex));
765: liberation(s_etat_processus,
766: (*((struct_liste_chainee *)
767: element_courant)).donnee);
768: free((struct_liste_chainee *) element_courant);
769:
770: element_courant = element_suivant;
771: }
772:
773: for(i = 0; i < (*s_etat_processus).nombre_instructions_externes;
774: i++)
775: {
776: free((*s_etat_processus).s_instructions_externes[i].nom);
777: free((*s_etat_processus).s_instructions_externes[i]
778: .nom_bibliotheque);
779: }
780:
781: if ((*s_etat_processus).nombre_instructions_externes != 0)
782: {
783: free((*s_etat_processus).s_instructions_externes);
784: }
785:
786: element_courant = (*s_etat_processus).s_bibliotheques;
787: while(element_courant != NULL)
788: {
789: element_suivant = (*((struct_liste_chainee *)
790: element_courant)).suivant;
791:
792: element_candidat = (*candidat).s_bibliotheques;
793: while(element_candidat != NULL)
794: {
795: if (((*((struct_bibliotheque *) (*((struct_liste_chainee *)
796: element_courant)).donnee))
797: .descripteur == (*((struct_bibliotheque *)
798: (*((struct_liste_chainee *) element_candidat))
799: .donnee)).descripteur) &&
800: ((*((struct_bibliotheque *)
801: (*((struct_liste_chainee *) element_courant))
802: .donnee)).pid == (*((struct_bibliotheque *)
803: (*((struct_liste_chainee *) element_candidat))
804: .donnee)).pid) && (pthread_equal(
805: (*((struct_bibliotheque *)
806: (*((struct_liste_chainee *) element_courant))
807: .donnee)).tid, (*((struct_bibliotheque *)
808: (*((struct_liste_chainee *) element_candidat))
809: .donnee)).tid) != 0))
810: {
811: break;
812: }
813:
814: element_candidat = (*((struct_liste_chainee *)
815: element_candidat)).suivant;
816: }
817:
818: if (element_candidat == NULL)
819: {
820: dlclose((*((struct_bibliotheque *)
821: (*((struct_liste_chainee *) element_courant))
822: .donnee)).descripteur);
823: }
824:
825: free((*((struct_bibliotheque *)
826: (*((struct_liste_chainee *)
827: element_courant)).donnee)).nom);
828: free((*((struct_liste_chainee *) element_courant)).donnee);
829: free(element_courant);
830:
831: element_courant = element_suivant;
832: }
833:
834: element_courant = (*s_etat_processus).l_base_pile_last;
835: while(element_courant != NULL)
836: {
837: element_suivant = (*((struct_liste_chainee *)
838: element_courant)).suivant;
839:
840: pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
841: element_courant)).donnee).mutex));
842: pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
843: element_courant)).donnee).mutex));
844: liberation(s_etat_processus,
845: (*((struct_liste_chainee *) element_courant)).donnee);
846: free(element_courant);
847:
848: element_courant = element_suivant;
849: }
850:
851: element_courant = (*s_etat_processus).l_base_pile_systeme;
852: while(element_courant != NULL)
853: {
854: element_suivant = (*((struct_liste_pile_systeme *)
855: element_courant)).suivant;
856:
857: if ((*((struct_liste_pile_systeme *)
858: element_courant)).indice_boucle != NULL)
859: {
860: pthread_mutex_trylock(&((*(*((struct_liste_pile_systeme *)
861: element_courant)).indice_boucle).mutex));
862: pthread_mutex_unlock(&((*(*((struct_liste_pile_systeme *)
863: element_courant)).indice_boucle).mutex));
864: }
865:
866: liberation(s_etat_processus,
867: (*((struct_liste_pile_systeme *)
868: element_courant)).indice_boucle);
869:
870: if ((*((struct_liste_pile_systeme *)
871: element_courant)).limite_indice_boucle != NULL)
872: {
873: pthread_mutex_trylock(&((*(*((struct_liste_pile_systeme *)
874: element_courant)).limite_indice_boucle).mutex));
875: pthread_mutex_unlock(&((*(*((struct_liste_pile_systeme *)
876: element_courant)).limite_indice_boucle).mutex));
877: }
878:
879: liberation(s_etat_processus,
880: (*((struct_liste_pile_systeme *)
881: element_courant)).limite_indice_boucle);
882:
883: if ((*((struct_liste_pile_systeme *)
884: element_courant)).objet_de_test != NULL)
885: {
886: pthread_mutex_trylock(&((*(*((struct_liste_pile_systeme *)
887: element_courant)).objet_de_test).mutex));
888: pthread_mutex_unlock(&((*(*((struct_liste_pile_systeme *)
889: element_courant)).objet_de_test).mutex));
890: }
891:
892: liberation(s_etat_processus,
893: (*((struct_liste_pile_systeme *)
894: element_courant)).objet_de_test);
895:
896: if ((*((struct_liste_pile_systeme *)
897: element_courant)).nom_variable != NULL)
898: {
899: free((*((struct_liste_pile_systeme *)
900: element_courant)).nom_variable);
901: }
902:
903: free(element_courant);
904:
905: element_courant = element_suivant;
906: }
907:
908: element_courant = (*s_etat_processus).s_fichiers;
909: while(element_courant != NULL)
910: {
911: element_suivant = (*((struct_liste_chainee *)
912: element_courant)).suivant;
913:
914: element_candidat = (*candidat).s_fichiers;
915: while(element_candidat != NULL)
916: {
917: if (((*((struct_descripteur_fichier *)
918: (*((struct_liste_chainee *) element_courant))
919: .donnee)).descripteur ==
920: (*((struct_descripteur_fichier *)
921: (*((struct_liste_chainee *) element_candidat))
922: .donnee)).descripteur) &&
923: ((*((struct_descripteur_fichier *)
924: (*((struct_liste_chainee *) element_courant))
925: .donnee)).pid ==
926: (*((struct_descripteur_fichier *)
927: (*((struct_liste_chainee *) element_candidat))
928: .donnee)).pid) && (pthread_equal(
929: (*((struct_descripteur_fichier *)
930: (*((struct_liste_chainee *) element_courant))
931: .donnee)).tid, (*((struct_descripteur_fichier *)
932: (*((struct_liste_chainee *) element_candidat))
933: .donnee)).tid) != 0))
934: {
935: break;
936: }
937:
938: element_candidat = (*((struct_liste_chainee *)
939: element_candidat)).suivant;
940: }
941:
942: if (element_candidat == NULL)
943: {
944: fclose((*((struct_descripteur_fichier *)
945: (*((struct_liste_chainee *) element_courant))
946: .donnee)).descripteur);
947: }
948:
949: free((*((struct_descripteur_fichier *)
950: (*((struct_liste_chainee *)
951: element_courant)).donnee)).nom);
952: free((struct_descripteur_fichier *)
953: (*((struct_liste_chainee *)
954: element_courant)).donnee);
955: free(element_courant);
956:
957: element_courant = element_suivant;
958: }
959:
960: element_courant = (*s_etat_processus).s_sockets;
961: while(element_courant != NULL)
962: {
963: element_suivant = (*((struct_liste_chainee *)
964: element_courant)).suivant;
965:
966: element_candidat = (*candidat).s_sockets;
967: while(element_candidat != NULL)
968: {
969: if (((*((struct_socket *)
970: (*((struct_liste_chainee *) element_courant))
971: .donnee)).socket == (*((struct_socket *)
972: (*((struct_liste_chainee *) element_candidat))
973: .donnee)).socket) &&
974: ((*((struct_socket *)
975: (*((struct_liste_chainee *) element_courant))
976: .donnee)).pid == (*((struct_socket *)
977: (*((struct_liste_chainee *) element_candidat))
978: .donnee)).pid) && (pthread_equal(
979: (*((struct_socket *)
980: (*((struct_liste_chainee *) element_courant))
981: .donnee)).tid, (*((struct_socket *)
982: (*((struct_liste_chainee *) element_candidat))
983: .donnee)).tid) != 0))
984: {
985: break;
986: }
987:
988: element_candidat = (*((struct_liste_chainee *)
989: element_candidat)).suivant;
990: }
991:
992: if (element_candidat == NULL)
993: {
994: if ((*((struct_socket *) (*((struct_liste_chainee *)
995: element_courant)).donnee)).socket_connectee
996: == d_vrai)
997: {
998: shutdown((*((struct_socket *)
999: (*((struct_liste_chainee *) element_courant))
1000: .donnee)).socket, SHUT_RDWR);
1001: }
1002:
1003: close((*((struct_socket *)
1004: (*((struct_liste_chainee *) element_courant))
1005: .donnee)).socket);
1006: }
1007:
1008: pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
1009: element_courant)).donnee).mutex));
1010: pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
1011: element_courant)).donnee).mutex));
1012:
1013: liberation(s_etat_processus,
1014: (*((struct_liste_chainee *)
1015: element_courant)).donnee);
1016: free(element_courant);
1017:
1018: element_courant = element_suivant;
1019: }
1020:
1021: element_courant = (*s_etat_processus).s_connecteurs_sql;
1022: while(element_courant != NULL)
1023: {
1024: element_suivant = (*((struct_liste_chainee *)
1025: element_courant)).suivant;
1026:
1027: element_candidat = (*candidat).s_connecteurs_sql;
1028: while(element_candidat != NULL)
1029: {
1030: if (((
1031: #ifdef MYSQL_SUPPORT
1032: ((*((struct_connecteur_sql *)
1033: (*((struct_liste_chainee *) element_courant))
1034: .donnee)).descripteur.mysql ==
1035: (*((struct_connecteur_sql *)
1036: (*((struct_liste_chainee *) element_candidat))
1037: .donnee)).descripteur.mysql)
1038: &&
1039: (strcmp((*((struct_connecteur_sql *)
1040: (*((struct_liste_chainee *) element_courant))
1041: .donnee)).type, "MYSQL") == 0)
1042: &&
1043: (strcmp((*((struct_connecteur_sql *)
1044: (*((struct_liste_chainee *) element_candidat))
1045: .donnee)).type, "MYSQL") == 0)
1046: #else
1047: 0
1048: #endif
1049: ) || (
1050: #ifdef POSTGRESQL_SUPPORT
1051: ((*((struct_connecteur_sql *)
1052: (*((struct_liste_chainee *) element_courant))
1053: .donnee)).descripteur.postgresql ==
1054: (*((struct_connecteur_sql *)
1055: (*((struct_liste_chainee *) element_candidat))
1056: .donnee)).descripteur.postgresql)
1057: &&
1058: (strcmp((*((struct_connecteur_sql *)
1059: (*((struct_liste_chainee *) element_courant))
1060: .donnee)).type, "POSTGRESQL") == 0)
1061: &&
1062: (strcmp((*((struct_connecteur_sql *)
1063: (*((struct_liste_chainee *) element_candidat))
1064: .donnee)).type, "POSTGRESQL") == 0)
1065: #else
1066: 0
1067: #endif
1068: )) &&
1069: ((*((struct_connecteur_sql *)
1070: (*((struct_liste_chainee *) element_courant))
1071: .donnee)).pid == (*((struct_connecteur_sql *)
1072: (*((struct_liste_chainee *) element_candidat))
1073: .donnee)).pid) && (pthread_equal(
1074: (*((struct_connecteur_sql *)
1075: (*((struct_liste_chainee *) element_courant))
1076: .donnee)).tid, (*((struct_connecteur_sql *)
1077: (*((struct_liste_chainee *) element_candidat))
1078: .donnee)).tid) != 0))
1079: {
1080: break;
1081: }
1082:
1083: element_candidat = (*((struct_liste_chainee *)
1084: element_candidat)).suivant;
1085: }
1086:
1087: if (element_candidat == NULL)
1088: {
1089: sqlclose((*((struct_liste_chainee *) element_courant))
1090: .donnee);
1091: }
1092:
1093: pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
1094: element_courant)).donnee).mutex));
1095: pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
1096: element_courant)).donnee).mutex));
1097:
1098: liberation(s_etat_processus, (*((struct_liste_chainee *)
1099: element_courant)).donnee);
1100: free(element_courant);
1101:
1102: element_courant = element_suivant;
1103: }
1104:
1105: element_courant = (*s_etat_processus).s_marques;
1106: while(element_courant != NULL)
1107: {
1108: free((*((struct_marque *) element_courant)).label);
1109: free((*((struct_marque *) element_courant)).position);
1110: element_suivant = (*((struct_marque *) element_courant))
1111: .suivant;
1112: free(element_courant);
1113: element_courant = element_suivant;
1114: }
1115:
1116: liberation_allocateur(s_etat_processus);
1117:
1118: sem_post(&((*s_etat_processus).semaphore_fork));
1119: sem_destroy(&((*s_etat_processus).semaphore_fork));
1120:
1121: free(s_etat_processus);
1122:
1123: s_etat_processus = candidat;
1124: }
1125:
1126: l_element_suivant = (*l_element_courant).suivant;
1127:
1128: free((struct_thread *) (*l_element_courant).donnee);
1129: free((struct_liste_chainee *) l_element_courant);
1130:
1131: l_element_courant = l_element_suivant;
1132: }
1133:
1134: liste_threads = NULL;
1135:
1136: l_element_courant = liste_threads_surveillance;
1137:
1138: while(l_element_courant != NULL)
1139: {
1140: s_argument_thread = (struct_descripteur_thread *)
1141: (*l_element_courant).donnee;
1142:
1143: close((*s_argument_thread).pipe_objets[0]);
1144: close((*s_argument_thread).pipe_acquittement[1]);
1145: close((*s_argument_thread).pipe_injections[1]);
1146: close((*s_argument_thread).pipe_nombre_injections[1]);
1147: close((*s_argument_thread).pipe_nombre_objets_attente[0]);
1148: close((*s_argument_thread).pipe_interruptions[0]);
1149: close((*s_argument_thread).pipe_nombre_interruptions_attente[0]);
1150:
1151: if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)
1152: {
1153: (*s_etat_processus).erreur_systeme = d_es_processus;
1154: return;
1155: }
1156:
1157: (*s_argument_thread).nombre_references--;
1158:
1159: BUG((*s_argument_thread).nombre_references < 0,
1160: printf("(*s_argument_thread).nombre_references = %d\n",
1161: (int) (*s_argument_thread).nombre_references));
1162:
1163: if ((*s_argument_thread).nombre_references == 0)
1164: {
1165: if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
1166: {
1167: (*s_etat_processus).erreur_systeme = d_es_processus;
1168: return;
1169: }
1170:
1171: pthread_mutex_destroy(&((*s_argument_thread).mutex));
1172: free(s_argument_thread);
1173: }
1174: else
1175: {
1176: if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
1177: {
1178: (*s_etat_processus).erreur_systeme = d_es_processus;
1179: return;
1180: }
1181: }
1182:
1183: l_element_suivant = (*l_element_courant).suivant;
1184: free((struct_liste_chainee *) l_element_courant);
1185: l_element_courant = l_element_suivant;
1186: }
1187:
1188: liste_threads_surveillance = NULL;
1189:
1190: if (sem_post(&semaphore_liste_threads) != 0)
1191: {
1192: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1193: (*s_etat_processus).erreur_systeme = d_es_processus;
1194: return;
1195: }
1196:
1197: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1198: sigpending(&set);
1199: return;
1200: }
1201:
1202: static struct_processus *
1203: recherche_thread(pid_t pid, pthread_t tid)
1204: {
1205: volatile struct_liste_chainee_volatile *l_element_courant;
1206:
1207: struct_processus *s_etat_processus;
1208:
1209: l_element_courant = liste_threads;
1210:
1211: while(l_element_courant != NULL)
1212: {
1213: if ((pthread_equal((*((struct_thread *) (*l_element_courant).donnee))
1214: .tid, tid) != 0) && ((*((struct_thread *)
1215: (*l_element_courant).donnee)).pid == pid))
1216: {
1217: break;
1218: }
1219:
1220: l_element_courant = (*l_element_courant).suivant;
1221: }
1222:
1223: if (l_element_courant == NULL)
1224: {
1225: /*
1226: * Le processus n'existe plus. On ne distribue aucun signal.
1227: */
1228:
1229: return(NULL);
1230: }
1231:
1232: s_etat_processus = (*((struct_thread *)
1233: (*l_element_courant).donnee)).s_etat_processus;
1234:
1235: return(s_etat_processus);
1236: }
1237:
1238: static logical1
1239: recherche_thread_principal(pid_t pid, pthread_t *thread)
1240: {
1241: volatile struct_liste_chainee_volatile *l_element_courant;
1242:
1243: l_element_courant = liste_threads;
1244:
1245: while(l_element_courant != NULL)
1246: {
1247: if (((*((struct_thread *) (*l_element_courant).donnee)).thread_principal
1248: == d_vrai) && ((*((struct_thread *)
1249: (*l_element_courant).donnee)).pid == pid))
1250: {
1251: break;
1252: }
1253:
1254: l_element_courant = (*l_element_courant).suivant;
1255: }
1256:
1257: if (l_element_courant == NULL)
1258: {
1259: /*
1260: * Le processus n'existe plus. On ne distribue aucun signal.
1261: */
1262:
1263: return(d_faux);
1264: }
1265:
1266: (*thread) = (*((struct_thread *) (*l_element_courant).donnee)).tid;
1267:
1268: return(d_vrai);
1269: }
1270:
1271:
1272: /*
1273: ================================================================================
1274: Procédures de gestion des signaux d'interruption
1275: ================================================================================
1276: Entrée : variable globale
1277: --------------------------------------------------------------------------------
1278: Sortie : variable globale modifiée
1279: --------------------------------------------------------------------------------
1280: Effets de bord : néant
1281: ================================================================================
1282: */
1283:
1284: // Les routines suivantes sont uniquement appelées depuis les gestionnaires
1285: // des signaux asynchrones. Elles de doivent pas bloquer dans le cas où
1286: // les sémaphores sont déjà bloqués par un gestionnaire de signal.
1287:
1288: static inline void
1289: verrouillage_gestionnaire_signaux()
1290: {
1291: int semaphore;
1292:
1293: sigset_t oldset;
1294: sigset_t set;
1295:
1296: sem_t *sem;
1297:
1298: if ((sem = pthread_getspecific(semaphore_fork_processus_courant))
1299: != NULL)
1300: {
1301: if (sem_post(sem) != 0)
1302: {
1303: BUG(1, uprintf("Lock error !\n"));
1304: return;
1305: }
1306: }
1307:
1308: // Il faut respecteur l'atomicité des deux opérations suivantes !
1309:
1310: sigfillset(&set);
1311: pthread_sigmask(SIG_BLOCK, &set, &oldset);
1312:
1313: while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1)
1314: {
1315: if (errno != EINTR)
1316: {
1317: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1318: BUG(1, uprintf("Unlock error !\n"));
1319: return;
1320: }
1321: }
1322:
1323: if (sem_post(&semaphore_gestionnaires_signaux) == -1)
1324: {
1325: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1326: BUG(1, uprintf("Lock error !\n"));
1327: return;
1328: }
1329:
1330: if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)
1331: {
1332: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1333: BUG(1, uprintf("Lock error !\n"));
1334: return;
1335: }
1336:
1337: if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0)
1338: {
1339: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1340: BUG(1, uprintf("Unlock error !\n"));
1341: return;
1342: }
1343:
1344: if (semaphore == 1)
1345: {
1346: // Le semaphore ne peut être pris par le thread qui a appelé
1347: // le gestionnaire de signal car le signal est bloqué par ce thread
1348: // dans les zones critiques. Ce sémaphore ne peut donc être bloqué que
1349: // par un thread concurrent. On essaye donc de le bloquer jusqu'à
1350: // ce que ce soit possible.
1351:
1352: while(sem_trywait(&semaphore_liste_threads) == -1)
1353: {
1354: if ((errno != EINTR) && (errno != EAGAIN))
1355: {
1356: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1357:
1358: while(sem_wait(sem) == -1)
1359: {
1360: if (errno != EINTR)
1361: {
1362: BUG(1, uprintf("Lock error !\n"));
1363: return;
1364: }
1365: }
1366:
1367: BUG(1, uprintf("Lock error !\n"));
1368: return;
1369: }
1370:
1371: sched_yield();
1372: }
1373: }
1374:
1375: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1376: sigpending(&set);
1377:
1378: return;
1379: }
1380:
1381: static inline void
1382: deverrouillage_gestionnaire_signaux()
1383: {
1384: int semaphore;
1385:
1386: sem_t *sem;
1387:
1388: sigset_t oldset;
1389: sigset_t set;
1390:
1391: // Il faut respecteur l'atomicité des deux opérations suivantes !
1392:
1393: sigfillset(&set);
1394: pthread_sigmask(SIG_BLOCK, &set, &oldset);
1395:
1396: while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1)
1397: {
1398: if (errno != EINTR)
1399: {
1400: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1401: BUG(1, uprintf("Unlock error !\n"));
1402: return;
1403: }
1404: }
1405:
1406: if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)
1407: {
1408: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1409: BUG(1, uprintf("Unlock error !\n"));
1410: return;
1411: }
1412:
1413: while(sem_wait(&semaphore_gestionnaires_signaux) == -1)
1414: {
1415: if (errno != EINTR)
1416: {
1417: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1418: BUG(1, uprintf("Unlock error !\n"));
1419: return;
1420: }
1421: }
1422:
1423: if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0)
1424: {
1425: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1426: BUG(1, uprintf("Unlock error !\n"));
1427: return;
1428: }
1429:
1430: if ((sem = pthread_getspecific(semaphore_fork_processus_courant))
1431: != NULL)
1432: {
1433: while(sem_wait(sem) == -1)
1434: {
1435: if (errno != EINTR)
1436: {
1437: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1438: BUG(1, uprintf("Unlock error !\n"));
1439: return;
1440: }
1441: }
1442: }
1443:
1444: if (semaphore == 1)
1445: {
1446: if (sem_post(&semaphore_liste_threads) != 0)
1447: {
1448: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1449:
1450: BUG(1, uprintf("Unlock error !\n"));
1451: return;
1452: }
1453: }
1454:
1455: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
1456: sigpending(&set);
1457:
1458: return;
1459: }
1460:
1461: void
1462: interruption1(int signal, siginfo_t *siginfo, void *context)
1463: {
1464: pthread_t thread;
1465:
1466: struct_processus *s_etat_processus;
1467:
1468: volatile sig_atomic_t exclusion = 0;
1469:
1470: verrouillage_gestionnaire_signaux();
1471:
1472: switch(signal)
1473: {
1474: case SIGALRM :
1475: {
1476: if ((*siginfo).si_pid == getpid())
1477: {
1478: if ((s_etat_processus = recherche_thread(getpid(),
1479: pthread_self())) == NULL)
1480: {
1481: deverrouillage_gestionnaire_signaux();
1482: return;
1483: }
1484:
1485: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
1486: {
1487: printf("[%d] SIGALRM (thread %llu)\n", (int) getpid(),
1488: (unsigned long long) pthread_self());
1489: fflush(stdout);
1490: }
1491:
1492: if ((*s_etat_processus).pid_processus_pere != getpid())
1493: {
1494: kill((*s_etat_processus).pid_processus_pere, signal);
1495: }
1496: else
1497: {
1498: (*s_etat_processus).var_volatile_alarme = -1;
1499: (*s_etat_processus).var_volatile_requete_arret = -1;
1500: }
1501: }
1502: else
1503: {
1504: if (recherche_thread_principal(getpid(), &thread) == d_vrai)
1505: {
1506: pthread_kill(thread, signal);
1507: }
1508: }
1509:
1510: break;
1511: }
1512:
1513: case SIGINT :
1514: {
1515: /*
1516: * Une vieille spécification POSIX permet au pointeur siginfo
1517: * d'être nul dans le cas d'un ^C envoyé depuis le clavier.
1518: * Solaris suit en particulier cette spécification.
1519: */
1520:
1521: if (siginfo == NULL)
1522: {
1523: kill(getpid(), signal);
1524: }
1525: else if ((*siginfo).si_pid == getpid())
1526: {
1527: if ((s_etat_processus = recherche_thread(getpid(),
1528: pthread_self())) == NULL)
1529: {
1530: deverrouillage_gestionnaire_signaux();
1531: return;
1532: }
1533:
1534: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
1535: {
1536: printf("[%d] SIGINT (thread %llu)\n", (int) getpid(),
1537: (unsigned long long) pthread_self());
1538: fflush(stdout);
1539: }
1540:
1541: if ((*s_etat_processus).pid_processus_pere != getpid())
1542: {
1543: kill((*s_etat_processus).pid_processus_pere, signal);
1544: }
1545: else
1546: {
1547: (*s_etat_processus).var_volatile_traitement_sigint = -1;
1548:
1549: while(exclusion == 1);
1550: exclusion = 1;
1551:
1552: if ((*s_etat_processus).var_volatile_requete_arret == -1)
1553: {
1554: deverrouillage_gestionnaire_signaux();
1555: exclusion = 0;
1556: return;
1557: }
1558:
1559: if (strncmp(getenv("LANG"), "fr", 2) == 0)
1560: {
1561: printf("+++Interruption\n");
1562: }
1563: else
1564: {
1565: printf("+++Interrupt\n");
1566: }
1567:
1568: fflush(stdout);
1569:
1570: (*s_etat_processus).var_volatile_requete_arret = -1;
1571: (*s_etat_processus).var_volatile_alarme = -1;
1572:
1573: exclusion = 0;
1574: }
1575: }
1576: else
1577: {
1578: if (recherche_thread_principal(getpid(), &thread) == d_vrai)
1579: {
1580: pthread_kill(thread, signal);
1581: }
1582: }
1583:
1584: break;
1585: }
1586:
1587: default :
1588: {
1589: BUG(1, uprintf("[%d] Unknown signal %d in this context\n",
1590: (int) getpid(), signal));
1591: break;
1592: }
1593: }
1594:
1595: deverrouillage_gestionnaire_signaux();
1596: return;
1597: }
1598:
1599: void
1600: interruption2(int signal, siginfo_t *siginfo, void *context)
1601: {
1602: pthread_t thread;
1603: struct_processus *s_etat_processus;
1604:
1605: verrouillage_gestionnaire_signaux();
1606:
1607: if (siginfo == NULL)
1608: {
1609: /*
1610: * Le signal SIGFSTP provient de la mort du processus de contrôle.
1611: * Sous certains systèmes (Linux...), la mort du terminal de contrôle
1612: * se traduit par l'envoi d'un SIGHUP au processus. Sur d'autres
1613: * (SunOS), le processus reçoit un SIGFSTP avec une structure siginfo
1614: * non initialisée (pointeur NULL) issue de TERMIO.
1615: */
1616:
1617: if (recherche_thread_principal(getpid(), &thread) == d_vrai)
1618: {
1619: pthread_kill(thread, SIGHUP);
1620: deverrouillage_gestionnaire_signaux();
1621: return;
1622: }
1623: }
1624: else if ((*siginfo).si_pid == getpid())
1625: {
1626: if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
1627: == NULL)
1628: {
1629: deverrouillage_gestionnaire_signaux();
1630: return;
1631: }
1632:
1633: /*
1634: * 0 => fonctionnement normal
1635: * -1 => requête
1636: * 1 => requête acceptée en attente de traitement
1637: */
1638:
1639: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
1640: {
1641: printf("[%d] SIGTSTP (thread %llu)\n", (int) getpid(),
1642: (unsigned long long) pthread_self());
1643: fflush(stdout);
1644: }
1645:
1646: if ((*s_etat_processus).var_volatile_processus_pere == 0)
1647: {
1648: kill((*s_etat_processus).pid_processus_pere, signal);
1649: }
1650: else
1651: {
1652: (*s_etat_processus).var_volatile_requete_arret2 = -1;
1653: }
1654: }
1655: else
1656: {
1657: // Envoi d'un signal au thread maître du groupe.
1658:
1659: if (recherche_thread_principal(getpid(), &thread) == d_vrai)
1660: {
1661: pthread_kill(thread, SIGTSTP);
1662: deverrouillage_gestionnaire_signaux();
1663: return;
1664: }
1665: }
1666:
1667: deverrouillage_gestionnaire_signaux();
1668: return;
1669: }
1670:
1671: void
1672: interruption3(int signal, siginfo_t *siginfo, void *context)
1673: {
1674: struct_processus *s_etat_processus;
1675:
1676: static int compteur = 0;
1677:
1678: verrouillage_gestionnaire_signaux();
1679:
1680: if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
1681: {
1682: deverrouillage_gestionnaire_signaux();
1683: return;
1684: }
1685:
1686: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
1687: {
1688: printf("[%d] SIGSEGV (thread %llu)\n", (int) getpid(),
1689: (unsigned long long) pthread_self());
1690: fflush(stdout);
1691: }
1692:
1693: if ((*s_etat_processus).var_volatile_recursivite == -1)
1694: {
1695: // Segfault dans un appel de fonction récursive
1696: deverrouillage_gestionnaire_signaux();
1697: longjmp(contexte, -1);
1698: }
1699: else
1700: {
1701: // Segfault dans une routine interne
1702: if (strncmp(getenv("LANG"), "fr", 2) == 0)
1703: {
1704: printf("+++Système : Violation d'accès (dépassement de pile)\n");
1705: }
1706: else
1707: {
1708: printf("+++System : Access violation (stack overflow)\n");
1709: }
1710:
1711: fflush(stdout);
1712:
1713: compteur++;
1714:
1715: if (compteur > 1)
1716: {
1717: deverrouillage_gestionnaire_signaux();
1718: exit(EXIT_FAILURE);
1719: }
1720: else
1721: {
1722: deverrouillage_gestionnaire_signaux();
1723: longjmp(contexte_initial, -1);
1724: }
1725: }
1726:
1727: deverrouillage_gestionnaire_signaux();
1728: return;
1729: }
1730:
1731: void
1732: interruption4(int signal, siginfo_t *siginfo, void *context)
1733: {
1734: struct_processus *s_etat_processus;
1735:
1736: verrouillage_gestionnaire_signaux();
1737:
1738: if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
1739: {
1740: deverrouillage_gestionnaire_signaux();
1741: return;
1742: }
1743:
1744: /*
1745: * Démarrage d'un processus fils ou gestion de SIGCONT (SUSPEND)
1746: */
1747:
1748: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
1749: {
1750: printf("[%d] SIGSTART/SIGCONT (thread %llu)\n", (int) getpid(),
1751: (unsigned long long) pthread_self());
1752: fflush(stdout);
1753: }
1754:
1755: deverrouillage_gestionnaire_signaux();
1756: return;
1757: }
1758:
1759: void
1760: interruption5(int signal, siginfo_t *siginfo, void *context)
1761: {
1762: pthread_t thread;
1763: struct_processus *s_etat_processus;
1764:
1765: verrouillage_gestionnaire_signaux();
1766:
1767: if ((*siginfo).si_pid == getpid())
1768: {
1769: if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
1770: == NULL)
1771: {
1772: deverrouillage_gestionnaire_signaux();
1773: return;
1774: }
1775:
1776: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
1777: {
1778: printf("[%d] SIGFSTOP (thread %llu)\n", (int) getpid(),
1779: (unsigned long long) pthread_self());
1780: fflush(stdout);
1781: }
1782:
1783: /*
1784: * var_globale_traitement_retarde_stop :
1785: * 0 -> traitement immédiat
1786: * 1 -> traitement retardé (aucun signal reçu)
1787: * -1 -> traitement retardé (un ou plusieurs signaux stop reçus)
1788: */
1789:
1790: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)
1791: {
1792: (*s_etat_processus).var_volatile_requete_arret = -1;
1793: }
1794: else
1795: {
1796: (*s_etat_processus).var_volatile_traitement_retarde_stop = -1;
1797: }
1798: }
1799: else
1800: {
1801: // Envoi d'un signal au thread maître du groupe.
1802:
1803: if (recherche_thread_principal(getpid(), &thread) == d_vrai)
1804: {
1805: pthread_kill(thread, SIGFSTOP);
1806: deverrouillage_gestionnaire_signaux();
1807: return;
1808: }
1809: }
1810:
1811: deverrouillage_gestionnaire_signaux();
1812: return;
1813: }
1814:
1815: void
1816: interruption6(int signal, siginfo_t *siginfo, void *context)
1817: {
1818: struct_processus *s_etat_processus;
1819:
1820: verrouillage_gestionnaire_signaux();
1821:
1822: if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
1823: {
1824: deverrouillage_gestionnaire_signaux();
1825: return;
1826: }
1827:
1828: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
1829: {
1830: printf("[%d] SIGINJECT/SIGQUIT (thread %llu)\n", (int) getpid(),
1831: (unsigned long long) pthread_self());
1832: fflush(stdout);
1833: }
1834:
1835: deverrouillage_gestionnaire_signaux();
1836: return;
1837: }
1838:
1839: void
1840: interruption7(int signal, siginfo_t *siginfo, void *context)
1841: {
1842: struct_processus *s_etat_processus;
1843:
1844: verrouillage_gestionnaire_signaux();
1845:
1846: if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
1847: {
1848: deverrouillage_gestionnaire_signaux();
1849: return;
1850: }
1851:
1852: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
1853: {
1854: printf("[%d] SIGPIPE (thread %llu)\n", (int) getpid(),
1855: (unsigned long long) pthread_self());
1856: fflush(stdout);
1857: }
1858:
1859: (*s_etat_processus).var_volatile_requete_arret = -1;
1860: deverrouillage_gestionnaire_signaux();
1861:
1862: BUG(1, printf("[%d] SIGPIPE\n", (int) getpid()));
1863: return;
1864: }
1865:
1866: void
1867: interruption8(int signal, siginfo_t *siginfo, void *context)
1868: {
1869: pthread_t thread;
1870: struct_processus *s_etat_processus;
1871:
1872: verrouillage_gestionnaire_signaux();
1873:
1874: if ((*siginfo).si_pid == getpid())
1875: {
1876: if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
1877: == NULL)
1878: {
1879: deverrouillage_gestionnaire_signaux();
1880: return;
1881: }
1882:
1883: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
1884: {
1885: printf("[%d] SIGURG (thread %llu)\n", (int) getpid(),
1886: (unsigned long long) pthread_self());
1887: fflush(stdout);
1888: }
1889:
1890: (*s_etat_processus).var_volatile_alarme = -1;
1891: (*s_etat_processus).var_volatile_requete_arret = -1;
1892: }
1893: else
1894: {
1895: // Envoi d'un signal au thread maître du groupe.
1896:
1897: if (recherche_thread_principal(getpid(), &thread) == d_vrai)
1898: {
1899: pthread_kill(thread, SIGURG);
1900: deverrouillage_gestionnaire_signaux();
1901: return;
1902: }
1903: }
1904:
1905: deverrouillage_gestionnaire_signaux();
1906: return;
1907: }
1908:
1909: void
1910: interruption9(int signal, siginfo_t *siginfo, void *context)
1911: {
1912: struct_processus *s_etat_processus;
1913:
1914: verrouillage_gestionnaire_signaux();
1915:
1916: if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
1917: {
1918: deverrouillage_gestionnaire_signaux();
1919: return;
1920: }
1921:
1922: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
1923: {
1924: printf("[%d] SIGABORT/SIGPROF (thread %llu)\n", (int) getpid(),
1925: (unsigned long long) pthread_self());
1926: fflush(stdout);
1927: }
1928:
1929: pthread_kill((*s_etat_processus).tid_processus_pere, SIGFSTOP);
1930: deverrouillage_gestionnaire_signaux();
1931: return;
1932: }
1933:
1934: void
1935: interruption10(int signal, siginfo_t *siginfo, void *context)
1936: {
1937: file *fichier;
1938:
1939: struct_processus *s_etat_processus;
1940:
1941: unsigned char nom[8 + 64 + 1];
1942:
1943: verrouillage_gestionnaire_signaux();
1944:
1945: if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
1946: {
1947: deverrouillage_gestionnaire_signaux();
1948: return;
1949: }
1950:
1951: snprintf(nom, 8 + 64 + 1, "rpl-out-%lu-%lu", (unsigned long) getpid(),
1952: (unsigned long) pthread_self());
1953:
1954: if ((fichier = fopen(nom, "w+")) != NULL)
1955: {
1956: fclose(fichier);
1957:
1958: freopen(nom, "w", stdout);
1959: freopen(nom, "w", stderr);
1960: }
1961:
1962: freopen("/dev/null", "r", stdin);
1963:
1964: if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
1965: {
1966: printf("[%d] SIGHUP (thread %llu)\n", (int) getpid(),
1967: (unsigned long long) pthread_self());
1968: fflush(stdout);
1969: }
1970:
1971: deverrouillage_gestionnaire_signaux();
1972: return;
1973: }
1974:
1975: void
1976: traitement_exceptions_gsl(const char *reason, const char *file,
1977: int line, int gsl_errno)
1978: {
1979: struct_processus *s_etat_processus;
1980:
1981: verrouillage_gestionnaire_signaux();
1982:
1983: if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
1984: {
1985: deverrouillage_gestionnaire_signaux();
1986: return;
1987: }
1988:
1989: (*s_etat_processus).var_volatile_exception_gsl = gsl_errno;
1990: deverrouillage_gestionnaire_signaux();
1991: return;
1992: }
1993:
1994: // 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