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