![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gestion_threads.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to gestion_threads.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.9 ! bertrand 3: RPL/2 (R) version 4.0.15
1.1 bertrand 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: Fonction de lancement d'un thread
29: ================================================================================
30: Entrées : pointeur sur une structure
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void *
39: lancement_thread(void *argument)
40: {
41: int status;
42:
43: pid_t ppid;
44:
45: pthread_t tid_final;
46:
47: sig_atomic_t registre_stop;
48:
49: sigset_t set;
50:
51: ssize_t longueur_ecriture;
52:
53: struct_descripteur_thread *s_argument_thread;
54:
55: struct_liste_chainee *l_element_courant;
56: struct_liste_chainee *l_element_suivant;
57:
58: struct_objet *s_objet_temporaire;
59:
60: struct_processus *s_etat_processus;
61:
62: struct sigaction action;
63: struct sigaction registre;
64:
65: struct timespec attente;
66:
67: unsigned char *message;
68:
69: unsigned int erreur;
70:
71: unsigned long i;
72:
73: attente.tv_sec = 0;
74: attente.tv_nsec = GRANULARITE_us * 1000;
75:
76: s_argument_thread = (struct_descripteur_thread *) argument;
77: (*s_argument_thread).tid = pthread_self();
78: (*s_argument_thread).thread_actif = d_vrai;
79: s_etat_processus = (*s_argument_thread).s_nouvel_etat_processus;
80:
1.8 bertrand 81: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 82: if (pthread_setspecific(semaphore_fork_processus_courant,
83: &((*s_etat_processus).semaphore_fork)) != 0)
1.8 bertrand 84: # else
85: if (pthread_setspecific(semaphore_fork_processus_courant,
86: (*s_etat_processus).semaphore_fork) != 0)
87: # endif
1.1 bertrand 88: {
89: (*s_etat_processus).erreur_systeme = d_es_processus;
90:
91: pthread_mutex_unlock(&((*s_etat_processus).mutex));
92:
93: pthread_mutex_lock(&((*s_argument_thread).mutex));
94: pthread_mutex_unlock(&((*s_argument_thread).mutex));
95:
96: (*s_argument_thread).thread_actif = d_faux;
97:
98: tid_final = -2;
99:
100: while((longueur_ecriture = write_atomic(s_etat_processus,
101: (*s_argument_thread).pipe_nombre_interruptions_attente[1],
102: &tid_final, sizeof(tid_final))) != sizeof(tid_final))
103: {
104: if (longueur_ecriture == -1)
105: {
106: break;
107: }
108: }
109:
110: while((longueur_ecriture = write_atomic(s_etat_processus,
111: (*s_argument_thread).pipe_nombre_objets_attente[1],
112: &tid_final, sizeof(tid_final))) != sizeof(tid_final))
113: {
114: if (longueur_ecriture == -1)
115: {
116: break;
117: }
118: }
119:
120: pthread_exit(NULL);
121: }
122:
123: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
124: {
125: (*s_etat_processus).erreur_systeme = d_es_processus;
126:
127: pthread_mutex_lock(&((*s_argument_thread).mutex));
128: pthread_mutex_unlock(&((*s_argument_thread).mutex));
129:
130: (*s_argument_thread).thread_actif = d_faux;
131:
132: tid_final = -2;
133:
134: while((longueur_ecriture = write_atomic(s_etat_processus,
135: (*s_argument_thread).pipe_nombre_interruptions_attente[1],
136: &tid_final, sizeof(tid_final))) != sizeof(tid_final))
137: {
138: if (longueur_ecriture == -1)
139: {
140: break;
141: }
142: }
143:
144: while((longueur_ecriture = write_atomic(s_etat_processus,
145: (*s_argument_thread).pipe_nombre_objets_attente[1],
146: &tid_final, sizeof(tid_final))) != sizeof(tid_final))
147: {
148: if (longueur_ecriture == -1)
149: {
150: break;
151: }
152: }
153:
154: pthread_exit(NULL);
155: }
156:
157: insertion_thread(s_etat_processus, d_faux);
158:
159: // Envoi d'une donnée pour signaler le démarrage du thread au thread
160: // de surveillance.
161:
162: if (write_atomic(s_etat_processus,
163: (*s_argument_thread).pipe_nombre_objets_attente[1],
164: "-", sizeof(unsigned char)) != sizeof(unsigned char))
165: {
166: pthread_mutex_unlock(&((*s_etat_processus).mutex));
167: (*s_etat_processus).erreur_systeme = d_es_processus;
168:
169: pthread_mutex_lock(&((*s_argument_thread).mutex));
170: pthread_mutex_unlock(&((*s_argument_thread).mutex));
171:
172: (*s_argument_thread).thread_actif = d_faux;
173:
174: tid_final = -2;
175:
176: while((longueur_ecriture = write_atomic(s_etat_processus,
177: (*s_argument_thread).pipe_nombre_interruptions_attente[1],
178: &tid_final, sizeof(tid_final))) != sizeof(tid_final))
179: {
180: if (longueur_ecriture == -1)
181: {
182: break;
183: }
184: }
185:
186: while((longueur_ecriture = write_atomic(s_etat_processus,
187: (*s_argument_thread).pipe_nombre_objets_attente[1],
188: &tid_final, sizeof(tid_final))) != sizeof(tid_final))
189: {
190: if (longueur_ecriture == -1)
191: {
192: break;
193: }
194: }
195:
196: pthread_exit(NULL);
197: }
198:
199: if ((*s_etat_processus).evaluation_expression_compilee == 'N')
200: {
201: free((*s_etat_processus).instruction_courante);
202: (*s_etat_processus).instruction_courante = NULL;
203: }
204:
205: set = (*s_argument_thread).set;
206:
207: if (sigpending(&set) != 0)
208: {
209: (*s_etat_processus).erreur_systeme = d_es_processus;
210: }
211: else if (sigismember(&set, SIGSTART) == 0)
212: {
213: while(sigismember(&set, SIGSTART) == 0)
214: {
215: if (sigpending(&set) != 0)
216: {
217: (*s_etat_processus).erreur_systeme = d_es_processus;
218: }
219:
220: nanosleep(&attente, NULL);
221: }
222: }
223:
224: if ((*s_etat_processus).debug == d_vrai)
225: if (((*s_etat_processus).type_debug & d_debug_processus) != 0)
226: {
227: if ((*s_etat_processus).langue == 'F')
228: {
229: printf("[%d] Lancement du thread %llu\n", (int) getpid(),
230: (unsigned long long) pthread_self());
231: }
232: else
233: {
234: printf("[%d] Start thread %llu\n", (int) getpid(),
235: (unsigned long long) pthread_self());
236: }
237:
238: fflush(stdout);
239: }
240:
241: if (pthread_sigmask(SIG_SETMASK, &((*s_argument_thread).oldset), NULL) != 0)
242: {
243: (*s_etat_processus).erreur_systeme = d_es_processus;
244: }
245:
246: sigpending(&set);
247:
248: (*s_etat_processus).pid_erreur_processus_fils = getpid();
249:
250: // Évaluation de l'objet
251:
252: if ((*s_etat_processus).erreur_systeme == d_es)
253: {
254: if (evaluation(s_etat_processus, (*s_argument_thread).argument, 'E')
255: == d_erreur)
256: {
257: if (((*s_etat_processus).erreur_execution == d_ex) &&
258: ((*s_etat_processus).erreur_systeme == d_es))
259: {
260: (*s_etat_processus).erreur_execution =
261: d_ex_erreur_evaluation;
262: }
263: }
264:
265: if ((*s_argument_thread).destruction_objet == d_vrai)
266: {
267: liberation(s_etat_processus, (*s_argument_thread).argument);
268: }
269: }
270:
271: if ((*s_etat_processus).presence_fusible == d_vrai)
272: {
273: pthread_cancel((*s_etat_processus).thread_fusible);
274: }
275:
276: tid_final = -2;
277:
278: while((longueur_ecriture = write_atomic(s_etat_processus,
279: (*s_argument_thread).pipe_nombre_interruptions_attente[1],
280: &tid_final, sizeof(tid_final))) != sizeof(tid_final))
281: {
282: if (longueur_ecriture == -1)
283: {
284: break;
285: }
286: }
287:
288: while((longueur_ecriture = write_atomic(s_etat_processus,
289: (*s_argument_thread).pipe_nombre_objets_attente[1],
290: &tid_final, sizeof(tid_final))) != sizeof(tid_final))
291: {
292: if (longueur_ecriture == -1)
293: {
294: break;
295: }
296: }
297:
298: if ((*s_etat_processus).var_volatile_processus_pere != 0)
299: {
300: // Racine des processus atteinte
301:
302: erreur = d_ex;
303:
304: while((longueur_ecriture = write_atomic(s_etat_processus,
305: (*s_argument_thread).pipe_erreurs[1], &erreur,
306: sizeof((*s_etat_processus).erreur_execution))) !=
307: sizeof((*s_etat_processus).erreur_execution))
308: {
309: if (longueur_ecriture == -1)
310: {
311: break;
312: }
313: }
314: }
315: else
316: {
317: while((longueur_ecriture = write_atomic(s_etat_processus,
318: (*s_argument_thread).pipe_erreurs[1],
319: &((*s_etat_processus).erreur_execution),
320: sizeof((*s_etat_processus).erreur_execution))) !=
321: sizeof((*s_etat_processus).erreur_execution))
322: {
323: if (longueur_ecriture == -1)
324: {
325: break;
326: }
327: }
328: }
329:
330: if ((*s_etat_processus).var_volatile_processus_pere != 0)
331: {
332: // Racine des processus atteinte
333:
334: erreur = d_es;
335:
336: while((longueur_ecriture = write_atomic(s_etat_processus,
337: (*s_argument_thread).pipe_erreurs[1], &erreur,
338: sizeof((*s_etat_processus).erreur_systeme))) !=
339: sizeof((*s_etat_processus).erreur_systeme))
340: {
341: if (longueur_ecriture == -1)
342: {
343: break;
344: }
345: }
346: }
347: else
348: {
349: while((longueur_ecriture = write_atomic(s_etat_processus,
350: (*s_argument_thread).pipe_erreurs[1],
351: &((*s_etat_processus).erreur_systeme),
352: sizeof((*s_etat_processus).erreur_systeme))) !=
353: sizeof((*s_etat_processus).erreur_systeme))
354: {
355: if (longueur_ecriture == -1)
356: {
357: break;
358: }
359: }
360: }
361:
362: if ((*s_etat_processus).pid_erreur_processus_fils == 0)
363: {
364: ppid = getpid();
365:
366: while((longueur_ecriture = write_atomic(s_etat_processus,
367: (*s_argument_thread).pipe_erreurs[1],
368: &ppid, sizeof(ppid))) != sizeof(ppid))
369: {
370: if (longueur_ecriture == -1)
371: {
372: break;
373: }
374: }
375: }
376: else
377: {
378: while((longueur_ecriture = write_atomic(s_etat_processus,
379: (*s_argument_thread).pipe_erreurs[1],
380: &((*s_etat_processus).pid_erreur_processus_fils),
381: sizeof((*s_etat_processus).pid_erreur_processus_fils))) !=
382: sizeof((*s_etat_processus).pid_erreur_processus_fils))
383: {
384: if (longueur_ecriture == -1)
385: {
386: break;
387: }
388: }
389: }
390:
391: close((*s_argument_thread).pipe_erreurs[1]);
392: close((*s_argument_thread).pipe_interruptions[1]);
393: close((*s_argument_thread).pipe_nombre_interruptions_attente[1]);
394: close((*s_argument_thread).pipe_objets[1]);
395: close((*s_argument_thread).pipe_nombre_objets_attente[1]);
396: close((*s_argument_thread).pipe_injections[0]);
397: close((*s_argument_thread).pipe_nombre_injections[0]);
398: close((*s_argument_thread).pipe_acquittement[0]);
399:
400: l_element_courant = (*s_etat_processus).s_fichiers;
401:
402: while(l_element_courant != NULL)
403: {
404: l_element_suivant = (*l_element_courant).suivant;
405:
406: if ((*((struct_descripteur_fichier *) (*l_element_courant)
407: .donnee)).pid == getpid())
408: {
409: fclose((*((struct_descripteur_fichier *)
1.5 bertrand 410: (*l_element_courant).donnee)).descripteur_c);
411:
412: if ((*((struct_descripteur_fichier *)
413: (*l_element_courant).donnee)).type != 'C')
414: {
415: sqlite3_close((*((struct_descripteur_fichier *)
416: (*l_element_courant).donnee)).descripteur_sqlite);
417: }
1.1 bertrand 418:
419: if ((*((struct_descripteur_fichier *) (*l_element_courant)
420: .donnee)).effacement == 'Y')
421: {
422: unlink((*((struct_descripteur_fichier *)
423: (*l_element_courant).donnee)).nom);
424: }
425: }
426:
427: free((*((struct_descripteur_fichier *) (*l_element_courant)
428: .donnee)).nom);
429: free((struct_descripteur_fichier *) (*l_element_courant).donnee);
430: free(l_element_courant);
431:
432: l_element_courant = l_element_suivant;
433: }
434:
435: pthread_mutex_lock(&((*s_etat_processus).mutex));
436:
437: l_element_courant = (struct_liste_chainee *)
438: (*s_etat_processus).l_base_pile_processus;
439:
440: while(l_element_courant != NULL)
441: {
442: if ((*(*((struct_processus_fils *) (*(*l_element_courant).donnee)
443: .objet)).thread).processus_detache == d_vrai)
444: {
445: if ((*s_etat_processus).debug == d_vrai)
446: {
447: if (((*s_etat_processus).type_debug & d_debug_processus) != 0)
448: {
449: if ((*s_etat_processus).langue == 'F')
450: {
451: printf("[%d] Signalement pour arrêt du processus %d\n",
452: (int) getpid(),
453: (int) (*(*((struct_processus_fils *)
454: (*(*l_element_courant).donnee).objet)).thread)
455: .pid);
456: }
457: else
458: {
459: printf("[%d] Send stop signal to process %d\n",
460: (int) getpid(),
461: (int) (*(*((struct_processus_fils *)
462: (*(*l_element_courant).donnee).objet)).thread)
463: .pid);
464: }
465: }
466: }
467:
468: if ((*s_etat_processus).var_volatile_alarme != 0)
469: {
470: kill((*(*((struct_processus_fils *) (*(*l_element_courant)
471: .donnee).objet)).thread).pid, SIGURG);
472: }
473: else
474: {
475: kill((*(*((struct_processus_fils *) (*(*l_element_courant)
476: .donnee).objet)).thread).pid, SIGFSTOP);
477: }
478: }
479: else
480: {
481: if ((*s_etat_processus).debug == d_vrai)
482: {
483: if (((*s_etat_processus).type_debug & d_debug_processus) != 0)
484: {
485: if ((*s_etat_processus).langue == 'F')
486: {
487: printf("[%d] Signalement pour arrêt du thread %llu\n",
488: (int) getpid(), (unsigned long long)
489: (*(*((struct_processus_fils *)
490: (*(*l_element_courant).donnee).objet)).thread)
491: .tid);
492: }
493: else
494: {
495: printf("[%d] Send stop signal to thread %llu\n",
496: (int) getpid(), (unsigned long long)
497: (*(*((struct_processus_fils *)
498: (*(*l_element_courant).donnee).objet)).thread)
499: .tid);
500: }
501: }
502: }
503:
504: if ((*s_etat_processus).var_volatile_alarme != 0)
505: {
506: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
507: (*(*l_element_courant).donnee).objet)).thread).mutex))
508: != 0)
509: {
510: pthread_mutex_unlock(&((*s_etat_processus).mutex));
511: (*s_etat_processus).erreur_systeme = d_es_processus;
512:
513: pthread_mutex_lock(&((*s_argument_thread).mutex));
514: pthread_mutex_unlock(&((*s_argument_thread).mutex));
515:
516: (*s_argument_thread).thread_actif = d_faux;
517:
518: pthread_exit(NULL);
519: }
520:
521: if ((*(*((struct_processus_fils *)
522: (*(*l_element_courant).donnee).objet)).thread)
523: .thread_actif == d_vrai)
524: {
525: pthread_kill((*(*((struct_processus_fils *)
526: (*(*l_element_courant).donnee).objet)).thread).tid,
527: SIGURG);
528: }
529:
530: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
531: (*(*l_element_courant).donnee).objet)).thread)
532: .mutex)) != 0)
533: {
534: pthread_mutex_unlock(&((*s_etat_processus).mutex));
535: (*s_etat_processus).erreur_systeme = d_es_processus;
536:
537: pthread_mutex_lock(&((*s_argument_thread).mutex));
538: pthread_mutex_unlock(&((*s_argument_thread).mutex));
539:
540: (*s_argument_thread).thread_actif = d_faux;
541:
542: pthread_exit(NULL);
543: }
544: }
545: else
546: {
547: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
548: (*(*l_element_courant).donnee).objet)).thread).mutex))
549: != 0)
550: {
551: pthread_mutex_unlock(&((*s_etat_processus).mutex));
552: (*s_etat_processus).erreur_systeme = d_es_processus;
553:
554: pthread_mutex_lock(&((*s_argument_thread).mutex));
555: pthread_mutex_unlock(&((*s_argument_thread).mutex));
556:
557: (*s_argument_thread).thread_actif = d_faux;
558:
559: pthread_exit(NULL);
560: }
561:
562: if ((*(*((struct_processus_fils *)
563: (*(*l_element_courant).donnee).objet)).thread)
564: .thread_actif == d_vrai)
565: {
566: pthread_kill((*(*((struct_processus_fils *)
567: (*(*l_element_courant).donnee).objet)).thread).tid,
568: SIGFSTOP);
569: }
570:
571: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
572: (*(*l_element_courant).donnee).objet)).thread).mutex))
573: != 0)
574: {
575: pthread_mutex_unlock(&((*s_etat_processus).mutex));
576: (*s_etat_processus).erreur_systeme = d_es_processus;
577:
578: pthread_mutex_lock(&((*s_argument_thread).mutex));
579: pthread_mutex_unlock(&((*s_argument_thread).mutex));
580:
581: (*s_argument_thread).thread_actif = d_faux;
582:
583: pthread_exit(NULL);
584: }
585: }
586: }
587:
588: l_element_courant = (*l_element_courant).suivant;
589: }
590:
591: /*
592: * Attente de la fin de tous les processus fils
593: */
594:
595: for(i = 0; i < d_NOMBRE_INTERRUPTIONS;
596: (*s_etat_processus).masque_interruptions[i++] = 'I');
597:
598: attente.tv_sec = 0;
599: attente.tv_nsec = GRANULARITE_us * 1000;
600:
601: while((*s_etat_processus).l_base_pile_processus != NULL)
602: {
603: status = 0;
604:
605: l_element_courant = (struct_liste_chainee *)
606: (*s_etat_processus).l_base_pile_processus;
607:
608: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
609: {
610: affectation_interruptions_logicielles(s_etat_processus);
611: }
612:
613: registre_stop = (*s_etat_processus)
614: .var_volatile_traitement_retarde_stop;
615: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
616:
617: for(i = 0; i < (unsigned long) (*(*((struct_processus_fils *)
618: (*(*l_element_courant).donnee).objet)).thread)
619: .nombre_objets_dans_pipe; i++)
620: {
621: if ((s_objet_temporaire = lecture_pipe(s_etat_processus,
622: (*(*((struct_processus_fils *) (*(*l_element_courant)
623: .donnee).objet)).thread).pipe_objets[0])) != NULL)
624: {
625: liberation(s_etat_processus, s_objet_temporaire);
626:
627: (*(*((struct_processus_fils *) (*(*l_element_courant)
628: .donnee).objet)).thread).nombre_objets_dans_pipe--;
629:
630: action.sa_handler = SIG_IGN;
631: action.sa_flags = SA_ONSTACK;
632:
633: if (sigaction(SIGPIPE, &action, ®istre) != 0)
634: {
635: pthread_mutex_unlock(&((*s_etat_processus).mutex));
636:
637: if (registre_stop == 0)
638: {
639: if ((*s_etat_processus)
640: .var_volatile_traitement_retarde_stop
641: == -1)
642: {
643: (*s_etat_processus)
644: .var_volatile_requete_arret = -1;
645: }
646:
647: (*s_etat_processus)
648: .var_volatile_traitement_retarde_stop =
649: registre_stop;
650: }
651:
652: (*s_etat_processus).erreur_systeme = d_es_signal;
653: exit(EXIT_FAILURE);
654: }
655:
656: while((longueur_ecriture = write_atomic(
657: s_etat_processus, (*(*((struct_processus_fils *)
658: (*(*l_element_courant).donnee).objet)).thread)
659: .pipe_nombre_injections[1], "+",
660: sizeof(unsigned char))) !=
661: sizeof(unsigned char))
662: {
663: if (longueur_ecriture == -1)
664: {
665: // Le processus n'existe plus.
666: break;
667: }
668: }
669:
670: if (registre_stop == 0)
671: {
672: if ((*s_etat_processus)
673: .var_volatile_traitement_retarde_stop == -1)
674: {
675: (*s_etat_processus).var_volatile_requete_arret
676: = -1;
677: }
678:
679: (*s_etat_processus)
680: .var_volatile_traitement_retarde_stop =
681: registre_stop;
682: }
683:
684: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
685: {
686: pthread_mutex_unlock(&((*s_etat_processus).mutex));
687:
688: (*s_etat_processus).erreur_systeme = d_es_signal;
689: exit(EXIT_FAILURE);
690: }
691: }
692: }
693:
694: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
695: .donnee).objet)).thread).processus_detache == d_vrai)
696: {
697: if (waitpid((*(*((struct_processus_fils *)
698: (*(*l_element_courant).donnee).objet)).thread).pid,
699: &status, WNOHANG) < 0)
700: {
701: }
702: }
703:
704: pthread_mutex_unlock(&((*s_etat_processus).mutex));
705: nanosleep(&attente, NULL);
706: pthread_mutex_lock(&((*s_etat_processus).mutex));
707: }
708:
709: pthread_mutex_unlock(&((*s_etat_processus).mutex));
710:
711: l_element_courant = (*s_etat_processus).s_sockets;
712:
713: while(l_element_courant != NULL)
714: {
715: l_element_suivant = (*l_element_courant).suivant;
716:
717: /*
718: * Fermeture des sockets créées dans le processus courant.
719: */
720:
721: if (((*((struct_socket *) (*(*l_element_courant).donnee).objet))
722: .pid == getpid()) && (pthread_equal((*((struct_socket *)
723: (*(*l_element_courant).donnee).objet)).tid, pthread_self())
724: != 0))
725: {
726: if ((*((struct_socket *) (*(*l_element_courant).donnee).objet))
727: .socket_connectee == d_vrai)
728: {
729: shutdown((*((struct_socket *) (*(*l_element_courant).donnee)
730: .objet)).socket, SHUT_RDWR);
731: }
732:
733: close((*((struct_socket *) (*(*l_element_courant).donnee).objet))
734: .socket);
735:
736: if ((*((struct_socket *) (*(*l_element_courant).donnee).objet))
737: .effacement == 'Y')
738: {
739: unlink((*((struct_socket *) (*(*l_element_courant).donnee)
740: .objet)).adresse);
741: }
742: }
743:
744: liberation(s_etat_processus, (*((struct_liste_chainee *)
745: l_element_courant)).donnee);
746: free(l_element_courant);
747:
748: l_element_courant = l_element_suivant;
749: }
750:
751: l_element_courant = (*s_etat_processus).s_connecteurs_sql;
752:
753: while(l_element_courant != NULL)
754: {
755: l_element_suivant = (*l_element_courant).suivant;
756:
757: /*
758: * Fermeture des connecteurs créés dans le processus courant.
759: */
760:
761: if (((*((struct_socket *) (*(*l_element_courant).donnee).objet))
762: .pid == getpid()) && (pthread_equal((*((struct_socket *)
763: (*(*l_element_courant).donnee).objet)).tid, pthread_self())
764: != 0))
765: {
766: sqlclose((*l_element_courant).donnee);
767: }
768:
769: liberation(s_etat_processus, (*((struct_liste_chainee *)
770: l_element_courant)).donnee);
771: free(l_element_courant);
772:
773: l_element_courant = l_element_suivant;
774: }
775:
776: if ((((*s_etat_processus).erreur_execution != d_ex) ||
777: ((*s_etat_processus).exception != d_ep) ||
778: ((*s_etat_processus).erreur_systeme != d_es)) &&
779: ((*s_etat_processus).var_volatile_traitement_sigint == 0))
780: {
781: printf("%s [%d]\n", message =
782: messages(s_etat_processus), (int) getpid());
783: free(message);
784:
785: if ((*s_etat_processus).core == d_vrai)
786: {
787: printf("\n");
788:
789: if ((*s_etat_processus).langue == 'F')
790: {
791: printf("+++Information : Génération du fichier rpl-core "
792: "[%d]\n", (int) getpid());
793: }
794: else
795: {
796: printf("+++Information : Writing rpl-core file [%d]\n",
797: (int) getpid());
798: }
799:
800: rplcore(s_etat_processus);
801:
802: if ((*s_etat_processus).langue == 'F')
803: {
804: printf("+++Information : Processus tracé [%d]\n",
805: (int) getpid());
806: }
807: else
808: {
809: printf("+++Information : Done [%d]\n", (int) getpid());
810: }
811:
812: printf("\n");
813: fflush(stdout);
814: }
815: }
816:
817: if ((*s_etat_processus).entree_standard != NULL)
818: {
819: pclose((*s_etat_processus).entree_standard);
820: (*s_etat_processus).entree_standard = NULL;
821: }
822:
823: if ((*s_etat_processus).fichiers_graphiques != NULL)
824: {
825: instruction_cllcd(s_etat_processus);
826: }
827:
828: liberation(s_etat_processus, (*s_etat_processus).indep);
829: liberation(s_etat_processus, (*s_etat_processus).depend);
830:
831: free((*s_etat_processus).label_x);
832: free((*s_etat_processus).label_y);
833: free((*s_etat_processus).label_z);
834: free((*s_etat_processus).titre);
835: free((*s_etat_processus).legende);
836:
837: liberation(s_etat_processus,
838: (*s_etat_processus).parametres_courbes_de_niveau);
839:
840: if ((*s_etat_processus).instruction_derniere_erreur != NULL)
841: {
842: free((*s_etat_processus).instruction_derniere_erreur);
843: (*s_etat_processus).instruction_derniere_erreur = NULL;
844: }
845:
846: for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
847: {
848: // Les définitions ne sont pas libérées parce qu'elles sont partagées
849: // avec le thread père.
850:
851: if ((*s_etat_processus).s_liste_variables[i].niveau != 0)
852: {
853: liberation(s_etat_processus,
854: (*s_etat_processus).s_liste_variables[i].objet);
855: }
856:
857: free((*s_etat_processus).s_liste_variables[i].nom);
858: }
859:
860: free((*s_etat_processus).s_liste_variables);
861:
862: for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
863: {
864: liberation(s_etat_processus,
865: (*s_etat_processus).s_liste_variables_statiques[i].objet);
866: free((*s_etat_processus).s_liste_variables_statiques[i].nom);
867: }
868:
869: free((*s_etat_processus).s_liste_variables_statiques);
870:
871: l_element_courant = (*s_etat_processus).l_base_pile;
872: while(l_element_courant != NULL)
873: {
874: l_element_suivant = (*l_element_courant).suivant;
875:
876: liberation(s_etat_processus, (*l_element_courant).donnee);
877: free(l_element_courant);
878:
879: l_element_courant = l_element_suivant;
880: }
881:
882: l_element_courant = (*s_etat_processus).l_base_pile_last;
883: while(l_element_courant != NULL)
884: {
885: l_element_suivant = (*l_element_courant).suivant;
886:
887: liberation(s_etat_processus, (*l_element_courant).donnee);
888: free(l_element_courant);
889:
890: l_element_courant = l_element_suivant;
891: }
892:
893: l_element_courant = (*s_etat_processus).l_base_pile_contextes;
894: while(l_element_courant != NULL)
895: {
896: l_element_suivant = (*l_element_courant).suivant;
897:
898: liberation(s_etat_processus, (*l_element_courant).donnee);
899: free(l_element_courant);
900:
901: l_element_courant = l_element_suivant;
902: }
903:
904: l_element_courant = (*s_etat_processus).l_base_pile_taille_contextes;
905: while(l_element_courant != NULL)
906: {
907: l_element_suivant = (*l_element_courant).suivant;
908:
909: liberation(s_etat_processus, (*l_element_courant).donnee);
910: free(l_element_courant);
911:
912: l_element_courant = l_element_suivant;
913: }
914:
915: l_element_courant = (struct_liste_chainee *)
916: (*s_etat_processus).l_base_pile_systeme;
917: while(l_element_courant != NULL)
918: {
919: l_element_suivant = (struct_liste_chainee *)
920: (*((struct_liste_pile_systeme *)
921: l_element_courant)).suivant;
922:
923: liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
924: l_element_courant)).indice_boucle);
925: liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
926: l_element_courant)).limite_indice_boucle);
927: liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
928: l_element_courant)).objet_de_test);
929:
930: if ((*((struct_liste_pile_systeme *)
931: l_element_courant)).nom_variable != NULL)
932: {
933: free((*((struct_liste_pile_systeme *)
934: l_element_courant)).nom_variable);
935: }
936:
937: free((struct_liste_pile_systeme *) l_element_courant);
938:
939: l_element_courant = l_element_suivant;
940: }
941:
942: l_element_courant = (*s_etat_processus).s_bibliotheques;
943:
944: while(l_element_courant != NULL)
945: {
946: l_element_suivant = (*l_element_courant).suivant;
947:
948: free((*((struct_bibliotheque *) (*l_element_courant).donnee)).nom);
949:
950: if (((*((struct_bibliotheque *) (*l_element_courant).donnee)).pid
951: == getpid()) && (pthread_equal((*((struct_bibliotheque *)
952: (*l_element_courant).donnee)).tid, pthread_self()) != 0))
953: {
954: dlclose((*((struct_bibliotheque *) (*l_element_courant).donnee))
955: .descripteur);
956: }
957:
958: free((*l_element_courant).donnee);
959: free(l_element_courant);
960:
961: l_element_courant = l_element_suivant;
962: }
963:
964: for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++)
965: {
966: free((*s_etat_processus).s_instructions_externes[i].nom);
967: free((*s_etat_processus).s_instructions_externes[i]
968: .nom_bibliotheque);
969: }
970:
971: if ((*s_etat_processus).nombre_instructions_externes != 0)
972: {
973: free((*s_etat_processus).s_instructions_externes);
974: }
975:
976: if ((*s_etat_processus).debug == d_vrai)
977: if (((*s_etat_processus).type_debug & d_debug_processus) != 0)
978: {
979: if ((*s_etat_processus).langue == 'F')
980: {
981: printf("[%d] Fin du thread %llu\n", (int) getpid(),
982: (unsigned long long) pthread_self());
983: }
984: else
985: {
986: printf("[%d] End of thread %llu\n", (int) getpid(),
987: (unsigned long long) pthread_self());
988: }
989:
990: fflush(stdout);
991: }
992:
993: liberation(s_etat_processus, (*s_argument_thread).argument);
994:
995: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
996: {
997: liberation(s_etat_processus,
998: (*s_etat_processus).corps_interruptions[i]);
999:
1000: l_element_courant = (*s_etat_processus)
1001: .pile_origine_interruptions[i];
1002:
1003: while(l_element_courant != NULL)
1004: {
1005: l_element_suivant = (*l_element_courant).suivant;
1006:
1007: liberation(s_etat_processus, (*l_element_courant).donnee);
1008: free(l_element_courant);
1009:
1010: l_element_courant = l_element_suivant;
1011: }
1012: }
1013:
1014: l_element_courant = (struct_liste_chainee *) (*s_etat_processus).s_marques;
1015:
1016: while(l_element_courant != NULL)
1017: {
1018: free((*((struct_marque *) l_element_courant)).label);
1019: free((*((struct_marque *) l_element_courant)).position);
1020: l_element_suivant = (struct_liste_chainee *)
1021: (*((struct_marque *) l_element_courant)).suivant;
1022: free((struct_marque *) l_element_courant);
1023: l_element_courant = l_element_suivant;
1024: }
1025:
1026: if ((*s_etat_processus).generateur_aleatoire != NULL)
1027: {
1028: liberation_generateur_aleatoire(s_etat_processus);
1029: }
1030:
1031: if ((*s_etat_processus).profilage == d_vrai)
1032: {
1033: ecriture_profil(s_etat_processus);
1034: liberation_profil(s_etat_processus);
1035: }
1036:
1037: liberation_allocateur(s_etat_processus);
1038:
1039: retrait_thread(s_etat_processus);
1040: pthread_mutex_destroy(&((*s_etat_processus).mutex));
1041:
1042: free((*s_etat_processus).localisation);
1043: free(s_etat_processus);
1044:
1045: pthread_mutex_lock(&((*s_argument_thread).mutex));
1046: pthread_mutex_unlock(&((*s_argument_thread).mutex));
1047:
1048: (*s_argument_thread).thread_actif = d_faux;
1049: pthread_exit(NULL);
1050: }
1051:
1052: // vim: ts=4