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