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