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