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