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