rpl/src/instructions_d5.c - diff

Return to instructions_d5.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_d5.c between versions 1.67 and 1.72

version 1.67, 2011/09/14 14:34:28	version 1.72, 2011/09/20 14:36:29
Line 814 instruction_der(struct_processus *s_etat	Line 814 instruction_der(struct_processus *s_etat
void	void
instruction_detach(struct_processus *s_etat_processus)	instruction_detach(struct_processus *s_etat_processus)
{	{
	int pipe_initialisation_segment_signaux[2];

logical1 drapeau;	logical1 drapeau;
logical1 variable_partagee;	logical1 variable_partagee;

Line 828 instruction_detach(struct_processus *s_e	Line 830 instruction_detach(struct_processus *s_e

sig_atomic_t registre_stop;	sig_atomic_t registre_stop;

sigset_t oldset;
sigset_t set;

ssize_t longueur_ecriture;	ssize_t longueur_ecriture;

struct_descripteur_thread *s_argument_thread;	struct_descripteur_thread *s_argument_thread;
Line 850 instruction_detach(struct_processus *s_e	Line 849 instruction_detach(struct_processus *s_e

struct timespec attente;	struct timespec attente;

	unsigned char caractere;
unsigned char *message;	unsigned char *message;

unsigned int erreur;	unsigned int erreur;
Line 1085 instruction_detach(struct_processus *s_e	Line 1085 instruction_detach(struct_processus *s_e
return;	return;
}	}

	if (pipe(pipe_initialisation_segment_signaux) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

ppid = getpid();	ppid = getpid();

/*	/*
Line 1104 instruction_detach(struct_processus *s_e	Line 1110 instruction_detach(struct_processus *s_e
* de mémoire, ni libération, ni copie d'objet concurrent au fork().	* de mémoire, ni libération, ni copie d'objet concurrent au fork().
*/	*/

sigfillset(&set);
pthread_sigmask(SIG_BLOCK, &set, &oldset);
verrouillage_threads_concurrents(s_etat_processus);	verrouillage_threads_concurrents(s_etat_processus);
(*s_argument_thread).pid = fork();	(*s_argument_thread).pid = fork();
deverrouillage_threads_concurrents(s_etat_processus);	deverrouillage_threads_concurrents(s_etat_processus);
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_argument_thread).thread_pere = pthread_self();	(*s_argument_thread).thread_pere = pthread_self();
(*s_argument_thread).processus_detache = d_vrai;	(*s_argument_thread).processus_detache = d_vrai;
Line 1278 instruction_detach(struct_processus *s_e	Line 1280 instruction_detach(struct_processus *s_e

(*s_etat_processus).pointeur_signal_lecture = 0;	(*s_etat_processus).pointeur_signal_lecture = 0;
(*s_etat_processus).pointeur_signal_ecriture = 0;	(*s_etat_processus).pointeur_signal_ecriture = 0;
(*s_etat_processus).tid_courant = pthread_self();
	if (write_atomic(s_etat_processus,
	pipe_initialisation_segment_signaux[1],
	"-", sizeof(unsigned char)) != sizeof(unsigned char))
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	}

	close(pipe_initialisation_segment_signaux[0]);
	close(pipe_initialisation_segment_signaux[1]);

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 1298 instruction_detach(struct_processus *s_e	Line 1309 instruction_detach(struct_processus *s_e
fflush(stdout);	fflush(stdout);
}	}

# ifndef SEMAPHORES_NOMMES
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_init(&semaphore_gestionnaires_signaux, 0, 0);
# else
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,
sem_gestionnaires_signaux);

if ((semaphore_gestionnaires_signaux = sem_init2(0,
sem_gestionnaires_signaux)) == SEM_FAILED)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
}
# endif

# ifndef SEMAPHORES_NOMMES
sem_post(&semaphore_liste_threads);
sem_destroy(&semaphore_liste_threads);
sem_init(&semaphore_liste_threads, 0, 1);
# else
sem_post(semaphore_liste_threads);
sem_destroy2(semaphore_liste_threads, sem_liste_threads);

if ((semaphore_liste_threads = sem_init2(1,
sem_liste_threads)) == SEM_FAILED)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
}
# endif

# ifndef SEMAPHORES_NOMMES
sem_destroy(&semaphore_gestionnaires_signaux_atomique);
sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);
sem_trywait(&((*s_etat_processus).semaphore_fork));
# else
sem_destroy2(semaphore_gestionnaires_signaux_atomique,
sem_gestionnaires_signaux_atomique);

if ((semaphore_gestionnaires_signaux_atomique = sem_init2(1,
sem_gestionnaires_signaux_atomique)) == SEM_FAILED)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
}

sem_trywait((*s_etat_processus).semaphore_fork);
# endif

# ifndef SEMAPHORES_NOMMES
if (pthread_setspecific(semaphore_fork_processus_courant,
&((*s_etat_processus).semaphore_fork)) != 0)
# else
if (pthread_setspecific(semaphore_fork_processus_courant,
(*s_etat_processus).semaphore_fork) != 0)
# endif
{
(*s_etat_processus).erreur_systeme = d_es_processus;
}

if (close((*s_argument_thread).pipe_erreurs[0]) != 0)	if (close((*s_argument_thread).pipe_erreurs[0]) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
Line 2478 instruction_detach(struct_processus *s_e	Line 2430 instruction_detach(struct_processus *s_e

nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
pthread_mutex_lock(&((*s_etat_processus).mutex));	pthread_mutex_lock(&((*s_etat_processus).mutex));

	scrutation_interruptions(s_etat_processus);
}	}

pthread_mutex_unlock(&((*s_etat_processus).mutex));	pthread_mutex_unlock(&((*s_etat_processus).mutex));
Line 2814 instruction_detach(struct_processus *s_e	Line 2768 instruction_detach(struct_processus *s_e
pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));	pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));	pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));

pthread_key_delete(semaphore_fork_processus_courant);

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_post((*s_etat_processus).semaphore_fork);	sem_post((*s_etat_processus).semaphore_fork);
sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork);	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
	pthread_self());
