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