|
version 1.6, 2010/04/07 13:45:03
|
version 1.67, 2013/05/28 22:09:55
|
|
Line 1
|
Line 1
|
| /* |
/* |
| ================================================================================ |
================================================================================ |
| RPL/2 (R) version 4.0.14 |
RPL/2 (R) version 4.1.14 |
| 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 40
|
Line 40
|
| void * |
void * |
| surveillance_processus(void *argument) |
surveillance_processus(void *argument) |
| { |
{ |
| int iostat; |
|
| int status; |
int status; |
| |
|
| integer8 nombre_donnees; |
integer8 nombre_donnees; |
|
Line 48 surveillance_processus(void *argument)
|
Line 47 surveillance_processus(void *argument)
|
| logical1 drapeau; |
logical1 drapeau; |
| logical1 drapeau_fin; |
logical1 drapeau_fin; |
| logical1 drapeau_fin_scrutation; |
logical1 drapeau_fin_scrutation; |
| logical1 drapeau_interruptions_traitees; |
logical1 drapeau_elements_traites; |
| logical1 drapeau_objets_traites; |
|
| |
|
| pid_t pid; |
pid_t pid; |
| pid_t pid_candidat; |
pid_t pid_erreur; |
| |
|
| pthread_t tid_candidat; |
|
| |
|
| sigset_t masque; |
|
| |
|
| |
ssize_t iostat; |
| ssize_t longueur_ecriture; |
ssize_t longueur_ecriture; |
| |
|
| struct_descripteur_thread *s_argument_thread; |
struct_descripteur_thread *s_argument_thread; |
|
Line 71 surveillance_processus(void *argument)
|
Line 66 surveillance_processus(void *argument)
|
| |
|
| unsigned char caractere; |
unsigned char caractere; |
| |
|
| unsigned int tampon_erreur; |
int tampon_erreur_execution; |
| |
int tampon_erreur_systeme; |
| |
|
| sigemptyset(&masque); |
sigset_t set; |
| sigaddset(&masque, SIGINJECT); |
|
| sigaddset(&masque, SIGFSTOP); |
sigfillset(&set); |
| sigaddset(&masque, SIGURG); |
pthread_sigmask(SIG_BLOCK, &set, NULL); |
| sigaddset(&masque, SIGALRM); |
|
| sigaddset(&masque, SIGCONT); |
|
| sigaddset(&masque, SIGINT); |
|
| pthread_sigmask(SIG_BLOCK, &masque, NULL); |
|
| |
|
| s_argument_thread = argument; |
s_argument_thread = argument; |
| s_etat_processus = (*s_argument_thread).s_etat_processus; |
s_etat_processus = (*s_argument_thread).s_etat_processus; |
| |
|
| |
if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = d_es_processus; |
| |
BUG(1, uprintf("General mutex error!\n")); |
| |
} |
| |
|
| insertion_thread_surveillance(s_etat_processus, s_argument_thread); |
insertion_thread_surveillance(s_etat_processus, s_argument_thread); |
| |
|
| |
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = d_es_processus; |
| |
BUG(1, uprintf("General mutex error!\n")); |
| |
} |
| |
|
| attente.tv_sec = 0; |
attente.tv_sec = 0; |
| attente.tv_nsec = GRANULARITE_us * 1000; |
attente.tv_nsec = GRANULARITE_us * 1000; |
| |
|
| status = 0; |
status = 0; |
| |
|
| drapeau_interruptions_traitees = d_faux; |
drapeau_elements_traites = d_faux; |
| drapeau_objets_traites = d_faux; |
|
| |
|
| if ((*s_etat_processus).debug == d_vrai) |
if ((*s_etat_processus).debug == d_vrai) |
| if (((*s_etat_processus).type_debug & |
if (((*s_etat_processus).type_debug & |
|
Line 137 surveillance_processus(void *argument)
|
Line 141 surveillance_processus(void *argument)
|
| */ |
*/ |
| |
|
| while(read_atomic(s_etat_processus, |
while(read_atomic(s_etat_processus, |
| (*s_argument_thread).pipe_nombre_objets_attente[0], |
(*s_argument_thread).pipe_nombre_elements_attente[0], |
| &caractere, sizeof(caractere)) == 0) |
&caractere, sizeof(caractere)) == 0) |
| { |
{ |
| if ((*s_etat_processus).var_volatile_requete_arret != 0) |
if ((*s_etat_processus).var_volatile_requete_arret != 0) |
| { |
{ |
| drapeau_objets_traites = d_vrai; |
drapeau_elements_traites = d_vrai; |
| drapeau_interruptions_traitees = d_vrai; |
|
| } |
} |
| |
|
| nanosleep(&attente, NULL); |
nanosleep(&attente, NULL); |
|
Line 157 surveillance_processus(void *argument)
|
Line 160 surveillance_processus(void *argument)
|
| * Le processus est un processus détaché. |
* Le processus est un processus détaché. |
| */ |
*/ |
| |
|
| // Scrutation de l'envoi de données par le fils. |
if (drapeau_elements_traites == d_vrai) |
| |
|
| pid_candidat = 0; |
|
| |
|
| if (drapeau_objets_traites == d_vrai) |
|
| { |
{ |
| nanosleep(&attente, NULL); |
nanosleep(&attente, NULL); |
| } |
} |
| else if ((iostat = read_atomic(s_etat_processus, |
else if ((iostat = read_atomic(s_etat_processus, |
| (*s_argument_thread).pipe_nombre_objets_attente[0], |
(*s_argument_thread).pipe_nombre_elements_attente[0], |
| &pid_candidat, sizeof(pid_candidat))) == 0) |
&caractere, sizeof(caractere))) == 0) |
| { |
{ |
| // Rien dans le pipe |
// Rien dans le pipe |
| |
|
| nanosleep(&attente, NULL); |
nanosleep(&attente, NULL); |
| } |
} |
| else if (iostat != sizeof(pid_candidat)) |
else if (iostat == sizeof(caractere)) |
| { |
{ |
| (*s_etat_processus).erreur_systeme_processus_fils = |
// Un objet supplémentaire est dans le pipe correspondant |
| d_es_processus; |
// au processus surveillé par ce thread. |
| } |
|
| else |
|
| { |
|
| // Un pid est dans le pipe. On vérifie que les deux pids |
|
| // correspondent. |
|
| |
|
| if (pid_candidat == -2) |
if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) |
| { |
|
| drapeau_objets_traites = d_vrai; |
|
| } |
|
| else if (pid_candidat == -1) |
|
| { |
{ |
| |
(*s_etat_processus).erreur_systeme_processus_fils = |
| |
d_es_processus; |
| } |
} |
| else if ((iostat = read_atomic(s_etat_processus, |
|
| (*s_argument_thread).pipe_nombre_objets_attente[0], |
l_element_courant = (struct_liste_chainee *) |
| &pid_candidat, sizeof(pid_candidat))) == |
(*s_etat_processus).l_base_pile_processus; |
| sizeof(pid_candidat)) |
|
| |
while(l_element_courant != NULL) |
| { |
{ |
| if ((*s_argument_thread).pid != pid_candidat) |
if ((*(*((struct_processus_fils *) |
| |
(*(*l_element_courant).donnee).objet)) |
| |
.thread).processus_detache == d_faux) |
| { |
{ |
| (*s_etat_processus).erreur_systeme_processus_fils = |
l_element_courant = (*l_element_courant) |
| d_es_processus; |
.suivant; |
| BUG(1, printf("Spurious process identifier")); |
continue; |
| } |
} |
| |
|
| // Un objet supplémentaire est dans le pipe correspondant |
if ((*(*((struct_processus_fils *) |
| // au processus surveillé par ce thread. |
(*(*l_element_courant).donnee).objet)) |
| |
.thread).pid == (*s_argument_thread).pid) |
| if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) |
|
| { |
{ |
| (*s_etat_processus).erreur_systeme_processus_fils = |
break; |
| d_es_processus; |
|
| } |
} |
| else |
|
| { |
|
| l_element_courant = (struct_liste_chainee *) |
|
| (*s_etat_processus).l_base_pile_processus; |
|
| |
|
| while(l_element_courant != NULL) |
l_element_courant = (*l_element_courant).suivant; |
| { |
} |
| if ((*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).processus_detache == d_faux) |
|
| { |
|
| l_element_courant = (*l_element_courant) |
|
| .suivant; |
|
| continue; |
|
| } |
|
| |
|
| if ((*(*((struct_processus_fils *) |
BUG(l_element_courant == NULL, |
| (*(*l_element_courant).donnee).objet)) |
printf("Process or thread not found")); |
| .thread).pid == pid_candidat) |
|
| { |
|
| if ((*s_etat_processus).debug == d_vrai) |
|
| if (((*s_etat_processus).type_debug & |
|
| d_debug_processus) != 0) |
|
| { |
|
| if ((*s_etat_processus).langue == 'F') |
|
| { |
|
| printf("[%d] Données en provenance " |
|
| "du processus %d\n", |
|
| (int) getpid(), |
|
| (int) (*s_argument_thread).pid); |
|
| fflush(stdout); |
|
| } |
|
| else |
|
| { |
|
| printf("[%d] Data from process %d\n", |
|
| (int) getpid(), |
|
| (int) (*s_argument_thread).pid); |
|
| fflush(stdout); |
|
| } |
|
| } |
|
| |
|
| if (pthread_mutex_lock( |
switch(caractere) |
| &((*(*((struct_processus_fils *) |
{ |
| (*(*l_element_courant).donnee).objet)) |
case 1: |
| .thread).mutex)) != 0) |
case 2: |
| |
{ |
| |
if ((*s_etat_processus).debug == d_vrai) |
| |
if (((*s_etat_processus).type_debug & |
| |
d_debug_processus) != 0) |
| |
{ |
| |
if ((*s_etat_processus).langue == 'F') |
| |
{ |
| |
if (caractere == 1) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
printf("[%d] Données en provenance " |
| d_es_processus; |
"du processus %d\n", (int) getpid(), |
| |
(int) (*s_argument_thread).pid); |
| } |
} |
| |
else |
| (*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).nombre_objets_dans_pipe++; |
|
| |
|
| if (pthread_mutex_unlock( |
|
| &((*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).mutex)) != 0) |
|
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
printf("[%d] Interrution logicielle " |
| d_es_processus; |
"en provenance du processus " |
| |
"%d\n", (int) getpid(), |
| |
(int) (*s_argument_thread).pid); |
| } |
} |
| |
|
| while((longueur_ecriture = |
fflush(stdout); |
| write_atomic(s_etat_processus, |
} |
| (*(*((struct_processus_fils *) |
else |
| (*(*l_element_courant).donnee).objet)) |
{ |
| .thread).pipe_acquittement[1], "-", |
if (caractere == 1) |
| sizeof(unsigned char))) != |
|
| sizeof(unsigned char)) |
|
| { |
{ |
| if (longueur_ecriture == -1) |
printf("[%d] Data from process %d\n", |
| { |
(int) getpid(), |
| (*s_etat_processus) |
(int) (*s_argument_thread).pid); |
| .erreur_systeme_processus_fils = |
|
| d_es_processus; |
|
| } |
|
| } |
} |
| |
else |
| if ((*s_etat_processus).debug == d_vrai) |
|
| if (((*s_etat_processus).type_debug & |
|
| d_debug_processus) != 0) |
|
| { |
{ |
| if ((*s_etat_processus).langue == 'F') |
printf("[%d] Software interrupt " |
| { |
"from process %d\n", (int) getpid(), |
| printf("[%d] Données acquittées " |
(int) (*s_argument_thread).pid); |
| "en provenance du " |
|
| "processus %d\n", |
|
| (int) getpid(), |
|
| (int) (*s_argument_thread).pid); |
|
| fflush(stdout); |
|
| } |
|
| else |
|
| { |
|
| printf("[%d] Data acknowklegment " |
|
| "from process %d\n", |
|
| (int) getpid(), |
|
| (int) (*s_argument_thread).pid); |
|
| fflush(stdout); |
|
| } |
|
| } |
} |
| |
|
| break; |
fflush(stdout); |
| } |
} |
| |
|
| l_element_courant = (*l_element_courant).suivant; |
|
| } |
} |
| |
|
| BUG(l_element_courant == NULL, |
if (pthread_mutex_lock(&((*(*((struct_processus_fils *) |
| printf("Process or thread not found")); |
(*(*l_element_courant).donnee).objet)) |
| |
.thread).mutex)) != 0) |
| if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) |
|
| != 0) |
|
| { |
{ |
| (*s_etat_processus).erreur_systeme_processus_fils = |
(*s_etat_processus).erreur_systeme = |
| d_es_processus; |
d_es_processus; |
| } |
} |
| |
|
| pthread_kill((*s_argument_thread).thread_pere, |
if (caractere == 1) |
| SIGINJECT); |
{ |
| } |
(*(*((struct_processus_fils *) |
| } |
(*(*l_element_courant).donnee).objet)) |
| else |
.thread).nombre_objets_dans_pipe++; |
| { |
} |
| (*s_etat_processus).erreur_systeme_processus_fils = |
else |
| d_es_processus; |
{ |
| } |
(*(*((struct_processus_fils *) |
| } |
(*(*l_element_courant).donnee).objet)) |
| |
.thread).nombre_interruptions_dans_pipe++; |
| // Scrutation de l'envoi d'interruptions par le fils. |
|
| |
|
| if (drapeau_interruptions_traitees == d_vrai) |
|
| { |
|
| nanosleep(&attente, NULL); |
|
| } |
|
| else if ((iostat = read_atomic(s_etat_processus, |
|
| (*s_argument_thread).pipe_nombre_interruptions_attente[0], |
|
| &pid_candidat, sizeof(pid_candidat))) == 0) |
|
| { |
|
| // Rien dans le pipe |
|
| |
|
| nanosleep(&attente, NULL); |
if (pthread_mutex_lock(&((*s_etat_processus) |
| } |
.mutex_interruptions)) != 0) |
| else if (iostat != sizeof(pid_candidat)) |
{ |
| { |
(*s_etat_processus).erreur_systeme = |
| (*s_etat_processus).erreur_systeme_processus_fils = |
d_es_processus; |
| d_es_processus; |
} |
| } |
|
| else |
|
| { |
|
| // Un pid est dans le pipe. On vérifie que les deux pids |
|
| // correspondent. |
|
| |
|
| if (pid_candidat == -2) |
(*s_etat_processus) |
| { |
.nombre_interruptions_non_affectees++; |
| drapeau_interruptions_traitees = d_vrai; |
|
| } |
|
| else if (pid_candidat == -1) |
|
| { |
|
| } |
|
| else if ((iostat = read_atomic(s_etat_processus, |
|
| (*s_argument_thread).pipe_nombre_interruptions_attente |
|
| [0], &pid_candidat, sizeof(pid_candidat))) |
|
| == sizeof(pid_candidat)) |
|
| { |
|
| if ((*s_argument_thread).pid != pid_candidat) |
|
| { |
|
| (*s_etat_processus).erreur_systeme_processus_fils = |
|
| d_es_processus; |
|
| BUG(1, printf("Spurious interrupt")); |
|
| } |
|
| |
|
| // Une interruption supplémentaire est dans le pipe |
if (pthread_mutex_unlock(&((*s_etat_processus) |
| // correspondant au processus surveillé par ce thread. |
.mutex_interruptions)) != 0) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_processus; |
| |
} |
| |
} |
| |
|
| if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) |
if (pthread_mutex_unlock( |
| { |
&((*(*((struct_processus_fils *) |
| (*s_etat_processus).erreur_systeme_processus_fils = |
(*(*l_element_courant).donnee).objet)) |
| d_es_processus; |
.thread).mutex)) != 0) |
| } |
{ |
| else |
(*s_etat_processus).erreur_systeme = |
| { |
d_es_processus; |
| l_element_courant = (struct_liste_chainee *) |
} |
| (*s_etat_processus).l_base_pile_processus; |
|
| |
|
| while(l_element_courant != NULL) |
while((longueur_ecriture = |
| |
write_atomic(s_etat_processus, |
| |
(*(*((struct_processus_fils *) |
| |
(*(*l_element_courant).donnee).objet)) |
| |
.thread).pipe_acquittement[1], "-", |
| |
sizeof(unsigned char))) != |
| |
sizeof(unsigned char)) |
| { |
{ |
| if ((*(*((struct_processus_fils *) |
if (longueur_ecriture == -1) |
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).processus_detache == d_faux) |
|
| { |
{ |
| l_element_courant = (*l_element_courant) |
(*s_etat_processus) |
| .suivant; |
.erreur_systeme_processus_fils = |
| continue; |
d_es_processus; |
| } |
} |
| |
} |
| |
|
| if ((*(*((struct_processus_fils *) |
if ((*s_etat_processus).debug == d_vrai) |
| (*(*l_element_courant).donnee).objet)) |
if (((*s_etat_processus).type_debug & |
| .thread).pid == pid_candidat) |
d_debug_processus) != 0) |
| |
{ |
| |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| if ((*s_etat_processus).debug == d_vrai) |
if (caractere == 1) |
| if (((*s_etat_processus).type_debug & |
|
| d_traitement_interruption) != 0) |
|
| { |
{ |
| if ((*s_etat_processus).langue == 'F') |
printf("[%d] Données acquittées " |
| { |
"en provenance du " |
| printf("[%d] Interrution logicielle " |
"processus %d\n", (int) getpid(), |
| "en provenance du processus " |
(int) (*s_argument_thread).pid); |
| "%d\n", (int) getpid(), |
|
| (int) (*s_argument_thread).pid); |
|
| fflush(stdout); |
|
| } |
|
| else |
|
| { |
|
| printf("[%d] Software interrupt " |
|
| "from process %d\n", |
|
| (int) getpid(), |
|
| (int) (*s_argument_thread).pid); |
|
| fflush(stdout); |
|
| } |
|
| } |
|
| |
|
| if (pthread_mutex_lock( |
|
| &((*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).mutex)) != 0) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_processus; |
|
| } |
} |
| |
else |
| (*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee) |
|
| .objet)).thread) |
|
| .nombre_interruptions_dans_pipe++; |
|
| |
|
| if (pthread_mutex_unlock( |
|
| &((*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).mutex)) != 0) |
|
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
printf("[%d] Interruption logicielle " |
| d_es_processus; |
"acquittée en provenance " |
| |
"du processus %d\n", (int) getpid(), |
| |
(int) (*s_argument_thread).pid); |
| } |
} |
| |
|
| (*s_etat_processus) |
fflush(stdout); |
| .nombre_interruptions_non_affectees++; |
} |
| |
else |
| while((longueur_ecriture = |
{ |
| write_atomic(s_etat_processus, |
if (caractere == 1) |
| (*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).pipe_acquittement[1], "-", |
|
| sizeof(unsigned char))) != |
|
| sizeof(unsigned char)) |
|
| { |
{ |
| if (longueur_ecriture == -1) |
printf("[%d] Data acknowklegment " |
| { |
"from process %d\n", (int) getpid(), |
| (*s_etat_processus) |
(int) (*s_argument_thread).pid); |
| .erreur_systeme_processus_fils = |
|
| d_es_processus; |
|
| } |
|
| } |
} |
| |
else |
| if ((*s_etat_processus).debug == d_vrai) |
|
| if (((*s_etat_processus).type_debug & |
|
| d_traitement_interruption) != 0) |
|
| { |
{ |
| if ((*s_etat_processus).langue == 'F') |
printf("[%d] Software interrupt " |
| { |
"acknowklegment from " |
| printf("[%d] Interruption logicielle " |
"process %d\n", (int) getpid(), |
| "acquittée en provenance " |
(int) (*s_argument_thread).pid); |
| "du processus %d\n", |
|
| (int) getpid(), |
|
| (int) (*s_argument_thread).pid); |
|
| fflush(stdout); |
|
| } |
|
| else |
|
| { |
|
| printf("[%d] Software interrupt " |
|
| "acknowklegment from " |
|
| "process %d\n", |
|
| (int) getpid(), |
|
| (int) (*s_argument_thread).pid); |
|
| fflush(stdout); |
|
| } |
|
| } |
} |
| |
|
| break; |
fflush(stdout); |
| } |
} |
| |
|
| l_element_courant = (*l_element_courant).suivant; |
|
| } |
} |
| |
|
| BUG(l_element_courant == NULL, |
envoi_signal_thread((*s_argument_thread).thread_pere, |
| printf("Process or thread not found")); |
rpl_siginject); |
| |
break; |
| |
} |
| |
|
| if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) |
case 0: |
| != 0) |
{ |
| { |
break; |
| (*s_etat_processus).erreur_systeme_processus_fils = |
} |
| d_es_processus; |
|
| } |
|
| |
|
| pthread_kill((*s_argument_thread).thread_pere, |
default: |
| SIGINJECT); |
{ |
| |
(*s_etat_processus).erreur_systeme_processus_fils = |
| |
d_es_processus; |
| |
BUG(1, printf("Spurious interprocess data")); |
| } |
} |
| } |
} |
| else |
|
| |
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) |
| |
!= 0) |
| { |
{ |
| (*s_etat_processus).erreur_systeme_processus_fils = |
(*s_etat_processus).erreur_systeme_processus_fils = |
| d_es_processus; |
d_es_processus; |
| } |
} |
| } |
} |
| |
else |
| |
{ |
| |
perror("read"); |
| |
(*s_etat_processus).erreur_systeme = d_es_processus; |
| |
} |
| |
|
| if ((pid = waitpid((*s_argument_thread).pid, &status, WNOHANG)) < 0) |
if ((pid = waitpid((*s_argument_thread).pid, &status, WNOHANG)) < 0) |
| { |
{ |
|
Line 547 surveillance_processus(void *argument)
|
Line 414 surveillance_processus(void *argument)
|
| * Le processus n'est pas détaché. |
* Le processus n'est pas détaché. |
| */ |
*/ |
| |
|
| // Scrutation de l'envoi de données par le fils. |
if (drapeau_elements_traites == d_vrai) |
| |
|
| tid_candidat = (pthread_t) 0; |
|
| |
|
| if (drapeau_objets_traites == d_vrai) |
|
| { |
{ |
| nanosleep(&attente, NULL); |
nanosleep(&attente, NULL); |
| } |
} |
| else if ((iostat = read_atomic(s_etat_processus, |
else if ((iostat = read_atomic(s_etat_processus, |
| (*s_argument_thread).pipe_nombre_objets_attente[0], |
(*s_argument_thread).pipe_nombre_elements_attente[0], |
| &tid_candidat, sizeof(tid_candidat))) == 0) |
&caractere, sizeof(caractere))) == 0) |
| { |
{ |
| // Rien dans le pipe |
// Rien dans le pipe |
| |
|
| nanosleep(&attente, NULL); |
nanosleep(&attente, NULL); |
| } |
} |
| else if (iostat != sizeof(tid_candidat)) |
else if (iostat == sizeof(caractere)) |
| { |
{ |
| (*s_etat_processus).erreur_systeme_processus_fils = |
// Un objet supplémentaire est dans le pipe correspondant |
| d_es_processus; |
// au processus surveillé par ce thread. |
| } |
|
| else |
|
| { |
|
| // Un pid est dans le pipe. On vérifie que les deux pids |
|
| // correspondent. |
|
| |
|
| if (tid_candidat == (pthread_t) -2) |
if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) |
| { |
|
| drapeau_objets_traites = d_vrai; |
|
| } |
|
| else if (tid_candidat == (pthread_t) -1) |
|
| { |
{ |
| |
(*s_etat_processus).erreur_systeme_processus_fils = |
| |
d_es_processus; |
| } |
} |
| else if ((iostat = read_atomic(s_etat_processus, |
|
| (*s_argument_thread).pipe_nombre_objets_attente[0], |
l_element_courant = (struct_liste_chainee *) |
| &tid_candidat, sizeof(tid_candidat))) == |
(*s_etat_processus).l_base_pile_processus; |
| sizeof(tid_candidat)) |
|
| |
while(l_element_courant != NULL) |
| { |
{ |
| if (pthread_equal((*s_argument_thread).tid, |
if ((*(*((struct_processus_fils *) |
| tid_candidat) == 0) |
(*(*l_element_courant).donnee).objet)) |
| |
.thread).processus_detache == d_vrai) |
| { |
{ |
| (*s_etat_processus).erreur_systeme_processus_fils = |
l_element_courant = (*l_element_courant).suivant; |
| d_es_processus; |
continue; |
| BUG(1, printf("Spurious thread identifier")); |
|
| } |
} |
| |
|
| // Un objet supplémentaire est dans le pipe correspondant |
if ((*(*((struct_processus_fils *) |
| // au processus surveillé par ce thread. |
(*(*l_element_courant).donnee).objet)) |
| |
.thread).tid == (*s_argument_thread).tid) |
| if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) |
|
| { |
{ |
| (*s_etat_processus).erreur_systeme_processus_fils = |
break; |
| d_es_processus; |
|
| } |
} |
| else |
|
| { |
|
| l_element_courant = (struct_liste_chainee *) |
|
| (*s_etat_processus).l_base_pile_processus; |
|
| |
|
| while(l_element_courant != NULL) |
l_element_courant = (*l_element_courant).suivant; |
| { |
} |
| if ((*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).processus_detache == d_vrai) |
|
| { |
|
| l_element_courant = (*l_element_courant) |
|
| .suivant; |
|
| continue; |
|
| } |
|
| |
|
| if (pthread_equal((*(*((struct_processus_fils *) |
BUG(l_element_courant == NULL, |
| (*(*l_element_courant).donnee).objet)) |
printf("Process or thread not found")); |
| .thread).tid, tid_candidat) != 0) |
|
| |
switch(caractere) |
| |
{ |
| |
case 1: |
| |
case 2: |
| |
{ |
| |
if ((*s_etat_processus).debug == d_vrai) |
| |
if (((*s_etat_processus).type_debug & |
| |
d_debug_processus) != 0) |
| |
{ |
| |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| if ((*s_etat_processus).debug == d_vrai) |
if (caractere == 1) |
| if (((*s_etat_processus).type_debug & |
|
| d_debug_processus) != 0) |
|
| { |
{ |
| if ((*s_etat_processus).langue == 'F') |
printf("[%d] Données en provenance " |
| { |
"du thread %llu\n", (int) getpid(), |
| printf("[%d] Données en provenance " |
(unsigned long long) |
| "du thread %llu\n", |
(*s_argument_thread).tid); |
| (int) getpid(), |
|
| (unsigned long long) |
|
| (*s_argument_thread).tid); |
|
| fflush(stdout); |
|
| } |
|
| else |
|
| { |
|
| printf("[%d] Data from thread %llu\n", |
|
| (int) getpid(), |
|
| (unsigned long long) |
|
| (*s_argument_thread).tid); |
|
| fflush(stdout); |
|
| } |
|
| } |
} |
| |
else |
| if (pthread_mutex_lock( |
|
| &((*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).mutex)) != 0) |
|
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
printf("[%d] Interrution logicielle " |
| d_es_processus; |
"en provenance du thread " |
| |
"%llu\n", (int) getpid(), |
| |
(unsigned long long) |
| |
(*s_argument_thread).tid); |
| } |
} |
| |
|
| (*(*((struct_processus_fils *) |
fflush(stdout); |
| (*(*l_element_courant).donnee).objet)) |
} |
| .thread).nombre_objets_dans_pipe++; |
else |
| |
{ |
| if (pthread_mutex_unlock( |
if (caractere == 1) |
| &((*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).mutex)) != 0) |
|
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
printf("[%d] Data from thread %llu\n", |
| d_es_processus; |
(int) getpid(), (unsigned long long) |
| |
(*s_argument_thread).tid); |
| } |
} |
| |
else |
| while((longueur_ecriture = |
|
| write_atomic(s_etat_processus, |
|
| (*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).pipe_acquittement[1], "-", |
|
| sizeof(unsigned char))) != |
|
| sizeof(unsigned char)) |
|
| { |
{ |
| if (longueur_ecriture == -1) |
printf("[%d] Software interrupt " |
| { |
"from thread %llu\n", |
| (*s_etat_processus) |
(int) getpid(), (unsigned long long) |
| .erreur_systeme_processus_fils = |
(*s_argument_thread).tid); |
| d_es_processus; |
|
| } |
|
| } |
} |
| |
|
| if ((*s_etat_processus).debug == d_vrai) |
fflush(stdout); |
| if (((*s_etat_processus).type_debug & |
|
| d_debug_processus) != 0) |
|
| { |
|
| if ((*s_etat_processus).langue == 'F') |
|
| { |
|
| printf("[%d] Données acquittées " |
|
| "en provenance du thread " |
|
| "%llu\n", (int) getpid(), |
|
| (unsigned long long) |
|
| (*s_argument_thread).tid); |
|
| fflush(stdout); |
|
| } |
|
| else |
|
| { |
|
| printf("[%d] Data acknowklegment " |
|
| "from thread %llu\n", |
|
| (int) getpid(), |
|
| (unsigned long long) |
|
| (*s_argument_thread).tid); |
|
| fflush(stdout); |
|
| } |
|
| } |
|
| |
|
| break; |
|
| } |
} |
| |
|
| l_element_courant = (*l_element_courant).suivant; |
|
| } |
} |
| |
|
| BUG(l_element_courant == NULL, |
if (pthread_mutex_lock(&((*(*((struct_processus_fils *) |
| printf("Process or thread not found")); |
(*(*l_element_courant).donnee).objet)) |
| |
.thread).mutex)) != 0) |
| if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) |
|
| != 0) |
|
| { |
{ |
| (*s_etat_processus).erreur_systeme_processus_fils = |
(*s_etat_processus).erreur_systeme = |
| d_es_processus; |
d_es_processus; |
| } |
} |
| } |
|
| } |
|
| else |
|
| { |
|
| (*s_etat_processus).erreur_systeme_processus_fils = |
|
| d_es_processus; |
|
| } |
|
| } |
|
| |
|
| // Scrutation de l'envoi d'interruptions par le fils. |
|
| |
|
| if (drapeau_interruptions_traitees == d_vrai) |
if (caractere == 1) |
| { |
{ |
| nanosleep(&attente, NULL); |
(*(*((struct_processus_fils *) |
| } |
(*(*l_element_courant).donnee).objet)) |
| else if ((iostat = read_atomic(s_etat_processus, |
.thread).nombre_objets_dans_pipe++; |
| (*s_argument_thread).pipe_nombre_interruptions_attente[0], |
} |
| &tid_candidat, sizeof(tid_candidat))) == 0) |
else |
| { |
{ |
| // Rien dans le pipe |
(*(*((struct_processus_fils *) |
| |
(*(*l_element_courant).donnee).objet)) |
| |
.thread).nombre_interruptions_dans_pipe++; |
| |
|
| nanosleep(&attente, NULL); |
if (pthread_mutex_lock(&((*s_etat_processus) |
| } |
.mutex_interruptions)) != 0) |
| else if (iostat != sizeof(tid_candidat)) |
{ |
| { |
(*s_etat_processus).erreur_systeme = |
| (*s_etat_processus).erreur_systeme_processus_fils = |
d_es_processus; |
| d_es_processus; |
} |
| } |
|
| else |
|
| { |
|
| // Un pid est dans le pipe. On vérifie que les deux pids |
|
| // correspondent. |
|
| |
|
| if (tid_candidat == (pthread_t) -2) |
(*s_etat_processus) |
| { |
.nombre_interruptions_non_affectees++; |
| drapeau_interruptions_traitees = d_vrai; |
|
| } |
|
| else if (tid_candidat == (pthread_t) -1) |
|
| { |
|
| } |
|
| else if ((iostat = read_atomic(s_etat_processus, |
|
| (*s_argument_thread).pipe_nombre_interruptions_attente |
|
| [0], &tid_candidat, sizeof(tid_candidat))) == |
|
| sizeof(tid_candidat)) |
|
| { |
|
| if (pthread_equal((*s_argument_thread).tid, |
|
| tid_candidat) == 0) |
|
| { |
|
| (*s_etat_processus).erreur_systeme_processus_fils = |
|
| d_es_processus; |
|
| BUG(1, printf("Spurious interrupt")); |
|
| } |
|
| |
|
| // Une interruption supplémentaire est dans le pipe |
if (pthread_mutex_unlock(&((*s_etat_processus) |
| // correspondant au processus surveillé par ce thread. |
.mutex_interruptions)) != 0) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_processus; |
| |
} |
| |
} |
| |
|
| if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) |
if (pthread_mutex_unlock( |
| { |
&((*(*((struct_processus_fils *) |
| (*s_etat_processus).erreur_systeme_processus_fils = |
(*(*l_element_courant).donnee).objet)) |
| d_es_processus; |
.thread).mutex)) != 0) |
| } |
{ |
| else |
(*s_etat_processus).erreur_systeme = |
| { |
d_es_processus; |
| l_element_courant = (struct_liste_chainee *) |
} |
| (*s_etat_processus).l_base_pile_processus; |
|
| |
|
| while(l_element_courant != NULL) |
while((longueur_ecriture = |
| |
write_atomic(s_etat_processus, |
| |
(*(*((struct_processus_fils *) |
| |
(*(*l_element_courant).donnee).objet)) |
| |
.thread).pipe_acquittement[1], "-", |
| |
sizeof(unsigned char))) != |
| |
sizeof(unsigned char)) |
| { |
{ |
| if ((*(*((struct_processus_fils *) |
if (longueur_ecriture == -1) |
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).processus_detache == d_vrai) |
|
| { |
{ |
| l_element_courant = (*l_element_courant) |
(*s_etat_processus) |
| .suivant; |
.erreur_systeme_processus_fils = |
| continue; |
d_es_processus; |
| } |
} |
| |
} |
| |
|
| if (pthread_equal((*(*((struct_processus_fils *) |
if ((*s_etat_processus).debug == d_vrai) |
| (*(*l_element_courant).donnee).objet)) |
if (((*s_etat_processus).type_debug & |
| .thread).tid, tid_candidat) != 0) |
d_debug_processus) != 0) |
| |
{ |
| |
if ((*s_etat_processus).langue == 'F') |
| { |
{ |
| if ((*s_etat_processus).debug == d_vrai) |
if (caractere == 1) |
| if (((*s_etat_processus).type_debug & |
|
| d_debug_processus) != 0) |
|
| { |
{ |
| if ((*s_etat_processus).langue == 'F') |
printf("[%d] Données acquittées " |
| { |
"en provenance du " |
| printf("[%d] Interrution logicielle " |
"thread %llu\n", (int) getpid(), |
| "en provenance du thread " |
(unsigned long long) |
| "%llu\n", (int) getpid(), |
(*s_argument_thread).tid); |
| (unsigned long long) |
|
| (*s_argument_thread).tid); |
|
| fflush(stdout); |
|
| } |
|
| else |
|
| { |
|
| printf("[%d] Software interrupt " |
|
| "from thread %llu\n", |
|
| (int) getpid(), |
|
| (unsigned long long) |
|
| (*s_argument_thread).tid); |
|
| fflush(stdout); |
|
| } |
|
| } |
} |
| |
else |
| if (pthread_mutex_lock( |
|
| &((*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).mutex)) != 0) |
|
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
printf("[%d] Interruption logicielle " |
| d_es_processus; |
"acquittée en provenance " |
| |
"du thread %llu\n", (int) getpid(), |
| |
(unsigned long long) |
| |
(*s_argument_thread).tid); |
| } |
} |
| |
|
| (*(*((struct_processus_fils *) |
fflush(stdout); |
| (*(*l_element_courant).donnee) |
} |
| .objet)).thread) |
else |
| .nombre_interruptions_dans_pipe++; |
{ |
| |
if (caractere == 1) |
| if (pthread_mutex_unlock( |
|
| &((*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).mutex)) != 0) |
|
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
printf("[%d] Data acknowklegment " |
| d_es_processus; |
"from thread %d\n", (int) getpid(), |
| |
(unsigned long long) |
| |
(*s_argument_thread).tid); |
| } |
} |
| |
else |
| (*s_etat_processus) |
|
| .nombre_interruptions_non_affectees++; |
|
| |
|
| while((longueur_ecriture = |
|
| write_atomic(s_etat_processus, |
|
| (*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).pipe_acquittement[1], "-", |
|
| sizeof(unsigned char))) != |
|
| sizeof(unsigned char)) |
|
| { |
{ |
| if (longueur_ecriture == -1) |
printf("[%d] Software interrupt " |
| { |
"acknowklegment from " |
| (*s_etat_processus) |
"thread %d\n", (int) getpid(), |
| .erreur_systeme_processus_fils = |
(unsigned long long) |
| d_es_processus; |
(*s_argument_thread).tid); |
| } |
|
| } |
} |
| |
|
| if ((*s_etat_processus).debug == d_vrai) |
fflush(stdout); |
| if (((*s_etat_processus).type_debug & |
|
| d_traitement_interruption) != 0) |
|
| { |
|
| if ((*s_etat_processus).langue == 'F') |
|
| { |
|
| printf("[%d] Interruption logicielle " |
|
| "acquittée en provenance " |
|
| "du thread %llu\n", |
|
| (int) getpid(), |
|
| (unsigned long long) |
|
| (*s_argument_thread).tid); |
|
| fflush(stdout); |
|
| } |
|
| else |
|
| { |
|
| printf("[%d] Software interrupt " |
|
| "acknowklegment from " |
|
| "thread %llu\n", |
|
| (int) getpid(), |
|
| (unsigned long long) |
|
| (*s_argument_thread).tid); |
|
| fflush(stdout); |
|
| } |
|
| } |
|
| |
|
| break; |
|
| } |
} |
| |
} |
| |
|
| l_element_courant = (*l_element_courant).suivant; |
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) |
| |
!= 0) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme_processus_fils = |
| |
d_es_processus; |
| } |
} |
| |
|
| BUG(l_element_courant == NULL, |
envoi_signal_thread((*s_argument_thread).thread_pere, |
| printf("Process or thread not found")); |
rpl_siginject); |
| |
|
| if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) |
if (pthread_mutex_lock(&((*s_etat_processus).mutex)) |
| != 0) |
!= 0) |
| { |
{ |
| (*s_etat_processus).erreur_systeme_processus_fils = |
(*s_etat_processus).erreur_systeme_processus_fils = |
| d_es_processus; |
d_es_processus; |
| } |
} |
| |
|
| |
break; |
| |
} |
| |
|
| |
case 0: |
| |
{ |
| |
break; |
| |
} |
| |
|
| |
default: |
| |
{ |
| |
(*s_etat_processus).erreur_systeme_processus_fils = |
| |
d_es_processus; |
| |
BUG(1, printf("Spurious interprocess data")); |
| } |
} |
| } |
} |
| else |
|
| |
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) |
| |
!= 0) |
| { |
{ |
| (*s_etat_processus).erreur_systeme_processus_fils = |
(*s_etat_processus).erreur_systeme_processus_fils = |
| d_es_processus; |
d_es_processus; |
| } |
} |
| } |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = d_es_processus; |
| |
} |
| |
|
| if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0) |
if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0) |
| { |
{ |
|
Line 998 surveillance_processus(void *argument)
|
Line 746 surveillance_processus(void *argument)
|
| l_element_courant = (struct_liste_chainee *) |
l_element_courant = (struct_liste_chainee *) |
| (*s_etat_processus).l_base_pile_processus; |
(*s_etat_processus).l_base_pile_processus; |
| |
|
| if (drapeau_objets_traites == d_faux) |
if (drapeau_elements_traites == d_faux) |
| { |
{ |
| if ((*s_argument_thread).processus_detache == d_vrai) |
while(l_element_courant != NULL) |
| { |
{ |
| while(l_element_courant != NULL) |
if ((*(*((struct_processus_fils *) (*(*l_element_courant) |
| |
.donnee).objet)).thread).processus_detache |
| |
== d_vrai) |
| { |
{ |
| if ((*(*((struct_processus_fils *) (*(*l_element_courant) |
if ((*(*((struct_processus_fils *) (*(*l_element_courant) |
| .donnee).objet)).thread).processus_detache |
|
| == d_faux) |
|
| { |
|
| l_element_courant = (*l_element_courant).suivant; |
|
| continue; |
|
| } |
|
| |
|
| if ((*(*((struct_processus_fils *) (*(*l_element_courant) |
|
| .donnee).objet)).thread).pid == |
.donnee).objet)).thread).pid == |
| (*s_argument_thread).pid) |
(*s_argument_thread).pid) |
| { |
{ |
| while(read_atomic(s_etat_processus, (*s_argument_thread) |
while(read_atomic(s_etat_processus, (*s_argument_thread) |
| .pipe_nombre_objets_attente[0], |
.pipe_nombre_elements_attente[0], |
| &pid_candidat, sizeof(pid_candidat)) == |
&caractere, sizeof(caractere)) == |
| sizeof(pid_candidat)) |
sizeof(caractere)) |
| { |
{ |
| /* |
if (caractere == 0) |
| * -1 est renvoyé par l'instruction SWI |
|
| */ |
|
| |
|
| if (pid_candidat == -2) |
|
| { |
|
| break; |
|
| } |
|
| else if (pid_candidat == -1) |
|
| { |
{ |
| |
continue; |
| } |
} |
| else if (read_atomic(s_etat_processus, |
|
| (*s_argument_thread) |
if ((*s_etat_processus).debug == d_vrai) |
| .pipe_nombre_objets_attente[0], |
if (((*s_etat_processus).type_debug & |
| &pid_candidat, sizeof(pid_candidat)) == |
d_debug_processus) != 0) |
| sizeof(pid_candidat)) |
|
| { |
{ |
| if ((*s_etat_processus).debug == d_vrai) |
if ((*s_etat_processus).langue == 'F') |
| if (((*s_etat_processus).type_debug & |
|
| d_debug_processus) != 0) |
|
| { |
{ |
| if ((*s_etat_processus).langue == 'F') |
if (caractere == 1) |
| { |
{ |
| printf("[%d] Données en provenance du " |
printf("[%d] Données en provenance du " |
| "processus %d (processus " |
"processus %d (processus " |
| "arrêté)\n", (int) getpid(), |
"arrêté)\n", (int) getpid(), |
| (int) (*s_argument_thread).pid); |
(int) (*s_argument_thread).pid); |
| fflush(stdout); |
|
| } |
} |
| else |
else |
| { |
{ |
| |
printf("[%d] Interruption en " |
| |
"provenance du " |
| |
"processus %d (processus " |
| |
"arrêté)\n", (int) getpid(), |
| |
(int) (*s_argument_thread).pid); |
| |
} |
| |
|
| |
fflush(stdout); |
| |
} |
| |
else |
| |
{ |
| |
if (caractere == 1) |
| |
{ |
| printf("[%d] Data from process %d " |
printf("[%d] Data from process %d " |
| "(processus stopped)\n", |
"(processus stopped)\n", |
| (int) getpid(), |
(int) getpid(), |
| (int) (*s_argument_thread).pid); |
(int) (*s_argument_thread).pid); |
| fflush(stdout); |
|
| } |
} |
| |
else |
| |
{ |
| |
printf("[%d] Interrupt from process %d " |
| |
"(processus stopped)\n", |
| |
(int) getpid(), |
| |
(int) (*s_argument_thread).pid); |
| |
} |
| |
|
| |
fflush(stdout); |
| } |
} |
| |
} |
| |
|
| |
if (pthread_mutex_lock( |
| |
&((*(*((struct_processus_fils *) |
| |
(*(*l_element_courant).donnee).objet)) |
| |
.thread).mutex)) != 0) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_processus; |
| |
} |
| |
|
| if (pthread_mutex_lock( |
if (caractere == 1) |
| &((*(*((struct_processus_fils *) |
{ |
| |
(*(*((struct_processus_fils *) |
| (*(*l_element_courant).donnee).objet)) |
(*(*l_element_courant).donnee).objet)) |
| .thread).mutex)) != 0) |
.thread).nombre_objets_dans_pipe++; |
| |
} |
| |
else |
| |
{ |
| |
(*(*((struct_processus_fils *) |
| |
(*(*l_element_courant).donnee).objet)) |
| |
.thread) |
| |
.nombre_interruptions_dans_pipe++; |
| |
|
| |
if (pthread_mutex_lock(&((*s_etat_processus) |
| |
.mutex_interruptions)) != 0) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
| d_es_processus; |
d_es_processus; |
| } |
} |
| |
|
| (*(*((struct_processus_fils *) |
(*s_etat_processus) |
| (*(*l_element_courant).donnee).objet)) |
.nombre_interruptions_non_affectees++; |
| .thread).nombre_objets_dans_pipe++; |
|
| |
|
| if (pthread_mutex_unlock( |
if (pthread_mutex_unlock(&((*s_etat_processus) |
| &((*(*((struct_processus_fils *) |
.mutex_interruptions)) != 0) |
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).mutex)) != 0) |
|
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
| d_es_processus; |
d_es_processus; |
| } |
} |
| } |
} |
| |
|
| |
if (pthread_mutex_unlock( |
| |
&((*(*((struct_processus_fils *) |
| |
(*(*l_element_courant).donnee).objet)) |
| |
.thread).mutex)) != 0) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_processus; |
| |
} |
| } |
} |
| |
|
| break; |
break; |
| } |
} |
| |
|
| l_element_courant = (*l_element_courant).suivant; |
|
| } |
} |
| } |
else |
| else |
|
| { |
|
| while(l_element_courant != NULL) |
|
| { |
{ |
| if ((*(*((struct_processus_fils *) (*(*l_element_courant) |
if ((*(*((struct_processus_fils *) (*(*l_element_courant) |
| .donnee).objet)).thread).processus_detache |
.donnee).objet)).thread).tid == |
| == d_vrai) |
(*s_argument_thread).tid) |
| { |
|
| l_element_courant = (*l_element_courant).suivant; |
|
| continue; |
|
| } |
|
| |
|
| if (pthread_equal((*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)).thread).tid, |
|
| (*s_argument_thread).tid) != 0) |
|
| { |
{ |
| while(read_atomic(s_etat_processus, (*s_argument_thread) |
while(read_atomic(s_etat_processus, (*s_argument_thread) |
| .pipe_nombre_objets_attente[0], |
.pipe_nombre_elements_attente[0], |
| &tid_candidat, sizeof(tid_candidat)) == |
&caractere, sizeof(caractere)) == |
| sizeof(tid_candidat)) |
sizeof(caractere)) |
| { |
{ |
| /* |
if (caractere == 0) |
| * -1 est renvoyé par l'instruction SWI |
|
| */ |
|
| |
|
| if (tid_candidat == (pthread_t) -2) |
|
| { |
|
| break; |
|
| } |
|
| else if (tid_candidat == (pthread_t) -1) |
|
| { |
{ |
| |
continue; |
| } |
} |
| else if (read_atomic(s_etat_processus, |
|
| (*s_argument_thread) |
if ((*s_etat_processus).debug == d_vrai) |
| .pipe_nombre_objets_attente[0], |
if (((*s_etat_processus).type_debug & |
| &tid_candidat, sizeof(tid_candidat)) == |
d_debug_processus) != 0) |
| sizeof(tid_candidat)) |
|
| { |
{ |
| if ((*s_etat_processus).debug == d_vrai) |
if ((*s_etat_processus).langue == 'F') |
| if (((*s_etat_processus).type_debug & |
|
| d_debug_processus) != 0) |
|
| { |
{ |
| if ((*s_etat_processus).langue == 'F') |
if (caractere == 1) |
| { |
{ |
| printf("[%d] Données en provenance du " |
printf("[%d] Données en provenance du " |
| "thread %llu (thread " |
"thread %llu (processus " |
| "arrêté)\n", (int) getpid(), |
"arrêté)\n", (int) getpid(), |
| (unsigned long long) |
(unsigned long long) |
| (*s_argument_thread).tid); |
(*s_argument_thread).tid); |
| fflush(stdout); |
|
| } |
} |
| else |
else |
| { |
{ |
| printf("[%d] Data from thread %llu " |
printf("[%d] Interruption en " |
| "(thread stopped)\n", |
"provenance du " |
| (int) getpid(), |
"thread %llu (processus " |
| |
"arrêté)\n", (int) getpid(), |
| (unsigned long long) |
(unsigned long long) |
| (*s_argument_thread).tid); |
(*s_argument_thread).tid); |
| fflush(stdout); |
|
| } |
} |
| } |
|
| |
|
| if (pthread_mutex_lock( |
fflush(stdout); |
| &((*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).mutex)) != 0) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_processus; |
|
| } |
} |
| |
else |
| (*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).nombre_objets_dans_pipe++; |
|
| |
|
| if (pthread_mutex_unlock( |
|
| &((*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).mutex)) != 0) |
|
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
if (caractere == 1) |
| d_es_processus; |
|
| } |
|
| } |
|
| } |
|
| |
|
| break; |
|
| } |
|
| |
|
| l_element_courant = (*l_element_courant).suivant; |
|
| } |
|
| } |
|
| } |
|
| |
|
| l_element_courant = (struct_liste_chainee *) |
|
| (*s_etat_processus).l_base_pile_processus; |
|
| |
|
| if (drapeau_interruptions_traitees == d_faux) |
|
| { |
|
| if ((*s_argument_thread).processus_detache == d_vrai) |
|
| { |
|
| while(l_element_courant != NULL) |
|
| { |
|
| if ((*(*((struct_processus_fils *) (*(*l_element_courant) |
|
| .donnee).objet)).thread).processus_detache |
|
| == d_faux) |
|
| { |
|
| l_element_courant = (*l_element_courant).suivant; |
|
| continue; |
|
| } |
|
| |
|
| if ((*(*((struct_processus_fils *) (*(*l_element_courant) |
|
| .donnee).objet)).thread).pid == |
|
| (*s_argument_thread).pid) |
|
| { |
|
| while(read_atomic(s_etat_processus, (*s_argument_thread) |
|
| .pipe_nombre_interruptions_attente[0], |
|
| &pid_candidat, sizeof(pid_candidat)) == |
|
| sizeof(pid_candidat)) |
|
| { |
|
| if (pid_candidat == -2) |
|
| { |
|
| break; |
|
| } |
|
| else if (pid_candidat == -1) |
|
| { |
|
| } |
|
| else if (read_atomic(s_etat_processus, |
|
| (*s_argument_thread) |
|
| .pipe_nombre_interruptions_attente[0], |
|
| &pid_candidat, sizeof(pid_candidat)) == |
|
| sizeof(pid_candidat)) |
|
| { |
|
| if ((*s_etat_processus).debug == d_vrai) |
|
| if (((*s_etat_processus).type_debug & |
|
| d_traitement_interruption) != 0) |
|
| { |
|
| if ((*s_etat_processus).langue == 'F') |
|
| { |
{ |
| printf("[%d] Interruption logicielle " |
printf("[%d] Data from thread %llu " |
| "en provenance du processus %d" |
"(processus stopped)\n", |
| " (processus arrêté)\n", |
|
| (int) getpid(), |
(int) getpid(), |
| (int) (*s_argument_thread).pid); |
(unsigned long long) |
| fflush(stdout); |
(*s_argument_thread).pid); |
| } |
} |
| else |
else |
| { |
{ |
| printf("[%d] Software interrupt " |
printf("[%d] Interrupt from thread " |
| "from process %d (processus " |
"%llu (processus stopped)\n", |
| "stopped)\n", (int) getpid(), |
(int) getpid(), |
| (int) (*s_argument_thread).pid); |
(unsigned long long) |
| fflush(stdout); |
(*s_argument_thread).pid); |
| } |
} |
| } |
|
| |
|
| if (pthread_mutex_lock( |
|
| &((*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).mutex)) != 0) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_processus; |
|
| } |
|
| |
|
| (*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee) |
|
| .objet)).thread) |
|
| .nombre_interruptions_dans_pipe++; |
|
| |
|
| if (pthread_mutex_unlock( |
fflush(stdout); |
| &((*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).mutex)) != 0) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_processus; |
|
| } |
} |
| |
|
| (*s_etat_processus) |
|
| .nombre_interruptions_non_affectees++; |
|
| } |
} |
| } |
|
| |
|
| break; |
|
| } |
|
| |
|
| l_element_courant = (*l_element_courant).suivant; |
if (pthread_mutex_lock( |
| } |
&((*(*((struct_processus_fils *) |
| } |
(*(*l_element_courant).donnee).objet)) |
| else |
.thread).mutex)) != 0) |
| { |
|
| while(l_element_courant != NULL) |
|
| { |
|
| if ((*(*((struct_processus_fils *) (*(*l_element_courant) |
|
| .donnee).objet)).thread).processus_detache |
|
| == d_vrai) |
|
| { |
|
| l_element_courant = (*l_element_courant).suivant; |
|
| continue; |
|
| } |
|
| |
|
| if (pthread_equal((*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)).thread).tid, |
|
| (*s_argument_thread).tid) != 0) |
|
| { |
|
| while(read_atomic(s_etat_processus, (*s_argument_thread) |
|
| .pipe_nombre_interruptions_attente[0], |
|
| &tid_candidat, sizeof(tid_candidat)) == |
|
| sizeof(tid_candidat)) |
|
| { |
|
| if (tid_candidat == (pthread_t) -2) |
|
| { |
{ |
| break; |
(*s_etat_processus).erreur_systeme = |
| |
d_es_processus; |
| } |
} |
| else if (tid_candidat == (pthread_t) -1) |
|
| |
if (caractere == 1) |
| { |
{ |
| |
(*(*((struct_processus_fils *) |
| |
(*(*l_element_courant).donnee).objet)) |
| |
.thread).nombre_objets_dans_pipe++; |
| } |
} |
| else if (read_atomic(s_etat_processus, |
else |
| (*s_argument_thread) |
|
| .pipe_nombre_interruptions_attente[0], |
|
| &tid_candidat, sizeof(tid_candidat)) == |
|
| sizeof(tid_candidat)) |
|
| { |
{ |
| if ((*s_etat_processus).debug == d_vrai) |
(*(*((struct_processus_fils *) |
| if (((*s_etat_processus).type_debug & |
|
| d_traitement_interruption) != 0) |
|
| { |
|
| if ((*s_etat_processus).langue == 'F') |
|
| { |
|
| printf("[%d] Interruption logicielle " |
|
| "en provenance du thread %llu" |
|
| " (thread arrêté)\n", |
|
| (int) getpid(), |
|
| (unsigned long long) |
|
| (*s_argument_thread).tid); |
|
| fflush(stdout); |
|
| } |
|
| else |
|
| { |
|
| printf("[%d] Software interrupt " |
|
| "from thread %llu (thread " |
|
| "stopped)\n", (int) getpid(), |
|
| (unsigned long long) |
|
| (*s_argument_thread).tid); |
|
| fflush(stdout); |
|
| } |
|
| } |
|
| |
|
| if (pthread_mutex_lock( |
|
| &((*(*((struct_processus_fils *) |
|
| (*(*l_element_courant).donnee).objet)) |
(*(*l_element_courant).donnee).objet)) |
| .thread).mutex)) != 0) |
.thread) |
| |
.nombre_interruptions_dans_pipe++; |
| |
|
| |
if (pthread_mutex_lock(&((*s_etat_processus) |
| |
.mutex_interruptions)) != 0) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
| d_es_processus; |
d_es_processus; |
| } |
} |
| |
|
| (*(*((struct_processus_fils *) |
(*s_etat_processus) |
| (*(*l_element_courant).donnee) |
.nombre_interruptions_non_affectees++; |
| .objet)).thread) |
|
| .nombre_interruptions_dans_pipe++; |
|
| |
|
| if (pthread_mutex_unlock( |
if (pthread_mutex_unlock(&((*s_etat_processus) |
| &((*(*((struct_processus_fils *) |
.mutex_interruptions)) != 0) |
| (*(*l_element_courant).donnee).objet)) |
|
| .thread).mutex)) != 0) |
|
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
| d_es_processus; |
d_es_processus; |
| } |
} |
| |
} |
| |
|
| (*s_etat_processus) |
if (pthread_mutex_unlock( |
| .nombre_interruptions_non_affectees++; |
&((*(*((struct_processus_fils *) |
| |
(*(*l_element_courant).donnee).objet)) |
| |
.thread).mutex)) != 0) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_processus; |
| } |
} |
| } |
} |
| |
|
| break; |
break; |
| } |
} |
| |
|
| l_element_courant = (*l_element_courant).suivant; |
|
| } |
} |
| |
|
| |
l_element_courant = (*l_element_courant).suivant; |
| } |
} |
| } |
} |
| |
|
|
Line 1428 surveillance_processus(void *argument)
|
Line 1042 surveillance_processus(void *argument)
|
| attente.tv_nsec = GRANULARITE_us * 1000; |
attente.tv_nsec = GRANULARITE_us * 1000; |
| |
|
| while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0], |
while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0], |
| &((*s_etat_processus).erreur_execution_processus_fils), |
&tampon_erreur_execution, |
| sizeof((*s_etat_processus).erreur_execution_processus_fils)) != |
sizeof((*s_etat_processus).erreur_execution_processus_fils)) != |
| sizeof((*s_etat_processus).erreur_execution_processus_fils)) |
sizeof((*s_etat_processus).erreur_execution_processus_fils)) |
| { |
{ |
|
Line 1440 surveillance_processus(void *argument)
|
Line 1054 surveillance_processus(void *argument)
|
| attente.tv_nsec = GRANULARITE_us * 1000; |
attente.tv_nsec = GRANULARITE_us * 1000; |
| |
|
| while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0], |
while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0], |
| &tampon_erreur, |
&tampon_erreur_systeme, |
| sizeof((*s_etat_processus).erreur_systeme_processus_fils)) != |
sizeof((*s_etat_processus).erreur_systeme_processus_fils)) != |
| sizeof((*s_etat_processus).erreur_systeme_processus_fils)) |
sizeof((*s_etat_processus).erreur_systeme_processus_fils)) |
| { |
{ |
|
Line 1448 surveillance_processus(void *argument)
|
Line 1062 surveillance_processus(void *argument)
|
| INCR_GRANULARITE(attente.tv_nsec); |
INCR_GRANULARITE(attente.tv_nsec); |
| } |
} |
| |
|
| (*s_etat_processus).erreur_systeme_processus_fils = tampon_erreur; |
|
| |
|
| attente.tv_sec = 0; |
attente.tv_sec = 0; |
| attente.tv_nsec = GRANULARITE_us * 1000; |
attente.tv_nsec = GRANULARITE_us * 1000; |
| |
|
| while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0], |
while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0], |
| &((*s_etat_processus).pid_erreur_processus_fils), |
&pid_erreur, |
| sizeof((*s_etat_processus).pid_erreur_processus_fils)) != |
sizeof((*s_etat_processus).pid_erreur_processus_fils)) != |
| sizeof((*s_etat_processus).pid_erreur_processus_fils)) |
sizeof((*s_etat_processus).pid_erreur_processus_fils)) |
| { |
{ |
|
Line 1463 surveillance_processus(void *argument)
|
Line 1075 surveillance_processus(void *argument)
|
| } |
} |
| |
|
| /* |
/* |
| * Si une erreur est déclarée dans le processus fils, le message |
|
| * d'erreur a déjà été affiché. |
|
| */ |
|
| |
|
| if (((*s_etat_processus).erreur_systeme_processus_fils != d_es) || |
|
| ((*s_etat_processus).erreur_execution_processus_fils != d_ex)) |
|
| { |
|
| (*s_etat_processus).erreur_processus_fils = d_vrai; |
|
| (*s_etat_processus).invalidation_message_erreur = d_vrai; |
|
| } |
|
| |
|
| /* |
|
| * Retrait du processus de la pile des processus |
* Retrait du processus de la pile des processus |
| */ |
*/ |
| |
|
|
Line 1489 surveillance_processus(void *argument)
|
Line 1089 surveillance_processus(void *argument)
|
| } |
} |
| else |
else |
| { |
{ |
| |
(*s_etat_processus).erreur_execution_processus_fils = |
| |
tampon_erreur_execution; |
| |
(*s_etat_processus).erreur_systeme_processus_fils = |
| |
tampon_erreur_systeme; |
| |
(*s_etat_processus).pid_erreur_processus_fils = pid_erreur; |
| |
|
| |
/* |
| |
* Si une erreur est déclarée dans le processus fils, le message |
| |
* d'erreur a déjà été affiché. |
| |
*/ |
| |
|
| |
if (((*s_etat_processus).erreur_systeme_processus_fils != d_es) || |
| |
((*s_etat_processus).erreur_execution_processus_fils != d_ex)) |
| |
{ |
| |
(*s_etat_processus).erreur_processus_fils = d_vrai; |
| |
(*s_etat_processus).invalidation_message_erreur = d_vrai; |
| |
} |
| |
|
| do |
do |
| { |
{ |
| drapeau_fin = d_faux; |
drapeau_fin = d_faux; |
|
Line 1659 surveillance_processus(void *argument)
|
Line 1277 surveillance_processus(void *argument)
|
| } |
} |
| |
|
| if (close((*s_argument_thread) |
if (close((*s_argument_thread) |
| .pipe_nombre_objets_attente[0]) != 0) |
.pipe_nombre_elements_attente[0]) != 0) |
| { |
{ |
| (*s_etat_processus).erreur_systeme_processus_fils = |
(*s_etat_processus).erreur_systeme_processus_fils = |
| d_es_processus; |
d_es_processus; |
|
Line 1672 surveillance_processus(void *argument)
|
Line 1290 surveillance_processus(void *argument)
|
| d_es_processus; |
d_es_processus; |
| } |
} |
| |
|
| if (close((*s_argument_thread) |
|
| .pipe_nombre_interruptions_attente[0]) != 0) |
|
| { |
|
| (*s_etat_processus).erreur_systeme_processus_fils = |
|
| d_es_processus; |
|
| } |
|
| |
|
| drapeau_fin = d_vrai; |
drapeau_fin = d_vrai; |
| } |
} |
| else |
else |
|
Line 1752 surveillance_processus(void *argument)
|
Line 1363 surveillance_processus(void *argument)
|
| { |
{ |
| (*s_etat_processus).l_base_pile_processus = |
(*s_etat_processus).l_base_pile_processus = |
| (*l_element_courant).suivant; |
(*l_element_courant).suivant; |
| |
|
| free(l_element_courant); |
|
| |
|
| l_element_courant = (struct_liste_chainee *) |
|
| (*s_etat_processus).l_base_pile_processus; |
|
| } |
} |
| else |
else |
| { |
{ |
| (*l_element_precedent).suivant = |
(*l_element_precedent).suivant = |
| (*l_element_courant).suivant; |
(*l_element_courant).suivant; |
| free(l_element_courant); |
|
| } |
} |
| |
|
| |
liberation(s_etat_processus, (*l_element_courant).donnee); |
| |
free(l_element_courant); |
| |
|
| break; |
break; |
| } |
} |
| else |
else |
|
Line 1774 surveillance_processus(void *argument)
|
Line 1382 surveillance_processus(void *argument)
|
| } |
} |
| } |
} |
| |
|
| if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) |
if ((*s_etat_processus).debug == d_vrai) |
| { |
if (((*s_etat_processus).type_debug & |
| (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus; |
d_debug_processus) != 0) |
| } |
|
| } |
|
| |
|
| if ((*s_etat_processus).debug == d_vrai) |
|
| if (((*s_etat_processus).type_debug & |
|
| d_debug_processus) != 0) |
|
| { |
|
| if ((*s_argument_thread).processus_detache == d_vrai) |
|
| { |
{ |
| if ((*s_etat_processus).langue == 'F') |
if ((*s_argument_thread).processus_detache == d_vrai) |
| { |
{ |
| printf("[%d] Arrêt du thread de surveillance du" |
if ((*s_etat_processus).langue == 'F') |
| " processus %d\n", (int) getpid(), |
{ |
| (int) (*s_argument_thread).pid); |
printf("[%d] Arrêt du thread de surveillance du" |
| |
" processus %d\n", (int) getpid(), |
| |
(int) (*s_argument_thread).pid); |
| |
} |
| |
else |
| |
{ |
| |
printf("[%d] Stop monitoring of process %d", (int) getpid(), |
| |
(int) (*s_argument_thread).pid); |
| |
} |
| } |
} |
| else |
else |
| { |
{ |
| printf("[%d] Stop monitoring of process %d", (int) getpid(), |
if ((*s_etat_processus).langue == 'F') |
| (int) (*s_argument_thread).pid); |
{ |
| |
printf("[%d] Arrêt du thread de surveillance du" |
| |
" thread %llu\n", (int) getpid(), |
| |
(unsigned long long) (*s_argument_thread) |
| |
.tid); |
| |
} |
| |
else |
| |
{ |
| |
printf("[%d] Stop monitoring of thread %llu", |
| |
(int) getpid(), |
| |
(unsigned long long) (*s_argument_thread) |
| |
.tid); |
| |
} |
| } |
} |
| |
|
| |
fflush(stdout); |
| } |
} |
| else |
|
| |
retrait_thread_surveillance(s_etat_processus, s_argument_thread); |
| |
|
| |
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) |
| { |
{ |
| if ((*s_etat_processus).langue == 'F') |
(*s_etat_processus).erreur_systeme_processus_fils = d_es_processus; |
| { |
|
| printf("[%d] Arrêt du thread de surveillance du" |
|
| " thread %llu\n", (int) getpid(), |
|
| (unsigned long long) (*s_argument_thread) |
|
| .tid); |
|
| } |
|
| else |
|
| { |
|
| printf("[%d] Stop monitoring of thread %llu", (int) getpid(), |
|
| (unsigned long long) (*s_argument_thread) |
|
| .tid); |
|
| } |
|
| } |
} |
| |
|
| fflush(stdout); |
|
| } |
} |
| |
|
| retrait_thread_surveillance(s_etat_processus, s_argument_thread); |
|
| |
|
| pthread_exit(NULL); |
pthread_exit(NULL); |
| |
return(NULL); |
| } |
} |
| |
|
| |
|
|
Line 1845 ecriture_pipe(struct_processus *s_etat_p
|
Line 1455 ecriture_pipe(struct_processus *s_etat_p
|
| |
|
| struct timespec attente; |
struct timespec attente; |
| |
|
| unsigned long i; |
integer8 i; |
| unsigned long j; |
integer8 j; |
| |
|
| size_t longueur; |
size_t longueur; |
| ssize_t longueur_ecriture; |
ssize_t longueur_ecriture; |
|
Line 1976 ecriture_pipe(struct_processus *s_etat_p
|
Line 1586 ecriture_pipe(struct_processus *s_etat_p
|
| |
|
| while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
| &((*((struct_vecteur *) (*s_objet).objet)) |
&((*((struct_vecteur *) (*s_objet).objet)) |
| .taille), sizeof(unsigned long))) != sizeof(unsigned long)) |
.taille), sizeof(integer8))) != sizeof(integer8)) |
| { |
{ |
| if (longueur_ecriture == -1) |
if (longueur_ecriture == -1) |
| { |
{ |
|
Line 2029 ecriture_pipe(struct_processus *s_etat_p
|
Line 1639 ecriture_pipe(struct_processus *s_etat_p
|
| |
|
| while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
| &((*((struct_vecteur *) (*s_objet).objet)) |
&((*((struct_vecteur *) (*s_objet).objet)) |
| .taille), sizeof(unsigned long))) != sizeof(unsigned long)) |
.taille), sizeof(integer8))) != sizeof(integer8)) |
| { |
{ |
| if (longueur_ecriture == -1) |
if (longueur_ecriture == -1) |
| { |
{ |
|
Line 2082 ecriture_pipe(struct_processus *s_etat_p
|
Line 1692 ecriture_pipe(struct_processus *s_etat_p
|
| |
|
| while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
| &((*((struct_vecteur *) (*s_objet).objet)) |
&((*((struct_vecteur *) (*s_objet).objet)) |
| .taille), sizeof(unsigned long))) != sizeof(unsigned long)) |
.taille), sizeof(integer8))) != sizeof(integer8)) |
| { |
{ |
| if (longueur_ecriture == -1) |
if (longueur_ecriture == -1) |
| { |
{ |
|
Line 2135 ecriture_pipe(struct_processus *s_etat_p
|
Line 1745 ecriture_pipe(struct_processus *s_etat_p
|
| |
|
| while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
| &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes), |
&((*((struct_matrice *) (*s_objet).objet)).nombre_lignes), |
| sizeof(unsigned long))) != sizeof(unsigned long)) |
sizeof(integer8))) != sizeof(integer8)) |
| { |
{ |
| if (longueur_ecriture == -1) |
if (longueur_ecriture == -1) |
| { |
{ |
|
Line 2151 ecriture_pipe(struct_processus *s_etat_p
|
Line 1761 ecriture_pipe(struct_processus *s_etat_p
|
| |
|
| while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
| &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes), |
&((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes), |
| sizeof(unsigned long))) != sizeof(unsigned long)) |
sizeof(integer8))) != sizeof(integer8)) |
| { |
{ |
| if (longueur_ecriture == -1) |
if (longueur_ecriture == -1) |
| { |
{ |
|
Line 2210 ecriture_pipe(struct_processus *s_etat_p
|
Line 1820 ecriture_pipe(struct_processus *s_etat_p
|
| |
|
| while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
| &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes), |
&((*((struct_matrice *) (*s_objet).objet)).nombre_lignes), |
| sizeof(unsigned long))) != sizeof(unsigned long)) |
sizeof(integer8))) != sizeof(integer8)) |
| { |
{ |
| if (longueur_ecriture == -1) |
if (longueur_ecriture == -1) |
| { |
{ |
|
Line 2226 ecriture_pipe(struct_processus *s_etat_p
|
Line 1836 ecriture_pipe(struct_processus *s_etat_p
|
| |
|
| while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
| &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes), |
&((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes), |
| sizeof(unsigned long))) != sizeof(unsigned long)) |
sizeof(integer8))) != sizeof(integer8)) |
| { |
{ |
| if (longueur_ecriture == -1) |
if (longueur_ecriture == -1) |
| { |
{ |
|
Line 2285 ecriture_pipe(struct_processus *s_etat_p
|
Line 1895 ecriture_pipe(struct_processus *s_etat_p
|
| |
|
| while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
| &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes), |
&((*((struct_matrice *) (*s_objet).objet)).nombre_lignes), |
| sizeof(unsigned long))) != sizeof(unsigned long)) |
sizeof(integer8))) != sizeof(integer8)) |
| { |
{ |
| if (longueur_ecriture == -1) |
if (longueur_ecriture == -1) |
| { |
{ |
|
Line 2301 ecriture_pipe(struct_processus *s_etat_p
|
Line 1911 ecriture_pipe(struct_processus *s_etat_p
|
| |
|
| while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
| &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes), |
&((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes), |
| sizeof(unsigned long))) != sizeof(unsigned long)) |
sizeof(integer8))) != sizeof(integer8)) |
| { |
{ |
| if (longueur_ecriture == -1) |
if (longueur_ecriture == -1) |
| { |
{ |
|
Line 2495 ecriture_pipe(struct_processus *s_etat_p
|
Line 2105 ecriture_pipe(struct_processus *s_etat_p
|
| |
|
| while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
| &((*((struct_fonction *) (*s_objet).objet)).nombre_arguments), |
&((*((struct_fonction *) (*s_objet).objet)).nombre_arguments), |
| sizeof(unsigned long))) != sizeof(unsigned long)) |
sizeof(integer8))) != sizeof(integer8)) |
| { |
{ |
| if (longueur_ecriture == -1) |
if (longueur_ecriture == -1) |
| { |
{ |
|
Line 2637 ecriture_pipe(struct_processus *s_etat_p
|
Line 2247 ecriture_pipe(struct_processus *s_etat_p
|
| |
|
| while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
while((longueur_ecriture = write_atomic(s_etat_processus, pipe, |
| &((*((struct_tableau *) (*s_objet).objet)).nombre_elements), |
&((*((struct_tableau *) (*s_objet).objet)).nombre_elements), |
| sizeof(unsigned long))) != sizeof(unsigned long)) |
sizeof(integer8))) != sizeof(integer8)) |
| { |
{ |
| if (longueur_ecriture == -1) |
if (longueur_ecriture == -1) |
| { |
{ |
|
Line 2693 lecture_pipe(struct_processus *s_etat_pr
|
Line 2303 lecture_pipe(struct_processus *s_etat_pr
|
| |
|
| struct timespec attente; |
struct timespec attente; |
| |
|
| unsigned long i; |
integer8 i; |
| unsigned long j; |
integer8 j; |
| |
|
| if ((s_objet = allocation(s_etat_processus, NON)) == NULL) |
if ((s_objet = allocation(s_etat_processus, NON)) == NULL) |
| { |
{ |
|
Line 2781 lecture_pipe(struct_processus *s_etat_pr
|
Line 2391 lecture_pipe(struct_processus *s_etat_pr
|
| |
|
| while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *) |
while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *) |
| (*s_objet).objet)).taille), |
(*s_objet).objet)).taille), |
| sizeof(unsigned long)) != sizeof(unsigned long)) |
sizeof(integer8)) != sizeof(integer8)) |
| { |
{ |
| nanosleep(&attente, NULL); |
nanosleep(&attente, NULL); |
| INCR_GRANULARITE(attente.tv_nsec); |
INCR_GRANULARITE(attente.tv_nsec); |
| } |
} |
| |
|
| if (((*((struct_vecteur *) (*s_objet).objet)).tableau = |
if (((*((struct_vecteur *) (*s_objet).objet)).tableau = |
| malloc((*((struct_vecteur *) (*s_objet).objet)).taille * |
malloc(((size_t) (*((struct_vecteur *) (*s_objet).objet)) |
| sizeof(integer8))) == NULL) |
.taille) * sizeof(integer8))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
| return(NULL); |
return(NULL); |
|
Line 2825 lecture_pipe(struct_processus *s_etat_pr
|
Line 2435 lecture_pipe(struct_processus *s_etat_pr
|
| |
|
| while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *) |
while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *) |
| (*s_objet).objet)).taille), |
(*s_objet).objet)).taille), |
| sizeof(unsigned long)) != sizeof(unsigned long)) |
sizeof(integer8)) != sizeof(integer8)) |
| { |
{ |
| nanosleep(&attente, NULL); |
nanosleep(&attente, NULL); |
| INCR_GRANULARITE(attente.tv_nsec); |
INCR_GRANULARITE(attente.tv_nsec); |
| } |
} |
| |
|
| if (((*((struct_vecteur *) (*s_objet).objet)).tableau = |
if (((*((struct_vecteur *) (*s_objet).objet)).tableau = |
| malloc((*((struct_vecteur *) (*s_objet).objet)).taille * |
malloc(((size_t) (*((struct_vecteur *) (*s_objet).objet)) |
| sizeof(real8))) == NULL) |
.taille) * sizeof(real8))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
| return(NULL); |
return(NULL); |
|
Line 2869 lecture_pipe(struct_processus *s_etat_pr
|
Line 2479 lecture_pipe(struct_processus *s_etat_pr
|
| |
|
| while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *) |
while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *) |
| (*s_objet).objet)).taille), |
(*s_objet).objet)).taille), |
| sizeof(unsigned long)) != sizeof(unsigned long)) |
sizeof(integer8)) != sizeof(integer8)) |
| { |
{ |
| nanosleep(&attente, NULL); |
nanosleep(&attente, NULL); |
| INCR_GRANULARITE(attente.tv_nsec); |
INCR_GRANULARITE(attente.tv_nsec); |
| } |
} |
| |
|
| if (((*((struct_vecteur *) (*s_objet).objet)).tableau = |
if (((*((struct_vecteur *) (*s_objet).objet)).tableau = |
| malloc((*((struct_vecteur *) (*s_objet).objet)).taille * |
malloc(((size_t) (*((struct_vecteur *) (*s_objet).objet)) |
| sizeof(complex16))) == NULL) |
.taille) * sizeof(complex16))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
| return(NULL); |
return(NULL); |
|
Line 2913 lecture_pipe(struct_processus *s_etat_pr
|
Line 2523 lecture_pipe(struct_processus *s_etat_pr
|
| |
|
| while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *) |
while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *) |
| (*s_objet).objet)).nombre_lignes), |
(*s_objet).objet)).nombre_lignes), |
| sizeof(unsigned long)) != sizeof(unsigned long)) |
sizeof(integer8)) != sizeof(integer8)) |
| { |
{ |
| nanosleep(&attente, NULL); |
nanosleep(&attente, NULL); |
| INCR_GRANULARITE(attente.tv_nsec); |
INCR_GRANULARITE(attente.tv_nsec); |
|
Line 2924 lecture_pipe(struct_processus *s_etat_pr
|
Line 2534 lecture_pipe(struct_processus *s_etat_pr
|
| |
|
| while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *) |
while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *) |
| (*s_objet).objet)).nombre_colonnes), |
(*s_objet).objet)).nombre_colonnes), |
| sizeof(unsigned long)) != sizeof(unsigned long)) |
sizeof(integer8)) != sizeof(integer8)) |
| { |
{ |
| nanosleep(&attente, NULL); |
nanosleep(&attente, NULL); |
| INCR_GRANULARITE(attente.tv_nsec); |
INCR_GRANULARITE(attente.tv_nsec); |
| } |
} |
| |
|
| if (((*((struct_matrice *) (*s_objet).objet)).tableau = |
if (((*((struct_matrice *) (*s_objet).objet)).tableau = |
| malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes * |
malloc(((size_t) (*((struct_matrice *) (*s_objet).objet)) |
| sizeof(integer8 *))) == NULL) |
.nombre_lignes) * sizeof(integer8 *))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
| return(NULL); |
return(NULL); |
|
Line 2942 lecture_pipe(struct_processus *s_etat_pr
|
Line 2552 lecture_pipe(struct_processus *s_etat_pr
|
| (*s_objet).objet)).nombre_lignes; i++) |
(*s_objet).objet)).nombre_lignes; i++) |
| { |
{ |
| if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] = |
if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] = |
| malloc((*((struct_matrice *) (*s_objet).objet)) |
malloc(((size_t) (*((struct_matrice *) (*s_objet).objet)) |
| .nombre_colonnes * sizeof(integer8))) == NULL) |
.nombre_colonnes) * sizeof(integer8))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
| return(NULL); |
return(NULL); |
|
Line 2981 lecture_pipe(struct_processus *s_etat_pr
|
Line 2591 lecture_pipe(struct_processus *s_etat_pr
|
| |
|
| while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *) |
while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *) |
| (*s_objet).objet)).nombre_lignes), |
(*s_objet).objet)).nombre_lignes), |
| sizeof(unsigned long)) != sizeof(unsigned long)) |
sizeof(integer8)) != sizeof(integer8)) |
| { |
{ |
| nanosleep(&attente, NULL); |
nanosleep(&attente, NULL); |
| INCR_GRANULARITE(attente.tv_nsec); |
INCR_GRANULARITE(attente.tv_nsec); |
|
Line 2992 lecture_pipe(struct_processus *s_etat_pr
|
Line 2602 lecture_pipe(struct_processus *s_etat_pr
|
| |
|
| while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *) |
while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *) |
| (*s_objet).objet)).nombre_colonnes), |
(*s_objet).objet)).nombre_colonnes), |
| sizeof(unsigned long)) != sizeof(unsigned long)) |
sizeof(integer8)) != sizeof(integer8)) |
| { |
{ |
| nanosleep(&attente, NULL); |
nanosleep(&attente, NULL); |
| INCR_GRANULARITE(attente.tv_nsec); |
INCR_GRANULARITE(attente.tv_nsec); |
| } |
} |
| |
|
| if (((*((struct_matrice *) (*s_objet).objet)).tableau = |
if (((*((struct_matrice *) (*s_objet).objet)).tableau = |
| malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes * |
malloc(((size_t) (*((struct_matrice *) (*s_objet).objet)) |
| sizeof(real8 *))) == NULL) |
.nombre_lignes) * sizeof(real8 *))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
| return(NULL); |
return(NULL); |
|
Line 3010 lecture_pipe(struct_processus *s_etat_pr
|
Line 2620 lecture_pipe(struct_processus *s_etat_pr
|
| (*s_objet).objet)).nombre_lignes; i++) |
(*s_objet).objet)).nombre_lignes; i++) |
| { |
{ |
| if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] = |
if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] = |
| malloc((*((struct_matrice *) (*s_objet).objet)) |
malloc(((size_t) (*((struct_matrice *) (*s_objet).objet)) |
| .nombre_colonnes * sizeof(real8))) == NULL) |
.nombre_colonnes) * sizeof(real8))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
| return(NULL); |
return(NULL); |
|
Line 3049 lecture_pipe(struct_processus *s_etat_pr
|
Line 2659 lecture_pipe(struct_processus *s_etat_pr
|
| |
|
| while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *) |
while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *) |
| (*s_objet).objet)).nombre_lignes), |
(*s_objet).objet)).nombre_lignes), |
| sizeof(unsigned long)) != sizeof(unsigned long)) |
sizeof(integer8)) != sizeof(integer8)) |
| { |
{ |
| nanosleep(&attente, NULL); |
nanosleep(&attente, NULL); |
| INCR_GRANULARITE(attente.tv_nsec); |
INCR_GRANULARITE(attente.tv_nsec); |
|
Line 3060 lecture_pipe(struct_processus *s_etat_pr
|
Line 2670 lecture_pipe(struct_processus *s_etat_pr
|
| |
|
| while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *) |
while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *) |
| (*s_objet).objet)).nombre_colonnes), |
(*s_objet).objet)).nombre_colonnes), |
| sizeof(unsigned long)) != sizeof(unsigned long)) |
sizeof(integer8)) != sizeof(integer8)) |
| { |
{ |
| nanosleep(&attente, NULL); |
nanosleep(&attente, NULL); |
| INCR_GRANULARITE(attente.tv_nsec); |
INCR_GRANULARITE(attente.tv_nsec); |
| } |
} |
| |
|
| if (((*((struct_matrice *) (*s_objet).objet)).tableau = |
if (((*((struct_matrice *) (*s_objet).objet)).tableau = |
| malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes * |
malloc(((size_t) (*((struct_matrice *) (*s_objet).objet)) |
| sizeof(complex16 *))) == NULL) |
.nombre_lignes) * sizeof(complex16 *))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
| return(NULL); |
return(NULL); |
|
Line 3078 lecture_pipe(struct_processus *s_etat_pr
|
Line 2688 lecture_pipe(struct_processus *s_etat_pr
|
| (*s_objet).objet)).nombre_lignes; i++) |
(*s_objet).objet)).nombre_lignes; i++) |
| { |
{ |
| if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] = |
if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] = |
| malloc((*((struct_matrice *) (*s_objet).objet)) |
malloc(((size_t) (*((struct_matrice *) (*s_objet).objet)) |
| .nombre_colonnes * sizeof(complex16))) == NULL) |
.nombre_colonnes) * sizeof(complex16))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
| return(NULL); |
return(NULL); |
|
Line 3207 lecture_pipe(struct_processus *s_etat_pr
|
Line 2817 lecture_pipe(struct_processus *s_etat_pr
|
| |
|
| while(read_atomic(s_etat_processus, pipe, |
while(read_atomic(s_etat_processus, pipe, |
| &((*((struct_fonction *) (*s_objet).objet)) |
&((*((struct_fonction *) (*s_objet).objet)) |
| .nombre_arguments), sizeof(unsigned long)) != |
.nombre_arguments), sizeof(integer8)) != |
| sizeof(unsigned long)) |
sizeof(integer8)) |
| { |
{ |
| nanosleep(&attente, NULL); |
nanosleep(&attente, NULL); |
| INCR_GRANULARITE(attente.tv_nsec); |
INCR_GRANULARITE(attente.tv_nsec); |
|
Line 3328 lecture_pipe(struct_processus *s_etat_pr
|
Line 2938 lecture_pipe(struct_processus *s_etat_pr
|
| |
|
| while(read_atomic(s_etat_processus, pipe, &((*((struct_tableau *) |
while(read_atomic(s_etat_processus, pipe, &((*((struct_tableau *) |
| (*s_objet).objet)).nombre_elements), |
(*s_objet).objet)).nombre_elements), |
| sizeof(unsigned long)) != sizeof(unsigned long)) |
sizeof(integer8)) != sizeof(integer8)) |
| { |
{ |
| nanosleep(&attente, NULL); |
nanosleep(&attente, NULL); |
| INCR_GRANULARITE(attente.tv_nsec); |
INCR_GRANULARITE(attente.tv_nsec); |
| } |
} |
| |
|
| if (((*((struct_tableau *) (*s_objet).objet)).elements = malloc( |
if (((*((struct_tableau *) (*s_objet).objet)).elements = malloc( |
| (*((struct_tableau *) (*s_objet).objet)).nombre_elements * |
((size_t) (*((struct_tableau *) (*s_objet).objet)) |
| sizeof(struct_objet *))) == NULL) |
.nombre_elements) * sizeof(struct_objet *))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
| return(NULL); |
return(NULL); |
|
Line 3378 lecture_pipe(struct_processus *s_etat_pr
|
Line 2988 lecture_pipe(struct_processus *s_etat_pr
|
| ================================================================================ |
================================================================================ |
| */ |
*/ |
| |
|
| inline void |
void |
| scrutation_injection(struct_processus *s_etat_processus) |
scrutation_injection(struct_processus *s_etat_processus) |
| { |
{ |
| fd_set ensemble_descripteurs; |
fd_set ensemble_descripteurs; |
| |
|
| struct timespec timeout; |
logical1 drapeau_erreur; |
| |
logical1 registre_arret_si_exception; |
| |
|
| |
# ifdef PSELECT |
| |
struct timespec timeout; |
| |
# else |
| |
struct timeval timeout; |
| |
# endif |
| |
|
| unsigned char tampon; |
unsigned char tampon; |
| |
unsigned char tampon_profilage[20]; |
| |
|
| // Si on est dans le processus père, il n'y a rien à surveiller. |
// Si on est dans le processus père, il n'y a rien à surveiller. |
| |
|
| if ((*s_etat_processus).var_volatile_processus_pere == 0) |
scrutation_interruptions(s_etat_processus); |
| |
|
| |
if ((*s_etat_processus).var_volatile_processus_racine == 0) |
| { |
{ |
| FD_ZERO(&ensemble_descripteurs); |
FD_ZERO(&ensemble_descripteurs); |
| FD_SET((*s_etat_processus).pipe_nombre_injections, |
FD_SET((*s_etat_processus).pipe_nombre_injections, |
| &ensemble_descripteurs); |
&ensemble_descripteurs); |
| |
|
| |
# ifdef PSELECT |
| timeout.tv_sec = 0; |
timeout.tv_sec = 0; |
| timeout.tv_nsec = 0; |
timeout.tv_nsec = 0; |
| |
|
| if (pselect((*s_etat_processus).pipe_nombre_injections + 1, |
if (pselect((*s_etat_processus).pipe_nombre_injections + 1, |
| &ensemble_descripteurs, NULL, NULL, &timeout, NULL) > 0) |
&ensemble_descripteurs, NULL, NULL, &timeout, NULL) > 0) |
| |
# else |
| |
timeout.tv_sec = 0; |
| |
timeout.tv_usec = 0; |
| |
|
| |
if (select((*s_etat_processus).pipe_nombre_injections + 1, |
| |
&ensemble_descripteurs, NULL, NULL, &timeout) > 0) |
| |
# endif |
| { |
{ |
| if (read_atomic(s_etat_processus, |
if (read_atomic(s_etat_processus, |
| (*s_etat_processus).pipe_nombre_injections, |
(*s_etat_processus).pipe_nombre_injections, |
|
Line 3424 scrutation_injection(struct_processus *s
|
Line 3052 scrutation_injection(struct_processus *s
|
| } |
} |
| } |
} |
| } |
} |
| |
|
| |
/* |
| |
* Traitement de l'interruption d'injection |
| |
*/ |
| |
|
| |
if (((*s_etat_processus).nombre_objets_injectes != 0) && |
| |
((*s_etat_processus).traitement_at_poke == 'N')) |
| |
{ |
| |
if ((*s_etat_processus).at_poke != NULL) |
| |
{ |
| |
registre_arret_si_exception = |
| |
(*s_etat_processus).arret_si_exception; |
| |
(*s_etat_processus).arret_si_exception = d_vrai; |
| |
|
| |
if ((*s_etat_processus).debug == d_vrai) |
| |
if (((*s_etat_processus).type_debug & |
| |
d_traitement_interruption) != 0) |
| |
{ |
| |
if ((*s_etat_processus).langue == 'F') |
| |
{ |
| |
printf("[%d] Traitement de l'interruption " |
| |
"d'injection\n", (int) getpid()); |
| |
} |
| |
else |
| |
{ |
| |
printf("[%d] Start injection interrupt\n", |
| |
(int) getpid()); |
| |
} |
| |
|
| |
fflush(stdout); |
| |
} |
| |
|
| |
if ((*s_etat_processus).profilage == d_vrai) |
| |
{ |
| |
sprintf(tampon_profilage, "Injection interrupt"); |
| |
profilage(s_etat_processus, tampon_profilage); |
| |
|
| |
if ((*s_etat_processus).erreur_systeme != d_es) |
| |
{ |
| |
return; |
| |
} |
| |
} |
| |
|
| |
(*s_etat_processus).traitement_at_poke = 'Y'; |
| |
drapeau_erreur = evaluation(s_etat_processus, |
| |
(*s_etat_processus).at_poke, 'E'); |
| |
(*s_etat_processus).traitement_at_poke = 'N'; |
| |
|
| |
if ((*s_etat_processus).profilage == d_vrai) |
| |
{ |
| |
profilage(s_etat_processus, NULL); |
| |
} |
| |
|
| |
if (drapeau_erreur == d_absence_erreur) |
| |
{ |
| |
(*s_etat_processus).arret_si_exception = |
| |
registre_arret_si_exception; |
| |
} |
| |
else |
| |
{ |
| |
if ((((*s_etat_processus).erreur_execution != d_ex) || |
| |
((*s_etat_processus).exception != d_ep) || |
| |
((*s_etat_processus).erreur_systeme != d_es)) && |
| |
((*s_etat_processus).core == d_vrai) && |
| |
((*s_etat_processus) |
| |
.var_volatile_traitement_sigint == 0)) |
| |
{ |
| |
printf("\n"); |
| |
|
| |
if ((*s_etat_processus).langue == 'F') |
| |
{ |
| |
printf("+++Information : " |
| |
"Génération du fichier rpl-core " |
| |
"[%d]\n", (int) getpid()); |
| |
} |
| |
else |
| |
{ |
| |
printf("+++Information : " |
| |
"Writing rpl-core file [%d]\n", |
| |
(int) getpid()); |
| |
} |
| |
|
| |
rplcore(s_etat_processus); |
| |
|
| |
if ((*s_etat_processus).langue == 'F') |
| |
{ |
| |
printf("+++Information : " |
| |
"Processus tracé [%d]\n", |
| |
(int) getpid()); |
| |
} |
| |
else |
| |
{ |
| |
printf("+++Information : Done [%d]\n", |
| |
(int) getpid()); |
| |
} |
| |
|
| |
printf("\n"); |
| |
fflush(stdout); |
| |
} |
| |
|
| |
} |
| |
|
| |
if ((*s_etat_processus).debug == d_vrai) |
| |
if (((*s_etat_processus).type_debug & |
| |
d_traitement_interruption) != 0) |
| |
{ |
| |
if ((*s_etat_processus).langue == 'F') |
| |
{ |
| |
printf("[%d] Fin de l'interruption d'injection\n", |
| |
(int) getpid()); |
| |
} |
| |
else |
| |
{ |
| |
printf("[%d] Stop injection interrupt\n", |
| |
(int) getpid()); |
| |
} |
| |
|
| |
fflush(stdout); |
| |
} |
| |
|
| |
if ((drapeau_erreur == d_erreur) && |
| |
((*s_etat_processus).erreur_execution == d_ex)) |
| |
{ |
| |
if (((*s_etat_processus).erreur_execution == d_ex) && |
| |
((*s_etat_processus).erreur_systeme == d_es)) |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_erreur_evaluation; |
| |
} |
| |
} |
| |
} |
| |
} |
| |
|
| } |
} |
| |
|
| return; |
return; |
|
Line 3432 scrutation_injection(struct_processus *s
|
Line 3193 scrutation_injection(struct_processus *s
|
| |
|
| /* |
/* |
| ================================================================================ |
================================================================================ |
| Fonction de test du draeau d'arrêt |
Fonction de test du drapeau d'arrêt |
| ================================================================================ |
================================================================================ |
| Entrées : pointeur sur une structure |
Entrées : pointeur sur une structure |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
|
Line 3442 scrutation_injection(struct_processus *s
|
Line 3203 scrutation_injection(struct_processus *s
|
| ================================================================================ |
================================================================================ |
| */ |
*/ |
| |
|
| inline int test_arret(struct_processus *s_etat_processus) |
int |
| |
test_arret(struct_processus *s_etat_processus) |
| { |
{ |
| return((int) (*s_etat_processus).var_volatile_requete_arret); |
return((int) (*s_etat_processus).var_volatile_requete_arret); |
| } |
} |
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gestion_processus.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src