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