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