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