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