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