version 1.7, 2010/03/04 10:17:48
|
version 1.96, 2013/03/10 17:01:05
|
Line 1
|
Line 1
|
/* |
/* |
================================================================================ |
================================================================================ |
RPL/2 (R) version 4.0.12 |
RPL/2 (R) version 4.1.13 |
Copyright (C) 1989-2010 Dr. BERTRAND Joël |
Copyright (C) 1989-2013 Dr. BERTRAND Joël |
|
|
This file is part of RPL/2. |
This file is part of RPL/2. |
|
|
Line 20
|
Line 20
|
*/ |
*/ |
|
|
|
|
#include "rpl.conv.h" |
#include "rpl-conv.h" |
|
|
|
|
/* |
/* |
Line 57 decrementation_atomique(struct_objet *s_
|
Line 57 decrementation_atomique(struct_objet *s_
|
return((*s_objet).nombre_occurrences); |
return((*s_objet).nombre_occurrences); |
} |
} |
|
|
inline void |
void |
initialisation_objet(struct_objet *s_objet) |
initialisation_objet(struct_objet *s_objet) |
{ |
{ |
pthread_mutexattr_t attributs_mutex; |
pthread_mutexattr_t attributs_mutex; |
Line 111 initialisation_allocateur(struct_process
|
Line 111 initialisation_allocateur(struct_process
|
(*s_etat_processus).pointeur_vec = 0; |
(*s_etat_processus).pointeur_vec = 0; |
(*s_etat_processus).pointeur_maillons = 0; |
(*s_etat_processus).pointeur_maillons = 0; |
|
|
|
(*s_etat_processus).pointeur_variables_noeud = 0; |
|
(*s_etat_processus).pointeur_variables_partagees_noeud = 0; |
|
(*s_etat_processus).pointeur_variables_feuille = 0; |
|
(*s_etat_processus).pointeur_variables_variable = 0; |
|
(*s_etat_processus).pointeur_variables_tableau_noeuds = 0; |
|
(*s_etat_processus).pointeur_variables_tableau_noeuds_partages = 0; |
|
|
return; |
return; |
} |
} |
|
|
Line 143 liberation_allocateur(struct_processus *
|
Line 150 liberation_allocateur(struct_processus *
|
for(i = 0; i < (*s_etat_processus).pointeur_maillons; |
for(i = 0; i < (*s_etat_processus).pointeur_maillons; |
free((*s_etat_processus).maillons[i++])); |
free((*s_etat_processus).maillons[i++])); |
|
|
|
for(i = 0; i < (*s_etat_processus).pointeur_variables_noeud; |
|
free((*s_etat_processus).variables_noeud[i++])); |
|
for(i = 0; i < (*s_etat_processus).pointeur_variables_partagees_noeud; |
|
free((*s_etat_processus).variables_partagees_noeud[i++])); |
|
for(i = 0; i < (*s_etat_processus).pointeur_variables_feuille; |
|
free((*s_etat_processus).variables_feuille[i++])); |
|
for(i = 0; i < (*s_etat_processus).pointeur_variables_variable; |
|
free((*s_etat_processus).variables_variable[i++])); |
|
for(i = 0; i < (*s_etat_processus).pointeur_variables_tableau_noeuds; |
|
free((*s_etat_processus).variables_tableau_noeuds[i++])); |
|
for(i = 0; i < (*s_etat_processus) |
|
.pointeur_variables_tableau_noeuds_partages; |
|
free((*s_etat_processus).variables_tableau_noeuds_partages[i++])); |
|
|
{ |
{ |
struct_liste_chainee *l_element_courant; |
struct_liste_chainee *l_element_courant; |
struct_liste_chainee *l_element_suivant; |
struct_liste_chainee *l_element_suivant; |
Line 224 allocation_maillon(struct_processus *s_e
|
Line 245 allocation_maillon(struct_processus *s_e
|
{ |
{ |
if ((s_maillon = malloc(sizeof(struct_liste_chainee))) == NULL) |
if ((s_maillon = malloc(sizeof(struct_liste_chainee))) == NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(NULL); |
return(NULL); |
} |
} |
} |
} |
Line 234 allocation_maillon(struct_processus *s_e
|
Line 256 allocation_maillon(struct_processus *s_e
|
|
|
/* |
/* |
================================================================================ |
================================================================================ |
Routine d'allocation d'un maillon d'un objet (liste, expression...) |
Routine de libération d'un maillon d'un objet (liste, expression...) |
================================================================================ |
================================================================================ |
Entrées : structure sur l'état du processus et objet à afficher |
Entrées : structure sur l'état du processus et objet à afficher |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
Line 266 liberation_maillon(struct_processus *s_e
|
Line 288 liberation_maillon(struct_processus *s_e
|
================================================================================ |
================================================================================ |
Routine d'allocation d'une structure *s_objet |
Routine d'allocation d'une structure *s_objet |
================================================================================ |
================================================================================ |
Entrées : structure sur l'état du processus et objet à afficher |
Entrées : structure sur l'état du processus et objet à allouer |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
Sorties : chaine de caractères |
Sorties : chaine de caractères |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
Line 274 liberation_maillon(struct_processus *s_e
|
Line 296 liberation_maillon(struct_processus *s_e
|
================================================================================ |
================================================================================ |
*/ |
*/ |
|
|
void * |
struct_objet * |
allocation(struct_processus *s_etat_processus, enum t_type type) |
allocation(struct_processus *s_etat_processus, enum t_type type) |
{ |
{ |
struct_objet *s_objet; |
struct_objet *s_objet; |
|
|
|
if (pthread_mutex_lock(&((*s_etat_processus).mutex_allocation)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return(NULL); |
|
} |
|
|
if ((*s_etat_processus).pile_objets == NULL) |
if ((*s_etat_processus).pile_objets == NULL) |
{ |
{ |
|
if (pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return(NULL); |
|
} |
|
|
// Il n'existe aucune structure struct_objet disponible dans le cache. |
// Il n'existe aucune structure struct_objet disponible dans le cache. |
|
|
if ((s_objet = malloc(sizeof(struct_objet))) == NULL) |
if ((s_objet = malloc(sizeof(struct_objet))) == NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(NULL); |
return(NULL); |
} |
} |
|
|
Line 299 allocation(struct_processus *s_etat_proc
|
Line 334 allocation(struct_processus *s_etat_proc
|
(*s_etat_processus).taille_pile_objets--; |
(*s_etat_processus).taille_pile_objets--; |
|
|
(*s_objet).nombre_occurrences = 1; |
(*s_objet).nombre_occurrences = 1; |
|
|
|
if (pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return(NULL); |
|
} |
} |
} |
|
|
(*s_objet).type = type; |
(*s_objet).type = type; |
Line 316 allocation(struct_processus *s_etat_proc
|
Line 357 allocation(struct_processus *s_etat_proc
|
{ |
{ |
if (((*s_objet).objet = malloc(sizeof(unsigned long))) == NULL) |
if (((*s_objet).objet = malloc(sizeof(unsigned long))) == NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 341 allocation(struct_processus *s_etat_proc
|
Line 384 allocation(struct_processus *s_etat_proc
|
{ |
{ |
if (((*s_objet).objet = malloc(sizeof(logical8))) == NULL) |
if (((*s_objet).objet = malloc(sizeof(logical8))) == NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 367 allocation(struct_processus *s_etat_proc
|
Line 412 allocation(struct_processus *s_etat_proc
|
if (((*s_objet).objet = malloc(sizeof(struct_complexe16))) |
if (((*s_objet).objet = malloc(sizeof(struct_complexe16))) |
== NULL) |
== NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 379 allocation(struct_processus *s_etat_proc
|
Line 426 allocation(struct_processus *s_etat_proc
|
{ |
{ |
if (((*s_objet).objet = malloc(sizeof(struct_fichier))) == NULL) |
if (((*s_objet).objet = malloc(sizeof(struct_fichier))) == NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 398 allocation(struct_processus *s_etat_proc
|
Line 446 allocation(struct_processus *s_etat_proc
|
if (((*s_objet).objet = malloc(sizeof(struct_fonction))) |
if (((*s_objet).objet = malloc(sizeof(struct_fonction))) |
== NULL) |
== NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 421 allocation(struct_processus *s_etat_proc
|
Line 471 allocation(struct_processus *s_etat_proc
|
{ |
{ |
if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL) |
if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 446 allocation(struct_processus *s_etat_proc
|
Line 498 allocation(struct_processus *s_etat_proc
|
{ |
{ |
if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL) |
if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 469 allocation(struct_processus *s_etat_proc
|
Line 523 allocation(struct_processus *s_etat_proc
|
{ |
{ |
if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL) |
if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 492 allocation(struct_processus *s_etat_proc
|
Line 548 allocation(struct_processus *s_etat_proc
|
{ |
{ |
if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL) |
if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 508 allocation(struct_processus *s_etat_proc
|
Line 566 allocation(struct_processus *s_etat_proc
|
{ |
{ |
if (((*s_objet).objet = malloc(sizeof(struct_mutex))) == NULL) |
if (((*s_objet).objet = malloc(sizeof(struct_mutex))) == NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
|
|
|
(*((struct_mutex *) (*s_objet).objet)).tid = pthread_self(); |
break; |
break; |
} |
} |
|
|
Line 526 allocation(struct_processus *s_etat_proc
|
Line 586 allocation(struct_processus *s_etat_proc
|
{ |
{ |
if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL) |
if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 545 allocation(struct_processus *s_etat_proc
|
Line 607 allocation(struct_processus *s_etat_proc
|
if (((*s_objet).objet = malloc(sizeof(struct_processus_fils))) |
if (((*s_objet).objet = malloc(sizeof(struct_processus_fils))) |
== NULL) |
== NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 563 allocation(struct_processus *s_etat_proc
|
Line 626 allocation(struct_processus *s_etat_proc
|
{ |
{ |
if (((*s_objet).objet = malloc(sizeof(real8))) == NULL) |
if (((*s_objet).objet = malloc(sizeof(real8))) == NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 581 allocation(struct_processus *s_etat_proc
|
Line 646 allocation(struct_processus *s_etat_proc
|
{ |
{ |
if (((*s_objet).objet = malloc(sizeof(struct_socket))) == NULL) |
if (((*s_objet).objet = malloc(sizeof(struct_socket))) == NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 593 allocation(struct_processus *s_etat_proc
|
Line 659 allocation(struct_processus *s_etat_proc
|
if (((*s_objet).objet = malloc(sizeof(struct_bibliotheque))) |
if (((*s_objet).objet = malloc(sizeof(struct_bibliotheque))) |
== NULL) |
== NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 604 allocation(struct_processus *s_etat_proc
|
Line 671 allocation(struct_processus *s_etat_proc
|
{ |
{ |
if (((*s_objet).objet = malloc(sizeof(struct_semaphore))) == NULL) |
if (((*s_objet).objet = malloc(sizeof(struct_semaphore))) == NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 616 allocation(struct_processus *s_etat_proc
|
Line 684 allocation(struct_processus *s_etat_proc
|
if (((*s_objet).objet = malloc(sizeof(struct_connecteur_sql))) |
if (((*s_objet).objet = malloc(sizeof(struct_connecteur_sql))) |
== NULL) |
== NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 634 allocation(struct_processus *s_etat_proc
|
Line 703 allocation(struct_processus *s_etat_proc
|
{ |
{ |
if (((*s_objet).objet = malloc(sizeof(struct_tableau))) == NULL) |
if (((*s_objet).objet = malloc(sizeof(struct_tableau))) == NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 655 allocation(struct_processus *s_etat_proc
|
Line 726 allocation(struct_processus *s_etat_proc
|
{ |
{ |
if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL) |
if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 677 allocation(struct_processus *s_etat_proc
|
Line 750 allocation(struct_processus *s_etat_proc
|
{ |
{ |
if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL) |
if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 699 allocation(struct_processus *s_etat_proc
|
Line 774 allocation(struct_processus *s_etat_proc
|
{ |
{ |
if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL) |
if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL) |
{ |
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
free(s_objet); |
free(s_objet); |
return(NULL); |
return(NULL); |
} |
} |
Line 877 liberation(struct_processus *s_etat_proc
|
Line 954 liberation(struct_processus *s_etat_proc
|
{ |
{ |
if (decrementation_atomique(s_objet) > 0) |
if (decrementation_atomique(s_objet) > 0) |
{ |
{ |
|
BUG((*(*((struct_fichier *) (*s_objet).objet)).format) |
|
.nombre_occurrences <= 1, |
|
pthread_mutex_unlock(&((*s_objet).mutex)), |
|
printf("(*(*((struct_fichier *) (*s_objet).objet))" |
|
".format).nombre_occurrences=%ld\n", |
|
(*(*((struct_fichier *) (*s_objet).objet)).format) |
|
.nombre_occurrences)); |
|
|
|
liberation(s_etat_processus, |
|
(*((struct_fichier *) (*s_objet).objet)).format); |
return; |
return; |
} |
} |
|
|
liberation(s_etat_processus, |
liberation(s_etat_processus, |
(*((struct_fichier *) (*s_objet).objet)).format); |
(*((struct_fichier *) (*s_objet).objet)).format); |
|
|
free((unsigned char *) (*((struct_fichier *) |
free((unsigned char *) (*((struct_fichier *) |
(*s_objet).objet)).nom); |
(*s_objet).objet)).nom); |
free((struct_fichier *) ((*s_objet).objet)); |
free((struct_fichier *) ((*s_objet).objet)); |
Line 1062 liberation(struct_processus *s_etat_proc
|
Line 1148 liberation(struct_processus *s_etat_proc
|
return; |
return; |
} |
} |
|
|
|
if (pthread_mutex_trylock(&((*((struct_mutex *) |
|
(*s_objet).objet)).mutex)) == 0) |
|
{ |
|
// On a pu verrouiller le mutex. Il faut donc spécifier le tid. |
|
(*((struct_mutex *) (*s_objet).objet)).tid = pthread_self(); |
|
} |
|
|
|
if (pthread_equal(pthread_self(), |
|
(*((struct_mutex *) (*s_objet).objet)).tid) != 0) |
|
{ |
|
pthread_mutex_unlock(&((*((struct_mutex *) |
|
(*s_objet).objet)).mutex)); |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_mutex_acquis_autre_thread; |
|
return; |
|
} |
|
|
|
pthread_mutex_destroy(&((*((struct_mutex *) |
|
(*s_objet).objet)).mutex)); |
free((struct_mutex *) (*s_objet).objet); |
free((struct_mutex *) (*s_objet).objet); |
break; |
break; |
} |
} |
Line 1095 liberation(struct_processus *s_etat_proc
|
Line 1203 liberation(struct_processus *s_etat_proc
|
return; |
return; |
} |
} |
|
|
free(s_objet); |
|
break; |
break; |
} |
} |
|
|
case PRC : |
case PRC : |
{ |
{ |
if (pthread_mutex_lock(&((*(*((struct_processus_fils *) |
if (pthread_mutex_lock(&((*(*((struct_processus_fils *) |
(*s_objet).objet)).thread).mutex)) != 0) |
(*s_objet).objet)).thread).mutex_nombre_references)) != 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
Line 1112 liberation(struct_processus *s_etat_proc
|
Line 1219 liberation(struct_processus *s_etat_proc
|
.nombre_references--; |
.nombre_references--; |
|
|
BUG((*(*((struct_processus_fils *) (*s_objet).objet)).thread) |
BUG((*(*((struct_processus_fils *) (*s_objet).objet)).thread) |
.nombre_references < 0, printf("(*(*((struct_processus_fils" |
.nombre_references < 0, uprintf( |
|
"(*(*((struct_processus_fils" |
" *) (*s_objet).objet)).thread).nombre_references = %d\n", |
" *) (*s_objet).objet)).thread).nombre_references = %d\n", |
(int) (*(*((struct_processus_fils *) (*s_objet).objet)) |
(int) (*(*((struct_processus_fils *) (*s_objet).objet)) |
.thread).nombre_references)); |
.thread).nombre_references)); |
Line 1128 liberation(struct_processus *s_etat_proc
|
Line 1236 liberation(struct_processus *s_etat_proc
|
} |
} |
|
|
if (pthread_mutex_unlock(&((*(*((struct_processus_fils *) |
if (pthread_mutex_unlock(&((*(*((struct_processus_fils *) |
(*s_objet).objet)).thread).mutex)) != 0) |
(*s_objet).objet)).thread).mutex_nombre_references)) != 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
Line 1138 liberation(struct_processus *s_etat_proc
|
Line 1246 liberation(struct_processus *s_etat_proc
|
{ |
{ |
pthread_mutex_destroy(&((*(*((struct_processus_fils *) |
pthread_mutex_destroy(&((*(*((struct_processus_fils *) |
(*s_objet).objet)).thread).mutex)); |
(*s_objet).objet)).thread).mutex)); |
|
pthread_mutex_destroy(&((*(*((struct_processus_fils *) |
|
(*s_objet).objet)).thread).mutex_nombre_references)); |
free((*((struct_processus_fils *) (*s_objet).objet)).thread); |
free((*((struct_processus_fils *) (*s_objet).objet)).thread); |
} |
} |
|
|
if (decrementation_atomique(s_objet) > 0) |
if (decrementation_atomique(s_objet) > 0) |
{ |
{ |
|
BUG(drapeau == d_vrai, uprintf("(*(*((struct_processus_fils" |
|
" *) (*s_objet).objet)).thread).nombre_references " |
|
"= 0 with nombre_occurrences > 0\n")); |
return; |
return; |
} |
} |
|
|
Line 1208 liberation(struct_processus *s_etat_proc
|
Line 1321 liberation(struct_processus *s_etat_proc
|
{ |
{ |
if (decrementation_atomique(s_objet) > 0) |
if (decrementation_atomique(s_objet) > 0) |
{ |
{ |
|
BUG((*(*((struct_socket *) (*s_objet).objet)).format) |
|
.nombre_occurrences <= 1, |
|
pthread_mutex_unlock(&((*s_objet).mutex)), |
|
printf("(*(*((struct_socket *) (*s_objet).objet))" |
|
".format).nombre_occurrences=%ld\n", |
|
(*(*((struct_socket *) (*s_objet).objet)).format) |
|
.nombre_occurrences)); |
|
|
|
liberation(s_etat_processus, (*((struct_socket *) |
|
(*s_objet).objet)).format); |
return; |
return; |
} |
} |
|
|
liberation(s_etat_processus, (*((struct_socket *) |
liberation(s_etat_processus, (*((struct_socket *) |
(*s_objet).objet)).format); |
(*s_objet).objet)).format); |
|
|
free((unsigned char *) (*((struct_socket *) (*s_objet).objet)) |
free((unsigned char *) (*((struct_socket *) (*s_objet).objet)) |
.adresse); |
.adresse); |
free((unsigned char *) (*((struct_socket *) (*s_objet).objet)) |
free((unsigned char *) (*((struct_socket *) (*s_objet).objet)) |
Line 1396 liberation(struct_processus *s_etat_proc
|
Line 1520 liberation(struct_processus *s_etat_proc
|
return; |
return; |
} |
} |
|
|
if (s_etat_processus != NULL) |
if (pthread_mutex_lock(&((*s_etat_processus).mutex_allocation)) != 0) |
{ |
{ |
if ((*s_etat_processus).taille_pile_objets < TAILLE_CACHE) |
(*s_etat_processus).erreur_systeme = d_es_processus; |
{ |
return; |
(*s_objet).objet = (*s_etat_processus).pile_objets; |
} |
(*s_etat_processus).pile_objets = s_objet; |
|
(*s_etat_processus).taille_pile_objets++; |
|
} |
|
else |
|
{ |
|
if (pthread_mutex_destroy(&((*s_objet).mutex)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
|
|
free(s_objet); |
if ((*s_etat_processus).taille_pile_objets < TAILLE_CACHE) |
} |
{ |
|
(*s_objet).objet = (*s_etat_processus).pile_objets; |
|
(*s_etat_processus).pile_objets = s_objet; |
|
(*s_etat_processus).taille_pile_objets++; |
} |
} |
else |
else |
{ |
{ |
|
if (pthread_mutex_destroy(&((*s_objet).mutex)) != 0) |
|
{ |
|
pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation)); |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
|
free(s_objet); |
free(s_objet); |
} |
} |
|
|
|
if (pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
|
return; |
return; |
} |
} |
|
|
Line 1749 copie_objet(struct_processus *s_etat_pro
|
Line 1879 copie_objet(struct_processus *s_etat_pro
|
if (type == 'P') |
if (type == 'P') |
{ |
{ |
incrementation_atomique(s_objet); |
incrementation_atomique(s_objet); |
|
|
|
if (((*((struct_fichier *) ((*s_objet).objet))).format = |
|
copie_objet(s_etat_processus, (*((struct_fichier *) |
|
((*s_objet).objet))).format, 'P')) == NULL) |
|
{ |
|
return(NULL); |
|
} |
|
|
return(s_objet); |
return(s_objet); |
} |
} |
|
|
Line 2145 copie_objet(struct_processus *s_etat_pro
|
Line 2283 copie_objet(struct_processus *s_etat_pro
|
|
|
case MTX : |
case MTX : |
{ |
{ |
if (type != 'O') |
// La duplication d'un mutex renvoie le même objet. |
{ |
incrementation_atomique(s_objet); |
incrementation_atomique(s_objet); |
return(s_objet); |
return(s_objet); |
|
} |
|
|
|
if ((s_nouvel_objet = allocation(s_etat_processus, MTX)) == NULL) |
|
{ |
|
return(NULL); |
|
} |
|
|
|
(*((struct_mutex *) ((*s_nouvel_objet).objet))).mutex = |
|
(*((struct_mutex *) ((*s_objet).objet))).mutex; |
|
break; |
|
} |
} |
|
|
case NOM : |
case NOM : |
Line 2200 copie_objet(struct_processus *s_etat_pro
|
Line 2327 copie_objet(struct_processus *s_etat_pro
|
return(s_objet); |
return(s_objet); |
} |
} |
|
|
|
// Un objet de type NON est un objet encapsulé dans une |
|
// structure de type struct_objet. Elle peut très bien contenir |
|
// une donnée, mais c'est à l'utilisateur de la libérer |
|
// explicitement avec un free(). |
|
|
if ((s_nouvel_objet = allocation(s_etat_processus, NON)) == NULL) |
if ((s_nouvel_objet = allocation(s_etat_processus, NON)) == NULL) |
{ |
{ |
return(NULL); |
return(NULL); |
} |
} |
|
|
(*s_nouvel_objet).objet = NULL; |
(*s_nouvel_objet).objet = (*s_objet).objet; |
break; |
break; |
} |
} |
|
|
case PRC : |
case PRC : |
{ |
{ |
if (pthread_mutex_lock(&((*(*((struct_processus_fils *) |
if (pthread_mutex_lock(&((*(*((struct_processus_fils *) |
(*s_objet).objet)).thread).mutex)) != 0) |
(*s_objet).objet)).thread).mutex_nombre_references)) != 0) |
{ |
{ |
return(NULL); |
return(NULL); |
} |
} |
Line 2221 copie_objet(struct_processus *s_etat_pro
|
Line 2353 copie_objet(struct_processus *s_etat_pro
|
.nombre_references++; |
.nombre_references++; |
|
|
if (pthread_mutex_unlock(&((*(*((struct_processus_fils *) |
if (pthread_mutex_unlock(&((*(*((struct_processus_fils *) |
(*s_objet).objet)).thread).mutex)) != 0) |
(*s_objet).objet)).thread).mutex_nombre_references)) != 0) |
{ |
{ |
return(NULL); |
return(NULL); |
} |
} |
Line 2265 copie_objet(struct_processus *s_etat_pro
|
Line 2397 copie_objet(struct_processus *s_etat_pro
|
if (type == 'P') |
if (type == 'P') |
{ |
{ |
incrementation_atomique(s_objet); |
incrementation_atomique(s_objet); |
|
|
|
if (((*((struct_socket *) ((*s_objet).objet))) |
|
.format = copie_objet(s_etat_processus, |
|
(*((struct_socket *) ((*s_objet).objet))).format, 'P')) |
|
== NULL) |
|
{ |
|
return(NULL); |
|
} |
|
|
return(s_objet); |
return(s_objet); |
} |
} |
|
|
Line 2404 copie_objet(struct_processus *s_etat_pro
|
Line 2545 copie_objet(struct_processus *s_etat_pro
|
return(NULL); |
return(NULL); |
} |
} |
|
|
|
(*((struct_semaphore *) (*s_nouvel_objet).objet)).semaphore = |
|
(*((struct_semaphore *) (*s_objet).objet)).semaphore; |
strcpy((*((struct_semaphore *) (*s_nouvel_objet).objet)).nom, |
strcpy((*((struct_semaphore *) (*s_nouvel_objet).objet)).nom, |
(*((struct_semaphore *) (*s_objet).objet)).nom); |
(*((struct_semaphore *) (*s_objet).objet)).nom); |
break; |
break; |
Line 2721 copie_etat_processus(struct_processus *s
|
Line 2864 copie_etat_processus(struct_processus *s
|
* n'ont aucune raison de changer. |
* n'ont aucune raison de changer. |
*/ |
*/ |
|
|
sem_init(&((*s_nouvel_etat_processus).semaphore_fork), 0, 0); |
pthread_mutexattr_init(&attributs_mutex); |
|
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); |
|
(*s_nouvel_etat_processus).sections_critiques = 0; |
|
|
|
// Les sémaphores sont initialisés dans le nouveau thread. Il |
|
// s'agit d'une limitation de l'implantation de l'émulation |
|
// de sem_init(). |
|
|
|
initialisation_contexte_cas(s_etat_processus); |
|
|
(*s_nouvel_etat_processus).var_volatile_processus_pere = 0; |
(*s_nouvel_etat_processus).var_volatile_processus_pere = 0; |
|
(*s_nouvel_etat_processus).var_volatile_processus_racine = 0; |
(*s_nouvel_etat_processus).fichiers_graphiques = NULL; |
(*s_nouvel_etat_processus).fichiers_graphiques = NULL; |
(*s_nouvel_etat_processus).entree_standard = NULL; |
(*s_nouvel_etat_processus).entree_standard = NULL; |
(*s_nouvel_etat_processus).s_marques = NULL; |
(*s_nouvel_etat_processus).s_marques = NULL; |
Line 2753 copie_etat_processus(struct_processus *s
|
Line 2905 copie_etat_processus(struct_processus *s
|
(*s_nouvel_etat_processus).nombre_interruptions_en_queue = 0; |
(*s_nouvel_etat_processus).nombre_interruptions_en_queue = 0; |
(*s_nouvel_etat_processus).nombre_interruptions_non_affectees = 0; |
(*s_nouvel_etat_processus).nombre_interruptions_non_affectees = 0; |
|
|
|
(*s_nouvel_etat_processus).at_exit = NULL; |
|
(*s_nouvel_etat_processus).at_poke = NULL; |
|
(*s_nouvel_etat_processus).traitement_at_poke = 'N'; |
|
|
for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++) |
for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++) |
{ |
{ |
(*s_nouvel_etat_processus).corps_interruptions[i] = NULL; |
(*s_nouvel_etat_processus).corps_interruptions[i] = NULL; |
Line 2763 copie_etat_processus(struct_processus *s
|
Line 2919 copie_etat_processus(struct_processus *s
|
|
|
if ((*s_nouvel_etat_processus).generateur_aleatoire != NULL) |
if ((*s_nouvel_etat_processus).generateur_aleatoire != NULL) |
{ |
{ |
(*s_nouvel_etat_processus).generateur_aleatoire = NULL; |
if (((*s_nouvel_etat_processus).generateur_aleatoire = |
} |
gsl_rng_clone((*s_etat_processus).generateur_aleatoire)) |
|
== NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
(*s_nouvel_etat_processus).type_generateur_aleatoire = NULL; |
gsl_rng_set((*s_nouvel_etat_processus).generateur_aleatoire, |
|
gsl_rng_get((*s_etat_processus).generateur_aleatoire)); |
|
} |
|
|
// Copie de la localisation |
// Copie de la localisation |
|
|
Line 2993 copie_etat_processus(struct_processus *s
|
Line 3156 copie_etat_processus(struct_processus *s
|
* Copie de la table des variables |
* Copie de la table des variables |
*/ |
*/ |
|
|
if (((*s_nouvel_etat_processus).s_liste_variables = |
(*s_nouvel_etat_processus).l_liste_variables_statiques = NULL; |
malloc((*s_etat_processus).nombre_variables_allouees * |
copie_arbre_variables(s_etat_processus, s_nouvel_etat_processus); |
sizeof(struct_variable))) == NULL) |
|
{ |
|
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return(NULL); |
|
} |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
for(i = 0; i < (*s_etat_processus).nombre_variables; i++) |
if ((*s_nouvel_etat_processus).erreur_systeme != d_es) |
{ |
|
if (((*s_nouvel_etat_processus).s_liste_variables[i].nom = |
|
malloc((strlen((*s_etat_processus).s_liste_variables[i].nom) |
|
+ 1) * sizeof(unsigned char))) == NULL) |
|
{ |
|
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return(NULL); |
|
} |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
strcpy((*s_nouvel_etat_processus).s_liste_variables[i].nom, |
|
(*s_etat_processus).s_liste_variables[i].nom); |
|
|
|
(*s_nouvel_etat_processus).s_liste_variables[i].origine = |
|
(*s_etat_processus).s_liste_variables[i].origine; |
|
(*s_nouvel_etat_processus).s_liste_variables[i].niveau = |
|
(*s_etat_processus).s_liste_variables[i].niveau; |
|
(*s_nouvel_etat_processus).s_liste_variables[i].variable_statique = |
|
(*s_etat_processus).s_liste_variables[i].variable_statique; |
|
(*s_nouvel_etat_processus).s_liste_variables[i].variable_verrouillee = |
|
(*s_etat_processus).s_liste_variables[i].variable_verrouillee; |
|
|
|
// Les définitions sont partagées entre tous les threads. |
|
|
|
if ((*s_etat_processus).s_liste_variables[i].niveau == 0) |
|
{ |
|
(*s_nouvel_etat_processus).s_liste_variables[i].objet = |
|
(*s_etat_processus).s_liste_variables[i].objet; |
|
} |
|
else |
|
{ |
|
if (((*s_nouvel_etat_processus).s_liste_variables[i].objet = |
|
copie_objet(s_etat_processus, |
|
(*s_etat_processus).s_liste_variables[i] |
|
.objet, 'P')) == NULL) |
|
{ |
|
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return(NULL); |
|
} |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
} |
|
} |
|
|
|
/* |
|
* Copie de la table des variables statiques |
|
*/ |
|
|
|
if (((*s_nouvel_etat_processus).s_liste_variables_statiques = |
|
malloc((*s_etat_processus).nombre_variables_statiques_allouees * |
|
sizeof(struct_variable_statique))) == NULL) |
|
{ |
{ |
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return(NULL); |
|
} |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(NULL); |
return(NULL); |
} |
} |
|
|
for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++) |
(*(*s_nouvel_etat_processus).l_liste_variables_partagees) = |
{ |
(*(*s_etat_processus).l_liste_variables_partagees); |
if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom = |
(*(*s_nouvel_etat_processus).s_arbre_variables_partagees) = |
malloc((strlen((*s_etat_processus).s_liste_variables_statiques |
(*(*s_etat_processus).s_arbre_variables_partagees); |
[i].nom) + 1) * sizeof(unsigned char))) == NULL) |
|
{ |
|
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return(NULL); |
|
} |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
strcpy((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom, |
|
(*s_etat_processus).s_liste_variables_statiques[i].nom); |
|
|
|
(*s_nouvel_etat_processus).s_liste_variables_statiques[i].origine = |
|
(*s_etat_processus).s_liste_variables_statiques[i].origine; |
|
(*s_nouvel_etat_processus).s_liste_variables_statiques[i].niveau = |
|
(*s_etat_processus).s_liste_variables_statiques[i].niveau; |
|
(*s_nouvel_etat_processus).s_liste_variables_statiques[i] |
|
.variable_statique = (*s_etat_processus) |
|
.s_liste_variables_statiques[i].variable_statique; |
|
|
|
if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].objet = |
|
copie_objet(s_etat_processus, (*s_etat_processus) |
|
.s_liste_variables_statiques[i].objet, 'P')) == NULL) |
|
{ |
|
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return(NULL); |
|
} |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
} |
|
|
|
/* |
/* |
* Copie de la pile opérationnelle |
* Copie de la pile opérationnelle |
Line 3228 copie_etat_processus(struct_processus *s
|
Line 3276 copie_etat_processus(struct_processus *s
|
* Copie des différents contextes |
* Copie des différents contextes |
*/ |
*/ |
|
|
|
(*s_nouvel_etat_processus).pointeur_signal_lecture = d_faux; |
|
(*s_nouvel_etat_processus).pointeur_signal_ecriture = d_faux; |
|
|
(*s_nouvel_etat_processus).l_base_pile_contextes = NULL; |
(*s_nouvel_etat_processus).l_base_pile_contextes = NULL; |
l_element_lecture = (*s_etat_processus).l_base_pile_contextes; |
l_element_lecture = (*s_etat_processus).l_base_pile_contextes; |
|
|
Line 3486 copie_etat_processus(struct_processus *s
|
Line 3537 copie_etat_processus(struct_processus *s
|
pthread_mutex_init(&((*s_nouvel_etat_processus).mutex), &attributs_mutex); |
pthread_mutex_init(&((*s_nouvel_etat_processus).mutex), &attributs_mutex); |
pthread_mutexattr_destroy(&attributs_mutex); |
pthread_mutexattr_destroy(&attributs_mutex); |
|
|
|
pthread_mutexattr_init(&attributs_mutex); |
|
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); |
|
pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_allocation), |
|
&attributs_mutex); |
|
pthread_mutexattr_destroy(&attributs_mutex); |
|
|
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) |
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
Line 3515 copie_etat_processus(struct_processus *s
|
Line 3572 copie_etat_processus(struct_processus *s
|
#undef malloc |
#undef malloc |
#undef realloc |
#undef realloc |
#undef free |
#undef free |
|
#undef fork |
|
|
#ifdef return |
#ifdef return |
# undef return |
# undef return |
#endif |
#endif |
|
|
#undef fprintf |
#ifdef __BACKTRACE |
|
#define PROFONDEUR_PILE 64 |
#define return(a) { if (a == NULL) \ |
#define return(a) { if (a == NULL) \ |
{ BACKTRACE(20); fprintf(stderr, ">>> MEDITATION %d\n", __LINE__); } \ |
{ BACKTRACE(PROFONDEUR_PILE); \ |
|
fprintf(stderr, ">>> MEDITATION %d\n", __LINE__); } \ |
return(a); } while(0) |
return(a); } while(0) |
|
#endif |
|
|
|
#undef fprintf |
|
#define check(a, b) ((strcmp(#a, fonction) == 0) && (ligne == b)) |
|
#undef CORE_DUMP |
|
|
typedef struct memoire |
typedef struct memoire |
{ |
{ |
Line 3534 typedef struct memoire
|
Line 3598 typedef struct memoire
|
unsigned long ligne; |
unsigned long ligne; |
size_t taille; |
size_t taille; |
unsigned long long ordre; |
unsigned long long ordre; |
|
# ifdef __BACKTRACE |
|
void *pile[PROFONDEUR_PILE]; |
|
int profondeur; |
|
# endif |
struct memoire *suivant; |
struct memoire *suivant; |
} struct_memoire; |
} struct_memoire; |
|
|
static struct_memoire *debug = NULL; |
static struct_memoire *debug = NULL; |
static unsigned long long ordre = 0; |
static unsigned long long ordre = 0; |
static pthread_mutex_t mutex_allocation = PTHREAD_MUTEX_INITIALIZER; |
static pthread_mutex_t mutex_allocation; |
|
|
#define check(a, b) ((strcmp(#a, fonction) == 0) && (ligne == b)) |
void |
|
debug_memoire_initialisation() |
|
{ |
|
pthread_mutexattr_t attributs_mutex; |
|
|
|
pthread_mutexattr_init(&attributs_mutex); |
|
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); |
|
pthread_mutex_init(&mutex_allocation, &attributs_mutex); |
|
pthread_mutexattr_destroy(&attributs_mutex); |
|
|
|
return; |
|
} |
|
|
void * |
void * |
debug_memoire_ajout(size_t taille, const unsigned char *fonction, |
debug_memoire_ajout(size_t taille, const unsigned char *fonction, |
Line 3549 debug_memoire_ajout(size_t taille, const
|
Line 3628 debug_memoire_ajout(size_t taille, const
|
{ |
{ |
struct_memoire *ancienne_base; |
struct_memoire *ancienne_base; |
|
|
|
void *pointeur; |
|
|
pthread_mutex_lock(&mutex_allocation); |
pthread_mutex_lock(&mutex_allocation); |
|
|
ancienne_base = debug; |
ancienne_base = debug; |
Line 3570 debug_memoire_ajout(size_t taille, const
|
Line 3651 debug_memoire_ajout(size_t taille, const
|
(*debug).taille = taille; |
(*debug).taille = taille; |
(*debug).ordre = ordre; |
(*debug).ordre = ordre; |
|
|
pthread_mutex_unlock(&mutex_allocation); |
pointeur = (*debug).pointeur; |
|
|
|
# ifdef __BACKTRACE |
|
(*debug).profondeur = backtrace((*debug).pile, PROFONDEUR_PILE); |
|
# endif |
|
|
if (((*debug).fonction = malloc((strlen(fonction) + 1) * |
if (((*debug).fonction = malloc((strlen(fonction) + 1) * |
sizeof(unsigned char))) == NULL) |
sizeof(unsigned char))) == NULL) |
{ |
{ |
|
pthread_mutex_unlock(&mutex_allocation); |
return(NULL); |
return(NULL); |
} |
} |
|
|
if (((*debug).argument = malloc((strlen(argument) + 1) * |
if (((*debug).argument = malloc((strlen(argument) + 1) * |
sizeof(unsigned char))) == NULL) |
sizeof(unsigned char))) == NULL) |
{ |
{ |
|
pthread_mutex_unlock(&mutex_allocation); |
return(NULL); |
return(NULL); |
} |
} |
|
|
strcpy((*debug).fonction, fonction); |
strcpy((*debug).fonction, fonction); |
strcpy((*debug).argument, argument); |
strcpy((*debug).argument, argument); |
|
|
|
memset((*debug).pointeur, 0, (*debug).taille); |
|
|
|
pthread_mutex_unlock(&mutex_allocation); |
ordre++; |
ordre++; |
|
|
return((*debug).pointeur); |
return(pointeur); |
} |
} |
|
|
void * |
void * |
Line 3603 debug_memoire_modification(void *pointeu
|
Line 3693 debug_memoire_modification(void *pointeu
|
{ |
{ |
if (taille == 0) |
if (taille == 0) |
{ |
{ |
// Revient à free() |
// Revient à free(). Il n'y a pas de parenthèses car on ne veut |
|
// pas utiliser la macro return(). |
|
|
debug_memoire_retrait(pointeur); |
debug_memoire_retrait(pointeur); |
return(NULL); |
return NULL ; |
} |
} |
else |
else |
{ |
{ |
Line 3628 debug_memoire_modification(void *pointeu
|
Line 3720 debug_memoire_modification(void *pointeu
|
if (element_courant == NULL) |
if (element_courant == NULL) |
{ |
{ |
pthread_mutex_unlock(&mutex_allocation); |
pthread_mutex_unlock(&mutex_allocation); |
return(NULL); |
|
} |
|
|
|
pthread_mutex_unlock(&mutex_allocation); |
uprintf("[%d-%llu] ILLEGAL POINTER (realloc)\n", |
|
getpid(), (unsigned long long) pthread_self()); |
|
# ifdef __BACKTRACE |
|
BACKTRACE(PROFONDEUR_PILE); |
|
# endif |
|
|
if (((*element_courant).pointeur = realloc(pointeur, taille)) |
return(realloc(pointeur, taille)); |
== NULL) |
|
{ |
|
return(NULL); |
|
} |
} |
|
else |
|
{ |
|
if (((*element_courant).pointeur = realloc(pointeur, taille)) |
|
== NULL) |
|
{ |
|
pthread_mutex_unlock(&mutex_allocation); |
|
return(NULL); |
|
} |
|
|
(*element_courant).ligne = ligne; |
(*element_courant).ligne = ligne; |
(*element_courant).taille = taille; |
(*element_courant).taille = taille; |
free((*element_courant).fonction); |
free((*element_courant).fonction); |
free((*element_courant).argument); |
free((*element_courant).argument); |
|
|
if (((*element_courant).fonction = malloc((strlen(fonction) + 1) * |
if (((*element_courant).fonction = malloc((strlen(fonction) |
sizeof(unsigned char))) == NULL) |
+ 1) * sizeof(unsigned char))) == NULL) |
{ |
{ |
return(NULL); |
pthread_mutex_unlock(&mutex_allocation); |
} |
return(NULL); |
|
} |
|
|
if (((*element_courant).argument = malloc((strlen(argument) + 1) * |
if (((*element_courant).argument = malloc((strlen(argument) |
sizeof(unsigned char))) == NULL) |
+ 1) * sizeof(unsigned char))) == NULL) |
{ |
{ |
return(NULL); |
pthread_mutex_unlock(&mutex_allocation); |
} |
return(NULL); |
|
} |
|
|
|
strcpy((*element_courant).fonction, fonction); |
|
strcpy((*element_courant).argument, argument); |
|
|
strcpy((*element_courant).fonction, fonction); |
pthread_mutex_unlock(&mutex_allocation); |
strcpy((*element_courant).argument, argument); |
|
|
|
return((*element_courant).pointeur); |
return((*element_courant).pointeur); |
|
} |
} |
} |
} |
} |
else |
else |
Line 3694 debug_memoire_retrait(void *pointeur)
|
Line 3798 debug_memoire_retrait(void *pointeur)
|
(*element_precedent).suivant = (*element_courant).suivant; |
(*element_precedent).suivant = (*element_courant).suivant; |
} |
} |
|
|
|
if (pointeur != NULL) |
|
{ |
|
memset(pointeur, 0, (*element_courant).taille); |
|
} |
|
|
free((*element_courant).fonction); |
free((*element_courant).fonction); |
free((*element_courant).argument); |
free((*element_courant).argument); |
free(element_courant); |
free(element_courant); |
Line 3707 debug_memoire_retrait(void *pointeur)
|
Line 3816 debug_memoire_retrait(void *pointeur)
|
|
|
pthread_mutex_unlock(&mutex_allocation); |
pthread_mutex_unlock(&mutex_allocation); |
|
|
free(pointeur); |
if (element_courant == NULL) |
|
{ |
|
uprintf("[%d-%llu] ILLEGAL POINTER (free)\n", |
|
getpid(), (unsigned long long) pthread_self()); |
|
# ifdef __BACKTRACE |
|
BACKTRACE(PROFONDEUR_PILE); |
|
# endif |
|
} |
|
|
|
free(pointeur); |
return; |
return; |
} |
} |
|
|
void |
void |
debug_memoire_verification(struct_processus *s_etat_processus) |
debug_memoire_verification() |
{ |
{ |
|
# ifdef __BACKTRACE |
|
char **appels; |
|
|
|
int j; |
|
# endif |
|
|
integer8 i; |
integer8 i; |
|
|
struct_memoire *element_courant; |
struct_memoire *element_courant; |
struct_memoire *element_suivant; |
struct_memoire *element_suivant; |
|
|
fprintf(stderr, "[%d-%llu] MEMORY LEAK\n", |
fprintf(stderr, "[%d-%llu] LIST OF MEMORY LEAKS\n", |
getpid(), (unsigned long long) pthread_self()); |
getpid(), (unsigned long long) pthread_self()); |
|
|
pthread_mutex_lock(&mutex_allocation); |
pthread_mutex_lock(&mutex_allocation); |
Line 3742 debug_memoire_verification(struct_proces
|
Line 3865 debug_memoire_verification(struct_proces
|
(unsigned long long) pthread_self(), |
(unsigned long long) pthread_self(), |
(*element_courant).argument); |
(*element_courant).argument); |
|
|
switch(i) |
if (strstr((*element_courant).argument, "sizeof(unsigned char)") |
|
!= NULL) |
|
{ |
|
fprintf(stderr, "[%d-%llu] ", getpid(), |
|
(unsigned long long) pthread_self()); |
|
fprintf(stderr, "O: %s\n", (unsigned char *) |
|
(*element_courant).pointeur); |
|
} |
|
else if (strcmp((*element_courant).argument, "sizeof(struct_objet)") |
|
== 0) |
|
{ |
|
fprintf(stderr, "[%d-%llu] ", getpid(), |
|
(unsigned long long) pthread_self()); |
|
fprintf(stderr, "O: %d\n", (*((struct_objet *) |
|
(*element_courant).pointeur)).type); |
|
} |
|
else if (strcmp((*element_courant).argument, |
|
"sizeof(struct_liste_chainee)") == 0) |
|
{ |
|
fprintf(stderr, "[%d-%llu] ", getpid(), |
|
(unsigned long long) pthread_self()); |
|
fprintf(stderr, "O: data=%p next=%p\n", (*((struct_liste_chainee *) |
|
(*element_courant).pointeur)).donnee, |
|
(*((struct_liste_chainee *) (*element_courant).pointeur)) |
|
.suivant); |
|
} |
|
|
|
# ifdef __BACKTRACE |
|
appels = backtrace_symbols((*element_courant).pile, |
|
(*element_courant).profondeur); |
|
|
|
fprintf(stderr, "[%d-%llu] BACKTRACE\n", |
|
getpid(), (unsigned long long) pthread_self()); |
|
|
|
if (appels != NULL) |
{ |
{ |
// Affichage des méditations |
for(j = 0; j < (*element_courant).profondeur; j++) |
case 1: |
|
{ |
{ |
break; |
fprintf(stderr, "[%d-%llu] %s\n", getpid(), |
|
(unsigned long long) pthread_self(), appels[j]); |
} |
} |
|
|
|
free(appels); |
} |
} |
|
# endif |
|
|
|
fprintf(stderr, "\n"); |
|
|
i++; |
i++; |
|
|
element_suivant = (*element_courant).suivant; |
element_suivant = (*element_courant).suivant; |
|
|
|
# ifndef CORE_DUMP |
free((*element_courant).fonction); |
free((*element_courant).fonction); |
free((*element_courant).argument); |
free((*element_courant).argument); |
free(element_courant); |
free(element_courant); |
|
# endif |
|
|
element_courant = element_suivant; |
element_courant = element_suivant; |
} |
} |
|
|
pthread_mutex_unlock(&mutex_allocation); |
pthread_mutex_unlock(&mutex_allocation); |
|
pthread_mutex_destroy(&mutex_allocation); |
|
|
fprintf(stderr, "[%d-%llu] END OF LIST\n", getpid(), |
fprintf(stderr, "[%d-%llu] END OF LIST\n", getpid(), |
(unsigned long long) pthread_self()); |
(unsigned long long) pthread_self()); |
|
|
return; |
return; |
} |
} |
|
|
|
pid_t |
|
debug_fork() |
|
{ |
|
pid_t pid; |
|
|
|
pthread_mutex_lock(&mutex_allocation); |
|
pid = fork(); |
|
|
|
if (pid == 0) |
|
{ |
|
liberation_queue_signaux(s_etat_processus); |
|
creation_queue_signaux(s_etat_processus); |
|
|
|
pthread_mutex_destroy(&mutex_allocation); |
|
debug_memoire_initialisation(); |
|
} |
|
else |
|
{ |
|
pthread_mutex_unlock(&mutex_allocation); |
|
} |
|
|
|
// Pas de parenthèses pour ne pas remplacer return par sa macro. |
|
return pid; |
|
} |
|
|
|
void |
|
analyse_post_mortem() |
|
{ |
|
# ifdef CORE_DUMP |
|
BUG(debug != NULL, uprintf("[%d-%llu] CREATE CORE DUMP FILE FOR " |
|
"POST MORTEM ANALYZE\n", getpid(), |
|
(unsigned long long) pthread_self())); |
|
# endif |
|
|
|
return; |
|
} |
|
|
#endif |
#endif |
|
|