Annotation of rpl/src/gestion_threads.c, revision 1.49
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: 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;
1.20 bertrand 77: s_etat_processus = (*s_argument_thread).s_nouvel_etat_processus;
1.1 bertrand 78: (*s_argument_thread).tid = pthread_self();
79: (*s_argument_thread).thread_actif = d_vrai;
80:
1.8 bertrand 81: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 82: if (pthread_setspecific(semaphore_fork_processus_courant,
83: &((*s_etat_processus).semaphore_fork)) != 0)
1.8 bertrand 84: # else
85: if (pthread_setspecific(semaphore_fork_processus_courant,
86: (*s_etat_processus).semaphore_fork) != 0)
87: # endif
1.1 bertrand 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: {
1.49 ! bertrand 254: if (setjmp(contexte_thread) == 0)
1.1 bertrand 255: {
1.49 ! bertrand 256: if (evaluation(s_etat_processus, (*s_argument_thread).argument, 'E')
! 257: == d_erreur)
1.1 bertrand 258: {
1.49 ! bertrand 259: if (((*s_etat_processus).erreur_execution == d_ex) &&
! 260: ((*s_etat_processus).erreur_systeme == d_es))
! 261: {
! 262: (*s_etat_processus).erreur_execution =
! 263: d_ex_erreur_evaluation;
! 264: }
1.1 bertrand 265: }
1.49 ! bertrand 266: else
1.10 bertrand 267: {
1.49 ! bertrand 268: if (((*s_etat_processus).var_volatile_alarme == 0)
! 269: && ((*s_etat_processus).arret_depuis_abort == 0)
! 270: && ((*s_etat_processus).at_exit != NULL))
! 271: {
! 272: (*s_etat_processus).var_volatile_requete_arret = 0;
! 273: (*s_etat_processus).var_volatile_traitement_retarde_stop =
! 274: -1;
1.13 bertrand 275:
1.49 ! bertrand 276: if (evaluation(s_etat_processus,
! 277: (*s_etat_processus).at_exit, 'E') == d_erreur)
1.12 bertrand 278: {
1.49 ! bertrand 279: if (((*s_etat_processus).erreur_execution == d_ex) &&
! 280: ((*s_etat_processus).erreur_systeme == d_es))
! 281: {
! 282: (*s_etat_processus).erreur_execution =
! 283: d_ex_erreur_evaluation;
! 284: }
1.12 bertrand 285: }
1.10 bertrand 286: }
287: }
288: }
1.1 bertrand 289:
290: if ((*s_argument_thread).destruction_objet == d_vrai)
291: {
292: liberation(s_etat_processus, (*s_argument_thread).argument);
293: }
294: }
295:
296: if ((*s_etat_processus).presence_fusible == d_vrai)
297: {
298: pthread_cancel((*s_etat_processus).thread_fusible);
299: }
300:
301: tid_final = -2;
302:
303: while((longueur_ecriture = write_atomic(s_etat_processus,
304: (*s_argument_thread).pipe_nombre_interruptions_attente[1],
305: &tid_final, sizeof(tid_final))) != sizeof(tid_final))
306: {
307: if (longueur_ecriture == -1)
308: {
309: break;
310: }
311: }
312:
313: while((longueur_ecriture = write_atomic(s_etat_processus,
314: (*s_argument_thread).pipe_nombre_objets_attente[1],
315: &tid_final, sizeof(tid_final))) != sizeof(tid_final))
316: {
317: if (longueur_ecriture == -1)
318: {
319: break;
320: }
321: }
322:
323: if ((*s_etat_processus).var_volatile_processus_pere != 0)
324: {
325: // Racine des processus atteinte
326:
327: erreur = d_ex;
328:
329: while((longueur_ecriture = write_atomic(s_etat_processus,
330: (*s_argument_thread).pipe_erreurs[1], &erreur,
331: sizeof((*s_etat_processus).erreur_execution))) !=
332: sizeof((*s_etat_processus).erreur_execution))
333: {
334: if (longueur_ecriture == -1)
335: {
336: break;
337: }
338: }
339: }
340: else
341: {
342: while((longueur_ecriture = write_atomic(s_etat_processus,
343: (*s_argument_thread).pipe_erreurs[1],
344: &((*s_etat_processus).erreur_execution),
345: sizeof((*s_etat_processus).erreur_execution))) !=
346: sizeof((*s_etat_processus).erreur_execution))
347: {
348: if (longueur_ecriture == -1)
349: {
350: break;
351: }
352: }
353: }
354:
355: if ((*s_etat_processus).var_volatile_processus_pere != 0)
356: {
357: // Racine des processus atteinte
358:
359: erreur = d_es;
360:
361: while((longueur_ecriture = write_atomic(s_etat_processus,
362: (*s_argument_thread).pipe_erreurs[1], &erreur,
363: sizeof((*s_etat_processus).erreur_systeme))) !=
364: sizeof((*s_etat_processus).erreur_systeme))
365: {
366: if (longueur_ecriture == -1)
367: {
368: break;
369: }
370: }
371: }
372: else
373: {
374: while((longueur_ecriture = write_atomic(s_etat_processus,
375: (*s_argument_thread).pipe_erreurs[1],
376: &((*s_etat_processus).erreur_systeme),
377: sizeof((*s_etat_processus).erreur_systeme))) !=
378: sizeof((*s_etat_processus).erreur_systeme))
379: {
380: if (longueur_ecriture == -1)
381: {
382: break;
383: }
384: }
385: }
386:
387: if ((*s_etat_processus).pid_erreur_processus_fils == 0)
388: {
389: ppid = getpid();
390:
391: while((longueur_ecriture = write_atomic(s_etat_processus,
392: (*s_argument_thread).pipe_erreurs[1],
393: &ppid, sizeof(ppid))) != sizeof(ppid))
394: {
395: if (longueur_ecriture == -1)
396: {
397: break;
398: }
399: }
400: }
401: else
402: {
403: while((longueur_ecriture = write_atomic(s_etat_processus,
404: (*s_argument_thread).pipe_erreurs[1],
405: &((*s_etat_processus).pid_erreur_processus_fils),
406: sizeof((*s_etat_processus).pid_erreur_processus_fils))) !=
407: sizeof((*s_etat_processus).pid_erreur_processus_fils))
408: {
409: if (longueur_ecriture == -1)
410: {
411: break;
412: }
413: }
414: }
415:
416: close((*s_argument_thread).pipe_erreurs[1]);
417: close((*s_argument_thread).pipe_interruptions[1]);
418: close((*s_argument_thread).pipe_nombre_interruptions_attente[1]);
419: close((*s_argument_thread).pipe_objets[1]);
420: close((*s_argument_thread).pipe_nombre_objets_attente[1]);
421: close((*s_argument_thread).pipe_injections[0]);
422: close((*s_argument_thread).pipe_nombre_injections[0]);
423: close((*s_argument_thread).pipe_acquittement[0]);
424:
425: l_element_courant = (*s_etat_processus).s_fichiers;
426:
427: while(l_element_courant != NULL)
428: {
429: l_element_suivant = (*l_element_courant).suivant;
430:
431: if ((*((struct_descripteur_fichier *) (*l_element_courant)
432: .donnee)).pid == getpid())
433: {
434: fclose((*((struct_descripteur_fichier *)
1.5 bertrand 435: (*l_element_courant).donnee)).descripteur_c);
436:
437: if ((*((struct_descripteur_fichier *)
438: (*l_element_courant).donnee)).type != 'C')
439: {
440: sqlite3_close((*((struct_descripteur_fichier *)
441: (*l_element_courant).donnee)).descripteur_sqlite);
442: }
1.1 bertrand 443:
444: if ((*((struct_descripteur_fichier *) (*l_element_courant)
445: .donnee)).effacement == 'Y')
446: {
447: unlink((*((struct_descripteur_fichier *)
448: (*l_element_courant).donnee)).nom);
449: }
450: }
451:
452: free((*((struct_descripteur_fichier *) (*l_element_courant)
453: .donnee)).nom);
454: free((struct_descripteur_fichier *) (*l_element_courant).donnee);
455: free(l_element_courant);
456:
457: l_element_courant = l_element_suivant;
458: }
459:
460: pthread_mutex_lock(&((*s_etat_processus).mutex));
461:
462: l_element_courant = (struct_liste_chainee *)
463: (*s_etat_processus).l_base_pile_processus;
464:
465: while(l_element_courant != NULL)
466: {
467: if ((*(*((struct_processus_fils *) (*(*l_element_courant).donnee)
468: .objet)).thread).processus_detache == d_vrai)
469: {
470: if ((*s_etat_processus).debug == d_vrai)
471: {
472: if (((*s_etat_processus).type_debug & d_debug_processus) != 0)
473: {
474: if ((*s_etat_processus).langue == 'F')
475: {
476: printf("[%d] Signalement pour arrêt du processus %d\n",
477: (int) getpid(),
478: (int) (*(*((struct_processus_fils *)
479: (*(*l_element_courant).donnee).objet)).thread)
480: .pid);
481: }
482: else
483: {
484: printf("[%d] Send stop signal to process %d\n",
485: (int) getpid(),
486: (int) (*(*((struct_processus_fils *)
487: (*(*l_element_courant).donnee).objet)).thread)
488: .pid);
489: }
490: }
491: }
492:
493: if ((*s_etat_processus).var_volatile_alarme != 0)
494: {
495: kill((*(*((struct_processus_fils *) (*(*l_element_courant)
496: .donnee).objet)).thread).pid, SIGURG);
497: }
498: else
499: {
1.14 bertrand 500: if ((*s_etat_processus).arret_depuis_abort == -1)
501: {
502: kill((*(*((struct_processus_fils *) (*(*l_element_courant)
503: .donnee).objet)).thread).pid, SIGFABORT);
504: }
505: else
506: {
507: kill((*(*((struct_processus_fils *) (*(*l_element_courant)
508: .donnee).objet)).thread).pid, SIGFSTOP);
509: }
1.1 bertrand 510: }
511: }
512: else
513: {
514: if ((*s_etat_processus).debug == d_vrai)
515: {
516: if (((*s_etat_processus).type_debug & d_debug_processus) != 0)
517: {
518: if ((*s_etat_processus).langue == 'F')
519: {
520: printf("[%d] Signalement pour arrêt du thread %llu\n",
521: (int) getpid(), (unsigned long long)
522: (*(*((struct_processus_fils *)
523: (*(*l_element_courant).donnee).objet)).thread)
524: .tid);
525: }
526: else
527: {
528: printf("[%d] Send stop signal to thread %llu\n",
529: (int) getpid(), (unsigned long long)
530: (*(*((struct_processus_fils *)
531: (*(*l_element_courant).donnee).objet)).thread)
532: .tid);
533: }
534: }
535: }
536:
537: if ((*s_etat_processus).var_volatile_alarme != 0)
538: {
539: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
540: (*(*l_element_courant).donnee).objet)).thread).mutex))
541: != 0)
542: {
543: pthread_mutex_unlock(&((*s_etat_processus).mutex));
544: (*s_etat_processus).erreur_systeme = d_es_processus;
545:
546: pthread_mutex_lock(&((*s_argument_thread).mutex));
547: pthread_mutex_unlock(&((*s_argument_thread).mutex));
548:
549: (*s_argument_thread).thread_actif = d_faux;
550:
551: pthread_exit(NULL);
552: }
553:
554: if ((*(*((struct_processus_fils *)
555: (*(*l_element_courant).donnee).objet)).thread)
556: .thread_actif == d_vrai)
557: {
558: pthread_kill((*(*((struct_processus_fils *)
559: (*(*l_element_courant).donnee).objet)).thread).tid,
560: SIGURG);
561: }
562:
563: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
564: (*(*l_element_courant).donnee).objet)).thread)
565: .mutex)) != 0)
566: {
567: pthread_mutex_unlock(&((*s_etat_processus).mutex));
568: (*s_etat_processus).erreur_systeme = d_es_processus;
569:
570: pthread_mutex_lock(&((*s_argument_thread).mutex));
571: pthread_mutex_unlock(&((*s_argument_thread).mutex));
572:
573: (*s_argument_thread).thread_actif = d_faux;
574:
575: pthread_exit(NULL);
576: }
577: }
578: else
579: {
580: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
581: (*(*l_element_courant).donnee).objet)).thread).mutex))
582: != 0)
583: {
584: pthread_mutex_unlock(&((*s_etat_processus).mutex));
585: (*s_etat_processus).erreur_systeme = d_es_processus;
586:
587: pthread_mutex_lock(&((*s_argument_thread).mutex));
588: pthread_mutex_unlock(&((*s_argument_thread).mutex));
589:
590: (*s_argument_thread).thread_actif = d_faux;
591:
592: pthread_exit(NULL);
593: }
594:
595: if ((*(*((struct_processus_fils *)
596: (*(*l_element_courant).donnee).objet)).thread)
597: .thread_actif == d_vrai)
598: {
1.14 bertrand 599: if ((*s_etat_processus).arret_depuis_abort == -1)
600: {
601: pthread_kill((*(*((struct_processus_fils *)
602: (*(*l_element_courant).donnee).objet)).thread)
603: .tid, SIGFABORT);
604: }
605: else
606: {
607: pthread_kill((*(*((struct_processus_fils *)
608: (*(*l_element_courant).donnee).objet)).thread)
609: .tid, SIGFSTOP);
610: }
1.1 bertrand 611: }
612:
613: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
614: (*(*l_element_courant).donnee).objet)).thread).mutex))
615: != 0)
616: {
617: pthread_mutex_unlock(&((*s_etat_processus).mutex));
618: (*s_etat_processus).erreur_systeme = d_es_processus;
619:
620: pthread_mutex_lock(&((*s_argument_thread).mutex));
621: pthread_mutex_unlock(&((*s_argument_thread).mutex));
622:
623: (*s_argument_thread).thread_actif = d_faux;
624:
625: pthread_exit(NULL);
626: }
627: }
628: }
629:
630: l_element_courant = (*l_element_courant).suivant;
631: }
632:
633: /*
634: * Attente de la fin de tous les processus fils
635: */
636:
637: for(i = 0; i < d_NOMBRE_INTERRUPTIONS;
638: (*s_etat_processus).masque_interruptions[i++] = 'I');
639:
640: attente.tv_sec = 0;
641: attente.tv_nsec = GRANULARITE_us * 1000;
642:
643: while((*s_etat_processus).l_base_pile_processus != NULL)
644: {
645: status = 0;
646:
647: l_element_courant = (struct_liste_chainee *)
648: (*s_etat_processus).l_base_pile_processus;
649:
650: registre_stop = (*s_etat_processus)
651: .var_volatile_traitement_retarde_stop;
652: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
653:
654: for(i = 0; i < (unsigned long) (*(*((struct_processus_fils *)
655: (*(*l_element_courant).donnee).objet)).thread)
656: .nombre_objets_dans_pipe; i++)
657: {
658: if ((s_objet_temporaire = lecture_pipe(s_etat_processus,
659: (*(*((struct_processus_fils *) (*(*l_element_courant)
660: .donnee).objet)).thread).pipe_objets[0])) != NULL)
661: {
662: liberation(s_etat_processus, s_objet_temporaire);
663:
664: (*(*((struct_processus_fils *) (*(*l_element_courant)
665: .donnee).objet)).thread).nombre_objets_dans_pipe--;
666:
667: action.sa_handler = SIG_IGN;
668: action.sa_flags = SA_ONSTACK;
669:
670: if (sigaction(SIGPIPE, &action, ®istre) != 0)
671: {
672: pthread_mutex_unlock(&((*s_etat_processus).mutex));
673:
674: if (registre_stop == 0)
675: {
676: if ((*s_etat_processus)
677: .var_volatile_traitement_retarde_stop
678: == -1)
679: {
680: (*s_etat_processus)
681: .var_volatile_requete_arret = -1;
682: }
683:
684: (*s_etat_processus)
685: .var_volatile_traitement_retarde_stop =
686: registre_stop;
687: }
688:
689: (*s_etat_processus).erreur_systeme = d_es_signal;
690: exit(EXIT_FAILURE);
691: }
692:
693: while((longueur_ecriture = write_atomic(
694: s_etat_processus, (*(*((struct_processus_fils *)
695: (*(*l_element_courant).donnee).objet)).thread)
696: .pipe_nombre_injections[1], "+",
697: sizeof(unsigned char))) !=
698: sizeof(unsigned char))
699: {
700: if (longueur_ecriture == -1)
701: {
702: // Le processus n'existe plus.
703: break;
704: }
705: }
706:
707: if (registre_stop == 0)
708: {
709: if ((*s_etat_processus)
710: .var_volatile_traitement_retarde_stop == -1)
711: {
712: (*s_etat_processus).var_volatile_requete_arret
713: = -1;
714: }
715:
716: (*s_etat_processus)
717: .var_volatile_traitement_retarde_stop =
718: registre_stop;
719: }
720:
721: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
722: {
723: pthread_mutex_unlock(&((*s_etat_processus).mutex));
724:
725: (*s_etat_processus).erreur_systeme = d_es_signal;
726: exit(EXIT_FAILURE);
727: }
728: }
729: }
730:
731: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
732: .donnee).objet)).thread).processus_detache == d_vrai)
733: {
734: if (waitpid((*(*((struct_processus_fils *)
735: (*(*l_element_courant).donnee).objet)).thread).pid,
736: &status, WNOHANG) < 0)
737: {
738: }
739: }
740:
741: pthread_mutex_unlock(&((*s_etat_processus).mutex));
1.15 bertrand 742:
743: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
744: {
745: affectation_interruptions_logicielles(s_etat_processus);
746: }
747:
1.1 bertrand 748: nanosleep(&attente, NULL);
749: pthread_mutex_lock(&((*s_etat_processus).mutex));
750: }
751:
752: pthread_mutex_unlock(&((*s_etat_processus).mutex));
753:
754: l_element_courant = (*s_etat_processus).s_sockets;
755:
756: while(l_element_courant != NULL)
757: {
758: l_element_suivant = (*l_element_courant).suivant;
759:
760: /*
761: * Fermeture des sockets créées dans le processus courant.
762: */
763:
764: if (((*((struct_socket *) (*(*l_element_courant).donnee).objet))
765: .pid == getpid()) && (pthread_equal((*((struct_socket *)
766: (*(*l_element_courant).donnee).objet)).tid, pthread_self())
767: != 0))
768: {
769: if ((*((struct_socket *) (*(*l_element_courant).donnee).objet))
770: .socket_connectee == d_vrai)
771: {
772: shutdown((*((struct_socket *) (*(*l_element_courant).donnee)
773: .objet)).socket, SHUT_RDWR);
774: }
775:
776: close((*((struct_socket *) (*(*l_element_courant).donnee).objet))
777: .socket);
778:
779: if ((*((struct_socket *) (*(*l_element_courant).donnee).objet))
780: .effacement == 'Y')
781: {
782: unlink((*((struct_socket *) (*(*l_element_courant).donnee)
783: .objet)).adresse);
784: }
785: }
786:
787: liberation(s_etat_processus, (*((struct_liste_chainee *)
788: l_element_courant)).donnee);
789: free(l_element_courant);
790:
791: l_element_courant = l_element_suivant;
792: }
793:
794: l_element_courant = (*s_etat_processus).s_connecteurs_sql;
795:
796: while(l_element_courant != NULL)
797: {
798: l_element_suivant = (*l_element_courant).suivant;
799:
800: /*
801: * Fermeture des connecteurs créés dans le processus courant.
802: */
803:
804: if (((*((struct_socket *) (*(*l_element_courant).donnee).objet))
805: .pid == getpid()) && (pthread_equal((*((struct_socket *)
806: (*(*l_element_courant).donnee).objet)).tid, pthread_self())
807: != 0))
808: {
809: sqlclose((*l_element_courant).donnee);
810: }
811:
812: liberation(s_etat_processus, (*((struct_liste_chainee *)
813: l_element_courant)).donnee);
814: free(l_element_courant);
815:
816: l_element_courant = l_element_suivant;
817: }
818:
819: if ((((*s_etat_processus).erreur_execution != d_ex) ||
820: ((*s_etat_processus).exception != d_ep) ||
821: ((*s_etat_processus).erreur_systeme != d_es)) &&
822: ((*s_etat_processus).var_volatile_traitement_sigint == 0))
823: {
824: printf("%s [%d]\n", message =
825: messages(s_etat_processus), (int) getpid());
826: free(message);
827:
828: if ((*s_etat_processus).core == d_vrai)
829: {
830: printf("\n");
831:
832: if ((*s_etat_processus).langue == 'F')
833: {
834: printf("+++Information : Génération du fichier rpl-core "
835: "[%d]\n", (int) getpid());
836: }
837: else
838: {
839: printf("+++Information : Writing rpl-core file [%d]\n",
840: (int) getpid());
841: }
842:
843: rplcore(s_etat_processus);
844:
845: if ((*s_etat_processus).langue == 'F')
846: {
847: printf("+++Information : Processus tracé [%d]\n",
848: (int) getpid());
849: }
850: else
851: {
852: printf("+++Information : Done [%d]\n", (int) getpid());
853: }
854:
855: printf("\n");
856: fflush(stdout);
857: }
858: }
859:
860: if ((*s_etat_processus).entree_standard != NULL)
861: {
862: pclose((*s_etat_processus).entree_standard);
863: (*s_etat_processus).entree_standard = NULL;
864: }
865:
866: if ((*s_etat_processus).fichiers_graphiques != NULL)
867: {
868: instruction_cllcd(s_etat_processus);
869: }
870:
871: liberation(s_etat_processus, (*s_etat_processus).indep);
872: liberation(s_etat_processus, (*s_etat_processus).depend);
873:
874: free((*s_etat_processus).label_x);
875: free((*s_etat_processus).label_y);
876: free((*s_etat_processus).label_z);
877: free((*s_etat_processus).titre);
878: free((*s_etat_processus).legende);
879:
880: liberation(s_etat_processus,
881: (*s_etat_processus).parametres_courbes_de_niveau);
882:
883: if ((*s_etat_processus).instruction_derniere_erreur != NULL)
884: {
885: free((*s_etat_processus).instruction_derniere_erreur);
886: (*s_etat_processus).instruction_derniere_erreur = NULL;
887: }
888:
1.35 bertrand 889: liberation_arbre_variables(s_etat_processus,
890: (*s_etat_processus).s_arbre_variables, d_faux);
1.1 bertrand 891:
892: for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
893: {
894: liberation(s_etat_processus,
895: (*s_etat_processus).s_liste_variables_statiques[i].objet);
896: free((*s_etat_processus).s_liste_variables_statiques[i].nom);
897: }
898:
899: free((*s_etat_processus).s_liste_variables_statiques);
900:
901: l_element_courant = (*s_etat_processus).l_base_pile;
902: while(l_element_courant != NULL)
903: {
904: l_element_suivant = (*l_element_courant).suivant;
905:
906: liberation(s_etat_processus, (*l_element_courant).donnee);
907: free(l_element_courant);
908:
909: l_element_courant = l_element_suivant;
910: }
911:
912: l_element_courant = (*s_etat_processus).l_base_pile_last;
913: while(l_element_courant != NULL)
914: {
915: l_element_suivant = (*l_element_courant).suivant;
916:
917: liberation(s_etat_processus, (*l_element_courant).donnee);
918: free(l_element_courant);
919:
920: l_element_courant = l_element_suivant;
921: }
922:
923: l_element_courant = (*s_etat_processus).l_base_pile_contextes;
924: while(l_element_courant != NULL)
925: {
926: l_element_suivant = (*l_element_courant).suivant;
927:
928: liberation(s_etat_processus, (*l_element_courant).donnee);
929: free(l_element_courant);
930:
931: l_element_courant = l_element_suivant;
932: }
933:
934: l_element_courant = (*s_etat_processus).l_base_pile_taille_contextes;
935: while(l_element_courant != NULL)
936: {
937: l_element_suivant = (*l_element_courant).suivant;
938:
939: liberation(s_etat_processus, (*l_element_courant).donnee);
940: free(l_element_courant);
941:
942: l_element_courant = l_element_suivant;
943: }
944:
945: l_element_courant = (struct_liste_chainee *)
946: (*s_etat_processus).l_base_pile_systeme;
947: while(l_element_courant != NULL)
948: {
949: l_element_suivant = (struct_liste_chainee *)
950: (*((struct_liste_pile_systeme *)
951: l_element_courant)).suivant;
952:
953: liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
954: l_element_courant)).indice_boucle);
955: liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
956: l_element_courant)).limite_indice_boucle);
957: liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
958: l_element_courant)).objet_de_test);
959:
960: if ((*((struct_liste_pile_systeme *)
961: l_element_courant)).nom_variable != NULL)
962: {
963: free((*((struct_liste_pile_systeme *)
964: l_element_courant)).nom_variable);
965: }
966:
967: free((struct_liste_pile_systeme *) l_element_courant);
968:
969: l_element_courant = l_element_suivant;
970: }
971:
972: l_element_courant = (*s_etat_processus).s_bibliotheques;
973:
974: while(l_element_courant != NULL)
975: {
976: l_element_suivant = (*l_element_courant).suivant;
977:
978: free((*((struct_bibliotheque *) (*l_element_courant).donnee)).nom);
979:
980: if (((*((struct_bibliotheque *) (*l_element_courant).donnee)).pid
981: == getpid()) && (pthread_equal((*((struct_bibliotheque *)
982: (*l_element_courant).donnee)).tid, pthread_self()) != 0))
983: {
984: dlclose((*((struct_bibliotheque *) (*l_element_courant).donnee))
985: .descripteur);
986: }
987:
988: free((*l_element_courant).donnee);
989: free(l_element_courant);
990:
991: l_element_courant = l_element_suivant;
992: }
993:
994: for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++)
995: {
996: free((*s_etat_processus).s_instructions_externes[i].nom);
997: free((*s_etat_processus).s_instructions_externes[i]
998: .nom_bibliotheque);
999: }
1000:
1001: if ((*s_etat_processus).nombre_instructions_externes != 0)
1002: {
1003: free((*s_etat_processus).s_instructions_externes);
1004: }
1005:
1006: if ((*s_etat_processus).debug == d_vrai)
1007: if (((*s_etat_processus).type_debug & d_debug_processus) != 0)
1008: {
1009: if ((*s_etat_processus).langue == 'F')
1010: {
1011: printf("[%d] Fin du thread %llu\n", (int) getpid(),
1012: (unsigned long long) pthread_self());
1013: }
1014: else
1015: {
1016: printf("[%d] End of thread %llu\n", (int) getpid(),
1017: (unsigned long long) pthread_self());
1018: }
1019:
1020: fflush(stdout);
1021: }
1022:
1023: liberation(s_etat_processus, (*s_argument_thread).argument);
1.11 bertrand 1024: liberation(s_etat_processus, (*s_etat_processus).at_exit);
1.25 bertrand 1025: liberation(s_etat_processus, (*s_etat_processus).at_poke);
1.1 bertrand 1026:
1027: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
1028: {
1029: liberation(s_etat_processus,
1030: (*s_etat_processus).corps_interruptions[i]);
1031:
1032: l_element_courant = (*s_etat_processus)
1033: .pile_origine_interruptions[i];
1034:
1035: while(l_element_courant != NULL)
1036: {
1037: l_element_suivant = (*l_element_courant).suivant;
1038:
1039: liberation(s_etat_processus, (*l_element_courant).donnee);
1040: free(l_element_courant);
1041:
1042: l_element_courant = l_element_suivant;
1043: }
1044: }
1045:
1046: l_element_courant = (struct_liste_chainee *) (*s_etat_processus).s_marques;
1047:
1048: while(l_element_courant != NULL)
1049: {
1050: free((*((struct_marque *) l_element_courant)).label);
1051: free((*((struct_marque *) l_element_courant)).position);
1052: l_element_suivant = (struct_liste_chainee *)
1053: (*((struct_marque *) l_element_courant)).suivant;
1054: free((struct_marque *) l_element_courant);
1055: l_element_courant = l_element_suivant;
1056: }
1057:
1058: if ((*s_etat_processus).generateur_aleatoire != NULL)
1059: {
1060: liberation_generateur_aleatoire(s_etat_processus);
1061: }
1062:
1063: if ((*s_etat_processus).profilage == d_vrai)
1064: {
1065: ecriture_profil(s_etat_processus);
1066: liberation_profil(s_etat_processus);
1067: }
1068:
1069: liberation_allocateur(s_etat_processus);
1070:
1071: retrait_thread(s_etat_processus);
1072: pthread_mutex_destroy(&((*s_etat_processus).mutex));
1.21 bertrand 1073: pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
1.1 bertrand 1074:
1.28 bertrand 1075: sem_destroy(&((*s_etat_processus).semaphore_fork));
1076:
1.45 bertrand 1077: liberation_contexte_cas(s_etat_processus);
1.1 bertrand 1078: free((*s_etat_processus).localisation);
1079: free(s_etat_processus);
1080:
1081: pthread_mutex_lock(&((*s_argument_thread).mutex));
1082: pthread_mutex_unlock(&((*s_argument_thread).mutex));
1083:
1084: (*s_argument_thread).thread_actif = d_faux;
1085: pthread_exit(NULL);
1.26 bertrand 1086: return(NULL);
1.1 bertrand 1087: }
1088:
1089: // 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