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