rpl/src/semaphores.c - diff

Return to semaphores.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/semaphores.c between versions 1.9 and 1.29

version 1.9, 2010/08/13 21:00:37	version 1.29, 2011/09/18 12:42:50
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.18	RPL/2 (R) version 4.1.3
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2011 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.

Line 24	Line 24

#ifdef SEMAPHORES_NOMMES	#ifdef SEMAPHORES_NOMMES

	// Les fonctions suivantes ne sont utilisées que dans le cas d'un
	// système POSIX qui ne possède pas de sémaphores anonymes. MacOS X
	// est dans ce cas.

	static unsigned char *
	nom_segment_semaphore(pid_t pid)
	{
	unsigned char *fichier;

	if ((fichier = malloc((1 + 256 + 1) * sizeof(unsigned char))) == NULL)
	{
	return(NULL);
	}

	sprintf(fichier, "/RPL-SIGSEMAPHORE-%d", (int) pid);
	return(fichier);
	}


/*	/*
================================================================================	================================================================================
Fonctions d'émulation de sémaphores anonymes	Fonctions d'émulation de sémaphores anonymes
Line 37	Line 56
*/	*/

sem_t *	sem_t *
sem_init2(unsigned int valeur, enum t_semaphore semaphore)	sem_init2(unsigned int valeur, pid_t pid)
{	{
snprintf(noms_semaphores[semaphore], LONGUEUR_NOM_SEMAPHORE,	sem_t *semaphore;
"/RPLSEM-%d-%llu-%d", (int) getpid(),
(unsigned long long) pthread_self(),	unsigned char *chemin;
(int) semaphore);
return(sem_open(noms_semaphores[semaphore], O_CREAT,	if ((chemin = nom_segment_semaphore(pid)) == NULL)
(S_IRUSR \| S_IWUSR), valeur));	{
	return(SEM_FAILED);
	}

	semaphore = sem_open(chemin, O_CREAT, (S_IRUSR \| S_IWUSR), valeur);
	free(chemin);

	return(semaphore);
}	}


	sem_t *
	sem_open2(pid_t pid)
	{
	unsigned char *chemin;

	sem_t *semaphore;

	if ((chemin = nom_segment_semaphore(pid)) == NULL)
	{
	return(1);
	}

	semaphore = sem_open(chemin, O_RDWR);
	free(chemin);

	return(semaphore);
	}


int	int
sem_destroy2(sem_t *semaphore_p, enum t_semaphore semaphore)	sem_destroy2(sem_t *semaphore, pid_t pid)
{	{
sem_close(semaphore_p);	int erreur;
return(sem_unlink(noms_semaphores[semaphore]));
	unsigned char *chemin;

	sem_close(semaphore);

	if ((chemin = nom_segment_semaphore(pid)) == NULL)
	{
	return(1);
	}

	erreur = sem_unlink(chemin);
	free(chemin);

	return(erreur);
}	}