# endif	# endif

free((*s_etat_processus).localisation);	free((*s_etat_processus).localisation);
free(s_argument_thread);	free(s_argument_thread);

# ifndef SEMAPHORES_NOMMES
sem_destroy(&semaphore_liste_threads);
sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux_atomique);
# else
sem_destroy2(semaphore_liste_threads, sem_liste_threads);
sem_post(semaphore_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux,
sem_gestionnaires_signaux);
sem_destroy2(semaphore_gestionnaires_signaux_atomique,
sem_gestionnaires_signaux_atomique);
# endif

clear_history();	clear_history();

destruction_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);
Line 2903 instruction_detach(struct_processus *s_e	Line 2842 instruction_detach(struct_processus *s_e
}	}
}	}

	scrutation_interruptions(s_etat_processus);
l_element_courant = (*l_element_courant).suivant;	l_element_courant = (*l_element_courant).suivant;
}	}
} while(drapeau == d_vrai);	} while(drapeau == d_vrai);
Line 2922 instruction_detach(struct_processus *s_e	Line 2862 instruction_detach(struct_processus *s_e
return;	return;
}	}

// Être sûr que le processus fils soit déjà présent...	// On attend une donnée fictive pour être sûr que le segment de mémoire
	// partagée destiné à la gestion des signaux est bien initialisé.

attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = GRANULARITE_us * 1000;	attente.tv_nsec = GRANULARITE_us * 1000;

while(kill((*s_argument_thread).pid, 0) != 0)	while(read_atomic(s_etat_processus,
	pipe_initialisation_segment_signaux[0],
	&caractere, sizeof(caractere)) == 0)
{	{
//if ((errno != ESRCH) && (errno != EAGAIN))	scrutation_interruptions(s_etat_processus);
if (errno != ESRCH)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
pthread_mutex_unlock(&((*s_etat_processus).mutex));
return;
}

nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
}	}

	close(pipe_initialisation_segment_signaux[0]);
	close(pipe_initialisation_segment_signaux[1]);

// Le fils peut être présent sans être en attente du signal de départ.	// Le fils peut être présent sans être en attente du signal de départ.

if (envoi_signal_processus((*s_argument_thread).pid, rpl_sigstart) != 0)	if (envoi_signal_processus((*s_argument_thread).pid, rpl_sigstart) != 0)

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.67
changed lines
	Added in v.1.72