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