#undef sem_post	#undef sem_post
Line 65 sem_getvalue2(sem_t semaphore, int val	Line 124 sem_getvalue2(sem_t semaphore, int val

logical1 drapeau_fin;	logical1 drapeau_fin;

	// Si on ne peut pas décrémenter le sémaphore, c'est qu'il était
	// déjà nul.
pthread_mutex_lock(&mutex_sem);	pthread_mutex_lock(&mutex_sem);

(*valeur) = 0;	(*valeur) = 0;
Line 107 sem_getvalue2(sem_t semaphore, int val	Line 168 sem_getvalue2(sem_t semaphore, int val

#endif	#endif

#ifdef SEMAPHORES_SYSV	#ifdef IPCS_SYSV

/*	/*
================================================================================	================================================================================
Line 125 sem_getvalue2(sem_t semaphore, int val	Line 186 sem_getvalue2(sem_t semaphore, int val
extern unsigned char *chemin_semaphores_SysV;	extern unsigned char *chemin_semaphores_SysV;
#else	#else
unsigned char racine_semaphores_OS2[] = "\\SEM32\\";	unsigned char racine_semaphores_OS2[] = "\\SEM32\\";
unsigned char racine_memoire_OS2[] = "\\SHAREDMEM\\";	unsigned char racine_memoire_OS2[] = "\\SHAREMEM\\";
#endif

#ifndef UNION_SEMUN
union semun
{
int val;
struct semid_ds *buf;
unsigned short *array;
struct seminfo *__buf;
};
#endif	#endif

int	int
sem_init_SysV(sem_t *semaphore, int shared, unsigned int valeur)	sem_init_SysV(sem_t *semaphore, int shared, unsigned int valeur)
{	{
	// Création d'un sémaphore anonyme qui devra être supprimé par
	// sem_destroy_SysV
# ifndef OS2	# ifndef OS2

int ios;	int ios;
Line 153 sem_init_SysV(sem_t *semaphore, int shar	Line 206 sem_init_SysV(sem_t *semaphore, int shar
return(-1);	return(-1);
}	}

(*semaphore) = semget(IPC_PRIVATE, 1, IPC_CREAT \| IPC_EXCL \| SEM_R \| SEM_A);	(*semaphore).sem = semget(IPC_PRIVATE, 1, IPC_CREAT \| IPC_EXCL \|
	S_IRUSR \| S_IWUSR);
	(*semaphore).path = NULL;
	(*semaphore).pid = getpid();

if ((*semaphore) == -1)	if ((*semaphore).sem == -1)
{	{
errno = EINVAL;	errno = EINVAL;
return(-1);	return(-1);
}	}

argument.val = valeur;	argument.val = valeur;
ios = semctl((*semaphore), 0, SETVAL, argument);	ios = semctl((*semaphore).sem, 0, SETVAL, argument);

return(ios);	return(ios);

Line 223 sem_init_SysV(sem_t *semaphore, int shar	Line 279 sem_init_SysV(sem_t *semaphore, int shar
int	int
sem_destroy_SysV(sem_t *semaphore)	sem_destroy_SysV(sem_t *semaphore)
{	{
	// Détruit un sémaphore anonmyme
# ifndef OS2	# ifndef OS2

if (semctl((*semaphore), IPC_RMID, 0) == -1)	if ((*semaphore).path != NULL)
	{
	return(EINVAL);
	}

	if ((*semaphore).pid != getpid())
	{
	return(0);
	}

	if (semctl((*semaphore).sem, 0, IPC_RMID) == -1)
{	{
return(EINVAL);	return(EINVAL);
}	}
Line 289 sem_wait_SysV(sem_t *semaphore)	Line 356 sem_wait_SysV(sem_t *semaphore)
commande.sem_op = -1;	commande.sem_op = -1;
commande.sem_flg = 0;	commande.sem_flg = 0;

if (semop((*semaphore), &commande, 1) == -1)	while(semop((*semaphore).sem, &commande, 1) == -1)
{	{
errno = EINVAL;	if (errno != EINTR)
return(-1);	{
	errno = EINVAL;
	return(-1);
	}
}	}

return(0);	return(0);
Line 344 sem_trywait_SysV(sem_t *semaphore)	Line 414 sem_trywait_SysV(sem_t *semaphore)
commande.sem_op = -1;	commande.sem_op = -1;
commande.sem_flg = IPC_NOWAIT;	commande.sem_flg = IPC_NOWAIT;

if (semop((*semaphore), &commande, 1) == -1)	while(semop((*semaphore).sem, &commande, 1) == -1)
{	{
return(-1);	if (errno != EINTR)
	{
	errno = EINVAL;
	return(-1);
	}
}	}

return(0);	return(0);
Line 400 sem_post_SysV(sem_t *semaphore)	Line 474 sem_post_SysV(sem_t *semaphore)
commande.sem_op = 1;	commande.sem_op = 1;
commande.sem_flg = 0;	commande.sem_flg = 0;

if (semop((*semaphore), &commande, 1) == -1)	while(semop((*semaphore).sem, &commande, 1) == -1)
{	{
errno = EINVAL;	if (errno != EINTR)
return(-1);	{
	errno = EINVAL;
	return(-1);
	}
}	}

return(0);	return(0);
Line 434 sem_getvalue_SysV(sem_t *semaphore, int	Line 511 sem_getvalue_SysV(sem_t *semaphore, int
{	{
# ifndef OS2	# ifndef OS2

(valeur) = semctl((semaphore), 0, GETVAL);	(valeur) = semctl((semaphore).sem, 0, GETVAL);

if ((*valeur) < 0)	if ((*valeur) < 0)
{	{
Line 473 sem_t	Line 550 sem_t
sem_t *semaphore;	sem_t *semaphore;

# ifndef OS2	# ifndef OS2
	file *desc;

	key_t clef;

union semun argument;	union semun argument;
# endif	# endif

Line 506 sem_t	Line 587 sem_t
return(SEM_FAILED);	return(SEM_FAILED);
}	}

(*psem).allocated = 1;

# else	# else

if ((nom_segment = malloc((strlen(racine_memoire_OS2) + strlen(nom) + 1)	if ((nom_segment = malloc((strlen(racine_memoire_OS2) + strlen(nom) + 1)
Line 555 sem_t	Line 634 sem_t
return(SEM_FAILED);	return(SEM_FAILED);
}	}

	(*psem).allocated = 1;

# endif	# endif

if ((oflag & O_CREAT) == 0)	if ((oflag & O_CREAT) == 0)
Line 563 sem_t	Line 644 sem_t

# ifndef OS2	# ifndef OS2

(*semaphore) = semget(ftok(nom_absolu, 1), 0, 0);	clef = ftok(nom_absolu, 1);

if ((*semaphore) == -1)	if (clef == -1)
	{
	return(SEM_FAILED);
	}

	(*semaphore).sem = semget(clef, 0, 0);
	(*semaphore).path = nom_absolu;
	(*semaphore).pid = getpid();

	if ((*semaphore).sem == -1)
{	{
free(semaphore);	free(semaphore);
free(nom_absolu);	free(nom_absolu);
Line 656 sem_t	Line 746 sem_t

# ifndef OS2	# ifndef OS2

(*semaphore) = semget(ftok(nom_absolu, 1), 1,	if ((desc = fopen(nom_absolu, "w")) == NULL)
((oflag & O_CREAT) == 0) ? 0 : IPC_CREAT \|	{
((oflag & O_EXCL) == 0) ? 0 : IPC_EXCL \|	free(semaphore);
((oflag & S_IRUSR) == 0) ? 0 : SEM_R \|	free(nom_absolu);
((oflag & S_IWUSR) == 0) ? 0 : SEM_A);
	return(SEM_FAILED);
	}

	fclose(desc);

	if ((clef = ftok(nom_absolu, 1)) == -1)
	{
	free(semaphore);
	free(nom_absolu);

	return(SEM_FAILED);
	}

if ((*semaphore) == -1)	(*semaphore).sem = semget(clef, 1,
	(((oflag & O_CREAT) == 0) ? 0 : IPC_CREAT) \|
	(((oflag & O_EXCL) == 0) ? 0 : IPC_EXCL) \|
	(int) mode);
	(*semaphore).path = nom_absolu;
	(*semaphore).pid = getpid();

	if ((*semaphore).sem == -1)
{	{
free(semaphore);	free(semaphore);
free(nom_absolu);	free(nom_absolu);
Line 671 sem_t	Line 780 sem_t
}	}

argument.val = valeur;	argument.val = valeur;
semctl((*semaphore), 0, SETVAL, argument);	semctl((*semaphore).sem, 0, SETVAL, argument);

# else	# else

Line 732 sem_t	Line 841 sem_t
# endif	# endif
}	}

free(nom_absolu);

return(semaphore);	return(semaphore);
}	}

int	int
sem_close_SysV(sem_t *semaphore)	sem_close_SysV(sem_t *semaphore)
{	{
	// Ferme un sémaphore nommé créé par sem_open_SysV()
# ifndef OS2	# ifndef OS2

	if ((*semaphore).path != NULL)
	{
	free((*semaphore).path);
	}

free(semaphore);	free(semaphore);
return(0);	return(0);

Line 789 sem_close_SysV(sem_t *semaphore)	Line 902 sem_close_SysV(sem_t *semaphore)
int	int
sem_unlink_SysV(const char *nom)	sem_unlink_SysV(const char *nom)
{	{
	// Détruit un sémaphore nommé créé par sem_open_SysV()
# ifndef OS2	# ifndef OS2

sem_t semaphore;

struct sembuf commande;

unsigned char *nom_absolu;	unsigned char *nom_absolu;

if ((nom_absolu = malloc((strlen(chemin_semaphores_SysV) + strlen(nom)	if ((nom_absolu = malloc((strlen(chemin_semaphores_SysV) + strlen(nom)
Line 804 sem_unlink_SysV(const char *nom)	Line 914 sem_unlink_SysV(const char *nom)
}	}

sprintf(nom_absolu, "%s%s", chemin_semaphores_SysV, nom);	sprintf(nom_absolu, "%s%s", chemin_semaphores_SysV, nom);
	semctl(semget(ftok(nom_absolu, 1), 0, 0), 0, IPC_RMID);
if ((semaphore = semget(ftok(nom_absolu, 1), 0, 0)) == -1)
{
free(nom_absolu);
return(EINVAL);
}

commande.sem_num = 0;
commande.sem_op = 0;
commande.sem_flg = 0;

if (semop(semaphore, &commande, 1) == -1)
{
free(nom_absolu);
return(EINVAL);
}

if (semctl(semaphore, IPC_RMID, 0) == -1)
{
free(nom_absolu);
return(EINVAL);
}

if (unlink(nom_absolu) == -1)	if (unlink(nom_absolu) == -1)
{	{

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.9
changed lines
	Added in v.1.29