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