Annotation of rpl/src/gestion_threads.c, revision 1.75
1.1 bertrand 1: /*
2: ================================================================================
1.73 bertrand 3: RPL/2 (R) version 4.1.13
1.72 bertrand 4: Copyright (C) 1989-2013 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: {
1.69 bertrand 41: int status;
1.1 bertrand 42:
1.69 bertrand 43: pid_t ppid;
1.1 bertrand 44:
1.69 bertrand 45: pthread_t tid_final;
1.1 bertrand 46:
1.69 bertrand 47: sig_atomic_t registre_stop;
1.1 bertrand 48:
1.69 bertrand 49: ssize_t longueur_ecriture;
1.1 bertrand 50:
1.69 bertrand 51: struct_descripteur_thread *s_argument_thread;
1.1 bertrand 52:
1.69 bertrand 53: struct_liste_chainee *l_element_courant;
54: struct_liste_chainee *l_element_suivant;
1.1 bertrand 55:
1.69 bertrand 56: struct_liste_variables_statiques *l_element_statique_courant;
57: struct_liste_variables_statiques *l_element_statique_suivant;
1.1 bertrand 58:
1.69 bertrand 59: struct_objet *s_objet_temporaire;
1.1 bertrand 60:
1.69 bertrand 61: struct_processus *s_etat_processus;
1.1 bertrand 62:
1.69 bertrand 63: struct sigaction action;
64: struct sigaction registre;
1.1 bertrand 65:
1.69 bertrand 66: struct timespec attente;
1.1 bertrand 67:
1.69 bertrand 68: unsigned char *message;
1.1 bertrand 69:
1.69 bertrand 70: unsigned int erreur;
71:
1.74 bertrand 72: integer8 i;
1.1 bertrand 73:
74: attente.tv_sec = 0;
75: attente.tv_nsec = GRANULARITE_us * 1000;
76:
77: s_argument_thread = (struct_descripteur_thread *) argument;
1.20 bertrand 78: s_etat_processus = (*s_argument_thread).s_nouvel_etat_processus;
1.55 bertrand 79:
80: # ifndef SEMAPHORES_NOMMES
81: sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
82: # else
83: if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(),
84: pthread_self(), SEM_FORK)) == SEM_FAILED)
85: {
86: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
87: return(NULL);
88: }
89: # endif
90:
1.1 bertrand 91: (*s_argument_thread).tid = pthread_self();
1.75 ! bertrand 92: insertion_thread(s_etat_processus, d_faux);
1.1 bertrand 93: (*s_argument_thread).thread_actif = d_vrai;
94:
95: // Envoi d'une donnée pour signaler le démarrage du thread au thread
96: // de surveillance.
97:
98: if (write_atomic(s_etat_processus,
99: (*s_argument_thread).pipe_nombre_objets_attente[1],
100: "-", sizeof(unsigned char)) != sizeof(unsigned char))
101: {
102: (*s_etat_processus).erreur_systeme = d_es_processus;
103:
104: pthread_mutex_lock(&((*s_argument_thread).mutex));
105: pthread_mutex_unlock(&((*s_argument_thread).mutex));
106:
107: (*s_argument_thread).thread_actif = d_faux;
108:
1.64 bertrand 109: tid_final = (pthread_t) -2;
1.1 bertrand 110:
111: while((longueur_ecriture = write_atomic(s_etat_processus,
112: (*s_argument_thread).pipe_nombre_interruptions_attente[1],
113: &tid_final, sizeof(tid_final))) != sizeof(tid_final))
114: {
115: if (longueur_ecriture == -1)
116: {
117: break;
118: }
119: }
120:
121: while((longueur_ecriture = write_atomic(s_etat_processus,
122: (*s_argument_thread).pipe_nombre_objets_attente[1],
123: &tid_final, sizeof(tid_final))) != sizeof(tid_final))
124: {
125: if (longueur_ecriture == -1)
126: {
127: break;
128: }
129: }
130:
131: pthread_exit(NULL);
132: }
133:
134: if ((*s_etat_processus).evaluation_expression_compilee == 'N')
135: {
136: free((*s_etat_processus).instruction_courante);
137: (*s_etat_processus).instruction_courante = NULL;
138: }
139:
1.50 bertrand 140: // Attente de la réception du signal rpl_sigstart.
1.1 bertrand 141:
1.50 bertrand 142: for((*s_etat_processus).demarrage_fils = d_faux;;)
1.1 bertrand 143: {
1.50 bertrand 144: scrutation_interruptions(s_etat_processus);
145:
146: if ((*s_etat_processus).demarrage_fils == d_vrai)
1.1 bertrand 147: {
1.50 bertrand 148: break;
149: }
1.1 bertrand 150:
1.50 bertrand 151: nanosleep(&attente, NULL);
1.1 bertrand 152: }
153:
154: if ((*s_etat_processus).debug == d_vrai)
155: if (((*s_etat_processus).type_debug & d_debug_processus) != 0)
156: {
157: if ((*s_etat_processus).langue == 'F')
158: {
159: printf("[%d] Lancement du thread %llu\n", (int) getpid(),
160: (unsigned long long) pthread_self());
161: }
162: else
163: {
164: printf("[%d] Start thread %llu\n", (int) getpid(),
165: (unsigned long long) pthread_self());
166: }
167:
168: fflush(stdout);
169: }
170:
171: (*s_etat_processus).pid_erreur_processus_fils = getpid();
172:
173: // Évaluation de l'objet
174:
175: if ((*s_etat_processus).erreur_systeme == d_es)
176: {
1.49 bertrand 177: if (setjmp(contexte_thread) == 0)
1.1 bertrand 178: {
1.49 bertrand 179: if (evaluation(s_etat_processus, (*s_argument_thread).argument, 'E')
180: == d_erreur)
1.1 bertrand 181: {
1.49 bertrand 182: if (((*s_etat_processus).erreur_execution == d_ex) &&
183: ((*s_etat_processus).erreur_systeme == d_es))
184: {
185: (*s_etat_processus).erreur_execution =
186: d_ex_erreur_evaluation;
187: }
1.1 bertrand 188: }
1.49 bertrand 189: else
1.10 bertrand 190: {
1.49 bertrand 191: if (((*s_etat_processus).var_volatile_alarme == 0)
192: && ((*s_etat_processus).arret_depuis_abort == 0)
193: && ((*s_etat_processus).at_exit != NULL))
194: {
195: (*s_etat_processus).var_volatile_requete_arret = 0;
196: (*s_etat_processus).var_volatile_traitement_retarde_stop =
197: -1;
1.13 bertrand 198:
1.49 bertrand 199: if (evaluation(s_etat_processus,
200: (*s_etat_processus).at_exit, 'E') == d_erreur)
1.12 bertrand 201: {
1.49 bertrand 202: if (((*s_etat_processus).erreur_execution == d_ex) &&
203: ((*s_etat_processus).erreur_systeme == d_es))
204: {
205: (*s_etat_processus).erreur_execution =
206: d_ex_erreur_evaluation;
207: }
1.12 bertrand 208: }
1.10 bertrand 209: }
210: }
211: }
1.1 bertrand 212:
213: if ((*s_argument_thread).destruction_objet == d_vrai)
214: {
215: liberation(s_etat_processus, (*s_argument_thread).argument);
216: }
217: }
218:
219: if ((*s_etat_processus).presence_fusible == d_vrai)
220: {
221: pthread_cancel((*s_etat_processus).thread_fusible);
222: }
223:
1.64 bertrand 224: tid_final = (pthread_t) -2;
1.1 bertrand 225:
226: while((longueur_ecriture = write_atomic(s_etat_processus,
227: (*s_argument_thread).pipe_nombre_interruptions_attente[1],
228: &tid_final, sizeof(tid_final))) != sizeof(tid_final))
229: {
230: if (longueur_ecriture == -1)
231: {
232: break;
233: }
234: }
235:
236: while((longueur_ecriture = write_atomic(s_etat_processus,
237: (*s_argument_thread).pipe_nombre_objets_attente[1],
238: &tid_final, sizeof(tid_final))) != sizeof(tid_final))
239: {
240: if (longueur_ecriture == -1)
241: {
242: break;
243: }
244: }
245:
246: if ((*s_etat_processus).var_volatile_processus_pere != 0)
247: {
248: // Racine des processus atteinte
249:
250: erreur = d_ex;
251:
252: while((longueur_ecriture = write_atomic(s_etat_processus,
253: (*s_argument_thread).pipe_erreurs[1], &erreur,
254: sizeof((*s_etat_processus).erreur_execution))) !=
255: sizeof((*s_etat_processus).erreur_execution))
256: {
257: if (longueur_ecriture == -1)
258: {
259: break;
260: }
261: }
262: }
263: else
264: {
265: while((longueur_ecriture = write_atomic(s_etat_processus,
266: (*s_argument_thread).pipe_erreurs[1],
267: &((*s_etat_processus).erreur_execution),
268: sizeof((*s_etat_processus).erreur_execution))) !=
269: sizeof((*s_etat_processus).erreur_execution))
270: {
271: if (longueur_ecriture == -1)
272: {
273: break;
274: }
275: }
276: }
277:
278: if ((*s_etat_processus).var_volatile_processus_pere != 0)
279: {
280: // Racine des processus atteinte
281:
282: erreur = d_es;
283:
284: while((longueur_ecriture = write_atomic(s_etat_processus,
285: (*s_argument_thread).pipe_erreurs[1], &erreur,
286: sizeof((*s_etat_processus).erreur_systeme))) !=
287: sizeof((*s_etat_processus).erreur_systeme))
288: {
289: if (longueur_ecriture == -1)
290: {
291: break;
292: }
293: }
294: }
295: else
296: {
297: while((longueur_ecriture = write_atomic(s_etat_processus,
298: (*s_argument_thread).pipe_erreurs[1],
299: &((*s_etat_processus).erreur_systeme),
300: sizeof((*s_etat_processus).erreur_systeme))) !=
301: sizeof((*s_etat_processus).erreur_systeme))
302: {
303: if (longueur_ecriture == -1)
304: {
305: break;
306: }
307: }
308: }
309:
310: if ((*s_etat_processus).pid_erreur_processus_fils == 0)
311: {
312: ppid = getpid();
313:
314: while((longueur_ecriture = write_atomic(s_etat_processus,
315: (*s_argument_thread).pipe_erreurs[1],
316: &ppid, sizeof(ppid))) != sizeof(ppid))
317: {
318: if (longueur_ecriture == -1)
319: {
320: break;
321: }
322: }
323: }
324: else
325: {
326: while((longueur_ecriture = write_atomic(s_etat_processus,
327: (*s_argument_thread).pipe_erreurs[1],
328: &((*s_etat_processus).pid_erreur_processus_fils),
329: sizeof((*s_etat_processus).pid_erreur_processus_fils))) !=
330: sizeof((*s_etat_processus).pid_erreur_processus_fils))
331: {
332: if (longueur_ecriture == -1)
333: {
334: break;
335: }
336: }
337: }
338:
339: close((*s_argument_thread).pipe_erreurs[1]);
340: close((*s_argument_thread).pipe_interruptions[1]);
341: close((*s_argument_thread).pipe_nombre_interruptions_attente[1]);
342: close((*s_argument_thread).pipe_objets[1]);
343: close((*s_argument_thread).pipe_nombre_objets_attente[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 *)
1.5 bertrand 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: }
1.1 bertrand 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: {
1.50 bertrand 418: envoi_signal_processus((*(*((struct_processus_fils *)
419: (*(*l_element_courant)
420: .donnee).objet)).thread).pid, rpl_sigurg);
1.1 bertrand 421: }
422: else
423: {
1.14 bertrand 424: if ((*s_etat_processus).arret_depuis_abort == -1)
425: {
1.50 bertrand 426: envoi_signal_processus((*(*((struct_processus_fils *)
427: (*(*l_element_courant)
428: .donnee).objet)).thread).pid, rpl_sigabort);
1.14 bertrand 429: }
430: else
431: {
1.50 bertrand 432: envoi_signal_processus((*(*((struct_processus_fils *)
433: (*(*l_element_courant)
434: .donnee).objet)).thread).pid, rpl_sigstop);
1.14 bertrand 435: }
1.1 bertrand 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: {
1.50 bertrand 484: envoi_signal_thread((*(*((struct_processus_fils *)
1.1 bertrand 485: (*(*l_element_courant).donnee).objet)).thread).tid,
1.50 bertrand 486: rpl_sigurg);
1.1 bertrand 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: {
1.14 bertrand 525: if ((*s_etat_processus).arret_depuis_abort == -1)
526: {
1.50 bertrand 527: envoi_signal_thread((*(*((struct_processus_fils *)
1.14 bertrand 528: (*(*l_element_courant).donnee).objet)).thread)
1.50 bertrand 529: .tid, rpl_sigabort);
1.14 bertrand 530: }
531: else
532: {
1.50 bertrand 533: envoi_signal_thread((*(*((struct_processus_fils *)
1.14 bertrand 534: (*(*l_element_courant).donnee).objet)).thread)
1.50 bertrand 535: .tid, rpl_sigstop);
1.14 bertrand 536: }
1.1 bertrand 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:
1.74 bertrand 580: for(i = 0; i < (*(*((struct_processus_fils *)
1.1 bertrand 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: pthread_mutex_unlock(&((*s_etat_processus).mutex));
1.15 bertrand 668:
669: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
670: {
671: affectation_interruptions_logicielles(s_etat_processus);
672: }
673:
1.1 bertrand 674: nanosleep(&attente, NULL);
675: pthread_mutex_lock(&((*s_etat_processus).mutex));
676: }
677:
678: pthread_mutex_unlock(&((*s_etat_processus).mutex));
679:
680: l_element_courant = (*s_etat_processus).s_sockets;
681:
682: while(l_element_courant != NULL)
683: {
684: l_element_suivant = (*l_element_courant).suivant;
685:
686: /*
687: * Fermeture des sockets créées dans le processus courant.
688: */
689:
690: if (((*((struct_socket *) (*(*l_element_courant).donnee).objet))
691: .pid == getpid()) && (pthread_equal((*((struct_socket *)
692: (*(*l_element_courant).donnee).objet)).tid, pthread_self())
693: != 0))
694: {
695: if ((*((struct_socket *) (*(*l_element_courant).donnee).objet))
696: .socket_connectee == d_vrai)
697: {
698: shutdown((*((struct_socket *) (*(*l_element_courant).donnee)
699: .objet)).socket, SHUT_RDWR);
700: }
701:
702: close((*((struct_socket *) (*(*l_element_courant).donnee).objet))
703: .socket);
704:
705: if ((*((struct_socket *) (*(*l_element_courant).donnee).objet))
706: .effacement == 'Y')
707: {
708: unlink((*((struct_socket *) (*(*l_element_courant).donnee)
709: .objet)).adresse);
710: }
711: }
712:
713: liberation(s_etat_processus, (*((struct_liste_chainee *)
714: l_element_courant)).donnee);
715: free(l_element_courant);
716:
717: l_element_courant = l_element_suivant;
718: }
719:
720: l_element_courant = (*s_etat_processus).s_connecteurs_sql;
721:
722: while(l_element_courant != NULL)
723: {
724: l_element_suivant = (*l_element_courant).suivant;
725:
726: /*
727: * Fermeture des connecteurs créés dans le processus courant.
728: */
729:
730: if (((*((struct_socket *) (*(*l_element_courant).donnee).objet))
731: .pid == getpid()) && (pthread_equal((*((struct_socket *)
732: (*(*l_element_courant).donnee).objet)).tid, pthread_self())
733: != 0))
734: {
735: sqlclose((*l_element_courant).donnee);
736: }
737:
738: liberation(s_etat_processus, (*((struct_liste_chainee *)
739: l_element_courant)).donnee);
740: free(l_element_courant);
741:
742: l_element_courant = l_element_suivant;
743: }
744:
745: if ((((*s_etat_processus).erreur_execution != d_ex) ||
746: ((*s_etat_processus).exception != d_ep) ||
747: ((*s_etat_processus).erreur_systeme != d_es)) &&
748: ((*s_etat_processus).var_volatile_traitement_sigint == 0))
749: {
750: printf("%s [%d]\n", message =
751: messages(s_etat_processus), (int) getpid());
752: free(message);
753:
754: if ((*s_etat_processus).core == d_vrai)
755: {
756: printf("\n");
757:
758: if ((*s_etat_processus).langue == 'F')
759: {
760: printf("+++Information : Génération du fichier rpl-core "
761: "[%d]\n", (int) getpid());
762: }
763: else
764: {
765: printf("+++Information : Writing rpl-core file [%d]\n",
766: (int) getpid());
767: }
768:
769: rplcore(s_etat_processus);
770:
771: if ((*s_etat_processus).langue == 'F')
772: {
773: printf("+++Information : Processus tracé [%d]\n",
774: (int) getpid());
775: }
776: else
777: {
778: printf("+++Information : Done [%d]\n", (int) getpid());
779: }
780:
781: printf("\n");
782: fflush(stdout);
783: }
784: }
785:
786: if ((*s_etat_processus).entree_standard != NULL)
787: {
788: pclose((*s_etat_processus).entree_standard);
789: (*s_etat_processus).entree_standard = NULL;
790: }
791:
792: if ((*s_etat_processus).fichiers_graphiques != NULL)
793: {
794: instruction_cllcd(s_etat_processus);
795: }
796:
797: liberation(s_etat_processus, (*s_etat_processus).indep);
798: liberation(s_etat_processus, (*s_etat_processus).depend);
799:
800: free((*s_etat_processus).label_x);
801: free((*s_etat_processus).label_y);
802: free((*s_etat_processus).label_z);
803: free((*s_etat_processus).titre);
804: free((*s_etat_processus).legende);
805:
806: liberation(s_etat_processus,
807: (*s_etat_processus).parametres_courbes_de_niveau);
808:
809: if ((*s_etat_processus).instruction_derniere_erreur != NULL)
810: {
811: free((*s_etat_processus).instruction_derniere_erreur);
812: (*s_etat_processus).instruction_derniere_erreur = NULL;
813: }
814:
1.35 bertrand 815: liberation_arbre_variables(s_etat_processus,
816: (*s_etat_processus).s_arbre_variables, d_faux);
1.1 bertrand 817:
1.69 bertrand 818: l_element_statique_courant = (*s_etat_processus)
819: .l_liste_variables_statiques;
820:
821: while(l_element_statique_courant != NULL)
822: {
823: l_element_statique_suivant = (*l_element_statique_courant).suivant;
824: free(l_element_statique_courant);
825: l_element_statique_courant = l_element_statique_suivant;
826: }
827:
1.1 bertrand 828: l_element_courant = (*s_etat_processus).l_base_pile;
829: while(l_element_courant != NULL)
830: {
831: l_element_suivant = (*l_element_courant).suivant;
832:
833: liberation(s_etat_processus, (*l_element_courant).donnee);
834: free(l_element_courant);
835:
836: l_element_courant = l_element_suivant;
837: }
838:
839: l_element_courant = (*s_etat_processus).l_base_pile_last;
840: while(l_element_courant != NULL)
841: {
842: l_element_suivant = (*l_element_courant).suivant;
843:
844: liberation(s_etat_processus, (*l_element_courant).donnee);
845: free(l_element_courant);
846:
847: l_element_courant = l_element_suivant;
848: }
849:
850: l_element_courant = (*s_etat_processus).l_base_pile_contextes;
851: while(l_element_courant != NULL)
852: {
853: l_element_suivant = (*l_element_courant).suivant;
854:
855: liberation(s_etat_processus, (*l_element_courant).donnee);
856: free(l_element_courant);
857:
858: l_element_courant = l_element_suivant;
859: }
860:
861: l_element_courant = (*s_etat_processus).l_base_pile_taille_contextes;
862: while(l_element_courant != NULL)
863: {
864: l_element_suivant = (*l_element_courant).suivant;
865:
866: liberation(s_etat_processus, (*l_element_courant).donnee);
867: free(l_element_courant);
868:
869: l_element_courant = l_element_suivant;
870: }
871:
872: l_element_courant = (struct_liste_chainee *)
873: (*s_etat_processus).l_base_pile_systeme;
874: while(l_element_courant != NULL)
875: {
876: l_element_suivant = (struct_liste_chainee *)
877: (*((struct_liste_pile_systeme *)
878: l_element_courant)).suivant;
879:
880: liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
881: l_element_courant)).indice_boucle);
882: liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
883: l_element_courant)).limite_indice_boucle);
884: liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
885: l_element_courant)).objet_de_test);
886:
887: if ((*((struct_liste_pile_systeme *)
888: l_element_courant)).nom_variable != NULL)
889: {
890: free((*((struct_liste_pile_systeme *)
891: l_element_courant)).nom_variable);
892: }
893:
894: free((struct_liste_pile_systeme *) l_element_courant);
895:
896: l_element_courant = l_element_suivant;
897: }
898:
899: l_element_courant = (*s_etat_processus).s_bibliotheques;
900:
901: while(l_element_courant != NULL)
902: {
903: l_element_suivant = (*l_element_courant).suivant;
904:
905: free((*((struct_bibliotheque *) (*l_element_courant).donnee)).nom);
906:
907: if (((*((struct_bibliotheque *) (*l_element_courant).donnee)).pid
908: == getpid()) && (pthread_equal((*((struct_bibliotheque *)
909: (*l_element_courant).donnee)).tid, pthread_self()) != 0))
910: {
911: dlclose((*((struct_bibliotheque *) (*l_element_courant).donnee))
912: .descripteur);
913: }
914:
915: free((*l_element_courant).donnee);
916: free(l_element_courant);
917:
918: l_element_courant = l_element_suivant;
919: }
920:
921: for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++)
922: {
923: free((*s_etat_processus).s_instructions_externes[i].nom);
924: free((*s_etat_processus).s_instructions_externes[i]
925: .nom_bibliotheque);
926: }
927:
928: if ((*s_etat_processus).nombre_instructions_externes != 0)
929: {
930: free((*s_etat_processus).s_instructions_externes);
931: }
932:
933: if ((*s_etat_processus).debug == d_vrai)
934: if (((*s_etat_processus).type_debug & d_debug_processus) != 0)
935: {
936: if ((*s_etat_processus).langue == 'F')
937: {
938: printf("[%d] Fin du thread %llu\n", (int) getpid(),
939: (unsigned long long) pthread_self());
940: }
941: else
942: {
943: printf("[%d] End of thread %llu\n", (int) getpid(),
944: (unsigned long long) pthread_self());
945: }
946:
947: fflush(stdout);
948: }
949:
950: liberation(s_etat_processus, (*s_argument_thread).argument);
1.11 bertrand 951: liberation(s_etat_processus, (*s_etat_processus).at_exit);
1.25 bertrand 952: liberation(s_etat_processus, (*s_etat_processus).at_poke);
1.1 bertrand 953:
954: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
955: {
956: liberation(s_etat_processus,
957: (*s_etat_processus).corps_interruptions[i]);
958:
959: l_element_courant = (*s_etat_processus)
960: .pile_origine_interruptions[i];
961:
962: while(l_element_courant != NULL)
963: {
964: l_element_suivant = (*l_element_courant).suivant;
965:
966: liberation(s_etat_processus, (*l_element_courant).donnee);
967: free(l_element_courant);
968:
969: l_element_courant = l_element_suivant;
970: }
971: }
972:
973: l_element_courant = (struct_liste_chainee *) (*s_etat_processus).s_marques;
974:
975: while(l_element_courant != NULL)
976: {
977: free((*((struct_marque *) l_element_courant)).label);
978: free((*((struct_marque *) l_element_courant)).position);
979: l_element_suivant = (struct_liste_chainee *)
980: (*((struct_marque *) l_element_courant)).suivant;
981: free((struct_marque *) l_element_courant);
982: l_element_courant = l_element_suivant;
983: }
984:
985: if ((*s_etat_processus).generateur_aleatoire != NULL)
986: {
987: liberation_generateur_aleatoire(s_etat_processus);
988: }
989:
990: if ((*s_etat_processus).profilage == d_vrai)
991: {
992: ecriture_profil(s_etat_processus);
993: liberation_profil(s_etat_processus);
994: }
995:
996: liberation_allocateur(s_etat_processus);
997:
998: retrait_thread(s_etat_processus);
999: pthread_mutex_destroy(&((*s_etat_processus).mutex));
1.21 bertrand 1000: pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
1.53 bertrand 1001:
1002: # ifndef SEMAPHORES_NOMMES
1003: sem_destroy(&((*s_etat_processus).semaphore_fork));
1004: # else
1.55 bertrand 1005: sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
1006: pthread_self(), SEM_FORK);
1.53 bertrand 1007: # endif
1.28 bertrand 1008:
1.45 bertrand 1009: liberation_contexte_cas(s_etat_processus);
1.1 bertrand 1010: free((*s_etat_processus).localisation);
1011: free(s_etat_processus);
1012:
1013: pthread_mutex_lock(&((*s_argument_thread).mutex));
1014: pthread_mutex_unlock(&((*s_argument_thread).mutex));
1015:
1016: (*s_argument_thread).thread_actif = d_faux;
1017: pthread_exit(NULL);
1.26 bertrand 1018: return(NULL);
1.1 bertrand 1019: }
1020:
1021: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>