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