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