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