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