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.42 and 1.89

version 1.42, 2012/01/17 14:44:13	version 1.89, 2020/01/10 11:15:51
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.6	RPL/2 (R) version 4.1.32
Copyright (C) 1989-2012 Dr. BERTRAND Joël	Copyright (C) 1989-2020 Dr. BERTRAND Joël

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

Line 23	Line 23
#include "rpl-conv.h"	#include "rpl-conv.h"


#ifdef SEMAPHORES_NOMMES

// Les fonctions suivantes ne sont utilisées que dans le cas d'un	// 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	// système POSIX qui ne possède pas de sémaphores anonymes. MacOS X
// est dans ce cas.	// est dans ce cas.
Line 34 nom_segment_semaphore(pid_t pid, int ord	Line 32 nom_segment_semaphore(pid_t pid, int ord
{	{
unsigned char *fichier;	unsigned char *fichier;

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

sprintf(fichier, "/RPL-%d-%d", (int) pid, ordre);	sprintf(fichier, "/RPL-%llu-%d", (unsigned long long) pid, ordre);
return(fichier);	return(fichier);
}	}

Line 49 nom_segment_semaphore_thread(pid_t pid,	Line 47 nom_segment_semaphore_thread(pid_t pid,
{	{
unsigned char *fichier;	unsigned char *fichier;

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

sprintf(fichier, "/RPL-%d-%llX-%d", (int) pid,	sprintf(fichier, "/RPL-%llu-%llu-%d", (unsigned long long) pid,
(unsigned long long) tid, ordre);	(unsigned long long) tid, ordre);
return(fichier);	return(fichier);
}	}
Line 78 sem_init2(unsigned int valeur, pid_t pid	Line 76 sem_init2(unsigned int valeur, pid_t pid
sem_t *semaphore;	sem_t *semaphore;

unsigned char *chemin;	unsigned char *chemin;
	unsigned char *langue;

if ((chemin = nom_segment_semaphore(pid, ordre)) == NULL)	if ((chemin = nom_segment_semaphore(pid, ordre)) == NULL)
{	{
return(SEM_FAILED);	return(SEM_FAILED);
}	}

semaphore = sem_open(chemin, O_RDWR \| O_CREAT \| O_EXCL, S_IRUSR \| S_IWUSR,	if ((semaphore = sem_open(chemin, O_RDWR \| O_CREAT \| O_EXCL,
valeur);	S_IRUSR \| S_IWUSR, valeur)) == SEM_FAILED)
free(chemin);	{
	if (errno == EEXIST)
	{
	if ((langue = getenv("LANG")) != NULL)
	{
	if (strncmp(langue, "fr", 2) == 0)
	{
	uprintf("+++Attention : Le sémaphore %s préexiste !\n",
	chemin);
	}
	else
	{
	uprintf("+++Warning: %s semaphore preexists!\n", chemin);
	}
	}
	else
	{
	uprintf("+++Warning: %s semaphore preexists!\n", chemin);
	}

	if (sem_unlink(chemin) != 0)
	{
	sys_free(chemin);
	return(SEM_FAILED);
	}

	semaphore = sem_open(chemin, O_RDWR \| O_CREAT \| O_EXCL,
	S_IRUSR \| S_IWUSR, valeur);
	}
	}

	sys_free(chemin);

return(semaphore);	return(semaphore);
}	}
Line 98 sem_init3(unsigned int valeur, pid_t pid	Line 128 sem_init3(unsigned int valeur, pid_t pid
sem_t *semaphore;	sem_t *semaphore;

unsigned char *chemin;	unsigned char *chemin;
	unsigned char *langue;

if ((chemin = nom_segment_semaphore_thread(pid, tid, ordre)) == NULL)	if ((chemin = nom_segment_semaphore_thread(pid, tid, ordre)) == NULL)
{	{
return(SEM_FAILED);	return(SEM_FAILED);
}	}

semaphore = sem_open(chemin, O_CREAT \| O_EXCL \| O_RDWR, S_IRUSR \| S_IWUSR,	if ((semaphore = sem_open(chemin, O_RDWR \| O_CREAT \| O_EXCL,
valeur);	S_IRUSR \| S_IWUSR, valeur)) == SEM_FAILED)
free(chemin);	{
	if (errno == EEXIST)
	{
	if ((langue = getenv("LANG")) != NULL)
	{
	if (strncmp(langue, "fr", 2) == 0)
	{
	uprintf("+++Attention : Le sémaphore %s préexiste !\n",
	chemin);
	}
	else
	{
	uprintf("+++Warning: %s semaphore preexists!\n", chemin);
	}
	}
	else
	{
	uprintf("+++Warning: %s semaphore preexists!\n", chemin);
	}

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

	sys_free(chemin);

return(semaphore);	return(semaphore);
}	}
Line 125 sem_open2(pid_t pid, int ordre)	Line 181 sem_open2(pid_t pid, int ordre)
}	}

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

return(semaphore);	return(semaphore);
}	}
Line 146 sem_destroy2(sem_t *semaphore, pid_t pid	Line 202 sem_destroy2(sem_t *semaphore, pid_t pid
}	}

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

return(erreur);	return(erreur);
}	}
Line 167 sem_destroy3(sem_t *semaphore, pid_t pid	Line 223 sem_destroy3(sem_t *semaphore, pid_t pid
}	}

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

return(erreur);	return(erreur);
}	}


#undef sem_post
#undef sem_wait
#undef sem_trywait

int	int
sem_getvalue2(sem_t semaphore, int valeur)	sem_getvalue2(sem_t semaphore, int valeur)
{	{
Line 232 sem_getvalue2(sem_t semaphore, int val	Line 284 sem_getvalue2(sem_t semaphore, int val
return(0);	return(0);
}	}

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

Line 242 sem_getvalue2(sem_t semaphore, int val	Line 295 sem_getvalue2(sem_t semaphore, int val
return(0);	return(0);
}	}

#endif
	#undef sem_post
	#undef sem_wait
	#undef sem_trywait


#ifdef IPCS_SYSV	#ifdef IPCS_SYSV

Line 279 sem_init_SysV(sem_t *semaphore, int shar	Line 336 sem_init_SysV(sem_t *semaphore, int shar

union semun argument;	union semun argument;

	unsigned char *langue;

if (shared == 0)	if (shared == 0)
{	{
// Sémaphore privé	// Sémaphore privé
Line 292 sem_init_SysV(sem_t *semaphore, int shar	Line 351 sem_init_SysV(sem_t *semaphore, int shar
else	else
{	{
// Sémaphore partagé entre plusieurs processus	// Sémaphore partagé entre plusieurs processus
if (((*semaphore).path = malloc((strlen(racine_segment)	if (((*semaphore).path = sys_malloc((strlen(racine_segment)
+ 2 + 256 + 1) * sizeof(unsigned char))) == NULL)	+ 2 + 256 + 1) * sizeof(unsigned char))) == NULL)
{	{
return(-1);	return(-1);
}	}

sprintf((*semaphore).path, "%s/RPL-SEMAPHORE-%d-%llX-%d",	sprintf((*semaphore).path, "%s/RPL-SEMAPHORE-%d-%llX-%llX",
racine_segment, (int) getpid(), pthread_self(), shared);	racine_segment, (int) getpid(),
	(long long unsigned) pthread_self(),
	(long long unsigned) semaphore);

if ((desc = open((*semaphore).path, O_RDWR \| O_CREAT \| O_EXCL,	if ((desc = open((*semaphore).path, O_RDWR \| O_CREAT \| O_EXCL,
S_IRUSR \| S_IWUSR)) == -1)	S_IRUSR \| S_IWUSR)) == -1)
{	{
free((*semaphore).path);	if (errno != EEXIST)
return(-1);	{
	sys_free((*semaphore).path);
	return(-1);
	}

	if ((langue = getenv("LANG")) != NULL)
	{
	if (strncmp(langue, "fr", 2) == 0)
	{
	uprintf("+++Attention : Le sémaphore %s préexiste !\n",
	(*semaphore).path);
	}
	else
	{
	uprintf("+++Warning: %s semaphore preexists!\n",
	(*semaphore).path);
	}
	}
	else
	{
	uprintf("+++Warning: %s semaphore preexists!\n",
	(*semaphore).path);
	}

	if ((desc = open((*semaphore).path, O_RDWR \| O_CREAT,
	S_IRUSR \| S_IWUSR)) == -1)
	{
	sys_free((*semaphore).path);
	return(-1);
	}
}	}

(*semaphore).pid = getpid();	(*semaphore).pid = getpid();
Line 315 sem_init_SysV(sem_t *semaphore, int shar	Line 405 sem_init_SysV(sem_t *semaphore, int shar

if (clef == -1)	if (clef == -1)
{	{
free((*semaphore).path);	sys_free((*semaphore).path);
return(-1);	return(-1);
}	}

Line 330 sem_init_SysV(sem_t *semaphore, int shar	Line 420 sem_init_SysV(sem_t *semaphore, int shar
return(-1);	return(-1);
}	}

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

return(ios);	return(ios);
Line 339 sem_init_SysV(sem_t *semaphore, int shar	Line 429 sem_init_SysV(sem_t *semaphore, int shar

psem = semaphore;	psem = semaphore;

if (((*psem).cnt = malloc(sizeof(ULONG))) == NULL)	if (((*psem).cnt = sys_malloc(sizeof(ULONG))) == NULL)
{	{
free(psem);	sys_free(psem);
errno = ENOMEM;	errno = ENOMEM;
return(-1);	return(-1);
}	}

if (((*psem).nopened = malloc(sizeof(ULONG))) == NULL)	if (((*psem).nopened = sys_malloc(sizeof(ULONG))) == NULL)
{	{
free((*psem).cnt);	sys_free((*psem).cnt);
free(psem);	sys_free(psem);
errno = ENOMEM;	errno = ENOMEM;
return(-1);	return(-1);
}	}

if (DosCreateMutexSem(NULL, &((*psem).hmtx), 0, 0) != 0)	if (DosCreateMutexSem(NULL, &((*psem).hmtx), 0, 0) != 0)
{	{
free((*psem).cnt);	sys_free((*psem).cnt);
free((*psem).nopened);	sys_free((*psem).nopened);
free(psem);	sys_free(psem);
return(-1);	return(-1);
}	}

Line 366 sem_init_SysV(sem_t *semaphore, int shar	Line 456 sem_init_SysV(sem_t *semaphore, int shar
!= 0)	!= 0)
{	{
DosCloseMutexSem((*psem).hmtx);	DosCloseMutexSem((*psem).hmtx);
free((*psem).cnt);	sys_free((*psem).cnt);
free((*psem).nopened);	sys_free((*psem).nopened);
free(psem);	sys_free(psem);
return(-1);	return(-1);
}	}

Line 427 sem_destroy_SysV(sem_t *semaphore)	Line 517 sem_destroy_SysV(sem_t *semaphore)

if ((*psem).shared == 0)	if ((*psem).shared == 0)
{	{
free((*psem).cnt);	sys_free((*psem).cnt);
free((*psem).nopened);	sys_free((*psem).nopened);
}	}
else	else
{	{
Line 440 sem_destroy_SysV(sem_t *semaphore)	Line 530 sem_destroy_SysV(sem_t *semaphore)

if ((*psem).allocated != 0)	if ((*psem).allocated != 0)
{	{
free(psem);	sys_free(psem);
}	}

return(0);	return(0);
Line 453 sem_wait_SysV(sem_t *semaphore)	Line 543 sem_wait_SysV(sem_t *semaphore)
# ifndef OS2 // IPCS_SYSV	# ifndef OS2 // IPCS_SYSV
struct sembuf commande;	struct sembuf commande;

	// semop() ne renvoie pas EINTR sur un signal !

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

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

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

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

return(0);	return(0);
Line 557 sem_trywait_SysV(sem_t *semaphore)	Line 649 sem_trywait_SysV(sem_t *semaphore)
# endif	# endif
}	}

	#ifndef timespeccmp
	# define timespeccmp(tsp, usp, cmp) \
	(((tsp)->tv_sec == (usp)->tv_sec) ? \
	((tsp)->tv_nsec cmp (usp)->tv_nsec) : \
	((tsp)->tv_sec cmp (usp)->tv_sec))
	# define timespecadd(tsp, usp, vsp) \
	do { \
	(vsp)->tv_sec = (tsp)->tv_sec + (usp)->tv_sec; \
	(vsp)->tv_nsec = (tsp)->tv_nsec + (usp)->tv_nsec; \
	if ((vsp)->tv_nsec >= 1000000000L) { \
	(vsp)->tv_sec++; \
	(vsp)->tv_nsec -= 1000000000L; \
	} \
	} while(0)
	# define timespecsub(tsp, usp, vsp) \
	do { \
	(vsp)->tv_sec = (tsp)->tv_sec - (usp)->tv_sec; \
	(vsp)->tv_nsec = (tsp)->tv_nsec - (usp)->tv_nsec; \
	if ((vsp)->tv_nsec < 0) { \
	(vsp)->tv_sec--; \
	(vsp)->tv_nsec += 1000000000L; \
	} \
	} while(0)
	#endif

	int
	sem_timedwait_SysV(sem_t sem, struct timespec ts)
	{
	struct timespec onems = { 0, 1000000 };
	struct timespec total = { 0, 0 };
	struct timespec unslept;
	struct timespec elapsed;
	struct timespec tmp;

	while(timespeccmp(ts, &total, >))
	{
	if (sem_trywait_SysV(sem) == 0)
	{
	return(0);
	}

	if (errno != EAGAIN)
	{
	return(-1);
	}

	nanosleep(&onems, &unslept);

	timespecsub(&onems, &unslept, &elapsed);
	timespecadd(&total, &elapsed, &tmp);
	total.tv_sec = tmp.tv_sec;
	total.tv_nsec = tmp.tv_nsec;
	}

	errno = ETIMEDOUT;
	return(-1);
	}

int	int
sem_post_SysV(sem_t *semaphore)	sem_post_SysV(sem_t *semaphore)
{	{
Line 641 sem_t	Line 791 sem_t
key_t clef;	key_t clef;

union semun argument;	union semun argument;

	unsigned char *langue;
# endif	# endif

unsigned char *nom_absolu;	unsigned char *nom_absolu;
Line 659 sem_t	Line 811 sem_t
# endif	# endif

# ifndef OS2 // IPCS_SYSV	# ifndef OS2 // IPCS_SYSV
if ((nom_absolu = malloc((strlen(racine_segment) + strlen(nom)	if ((nom_absolu = sys_malloc((strlen(racine_segment) + strlen(nom)
+ 2) * sizeof(unsigned char))) == NULL)	+ 2) * sizeof(unsigned char))) == NULL)
{	{
return(SEM_FAILED);	return(SEM_FAILED);
Line 667 sem_t	Line 819 sem_t

sprintf(nom_absolu, "%s/%s", racine_segment, nom);	sprintf(nom_absolu, "%s/%s", racine_segment, nom);

if ((semaphore = malloc(sizeof(sem_t))) == NULL)	if ((semaphore = sys_malloc(sizeof(sem_t))) == NULL)
{	{
return(SEM_FAILED);	return(SEM_FAILED);
}	}
Line 676 sem_t	Line 828 sem_t
(*semaphore).pid = getpid();	(*semaphore).pid = getpid();
(*semaphore).tid = pthread_self();	(*semaphore).tid = pthread_self();
# else	# else
if ((nom_segment = malloc((strlen(racine_memoire_OS2) + strlen(nom) + 1)	if ((nom_segment = sys_malloc((strlen(racine_memoire_OS2) + strlen(nom)
* sizeof(unsigned char))) == NULL)	+ 1) * sizeof(unsigned char))) == NULL)
{	{
return(SEM_FAILED);	return(SEM_FAILED);
}	}
Line 695 sem_t	Line 847 sem_t
ptr++;	ptr++;
}	}

if ((nom_absolu = malloc((strlen(racine_semaphores_OS2) + strlen(nom)	if ((nom_absolu = sys_malloc((strlen(racine_semaphores_OS2) +
+ 2) * sizeof(unsigned char))) == NULL)	strlen(nom) + 2) * sizeof(unsigned char))) == NULL)
{	{
return(SEM_FAILED);	return(SEM_FAILED);
}	}
Line 716 sem_t	Line 868 sem_t

(*(ptr + 1)) = d_code_fin_chaine;	(*(ptr + 1)) = d_code_fin_chaine;

if ((psem = malloc(sizeof(sem_t))) == NULL)	if ((psem = sys_malloc(sizeof(sem_t))) == NULL)
{	{
return(SEM_FAILED);	return(SEM_FAILED);
}	}
Line 742 sem_t	Line 894 sem_t

if ((*semaphore).sem == -1)	if ((*semaphore).sem == -1)
{	{
free(semaphore);	sys_free(semaphore);
free(nom_absolu);	sys_free(nom_absolu);

return(SEM_FAILED);	return(SEM_FAILED);
}	}
# else // OS/2	# else // OS/2
if ((psem = malloc(sizeof(sem_t))) == NULL)	if ((psem = sys_malloc(sizeof(sem_t))) == NULL)
{	{
free(nom_absolu);	sys_free(nom_absolu);
free(nom_segment);	sys_free(nom_segment);
return(SEM_FAILED);	return(SEM_FAILED);
}	}

Line 759 sem_t	Line 911 sem_t

if (DosOpenMutexSem(nom_absolu, &((*psem).hmtx)) != 0)	if (DosOpenMutexSem(nom_absolu, &((*psem).hmtx)) != 0)
{	{
free(psem);	sys_free(psem);
free(nom_absolu);	sys_free(nom_absolu);
free(nom_segment);	sys_free(nom_segment);

return(SEM_FAILED);	return(SEM_FAILED);
}	}
Line 772 sem_t	Line 924 sem_t
{	{
DosCloseMutexSem((*psem).hmtx);	DosCloseMutexSem((*psem).hmtx);

free(psem);	sys_free(psem);
free(nom_absolu);	sys_free(nom_absolu);
free(nom_segment);	sys_free(nom_segment);

return(SEM_FAILED);	return(SEM_FAILED);
}	}
Line 784 sem_t	Line 936 sem_t
{	{
DosCloseMutexSem((*psem).hmtx);	DosCloseMutexSem((*psem).hmtx);

free(nom_absolu);	sys_free(nom_absolu);
free(nom_segment);	sys_free(nom_segment);
free(psem);	sys_free(psem);

return(SEM_FAILED);	return(SEM_FAILED);
}	}

free(nom_segment);	sys_free(nom_segment);

(psem).cnt = (ULONG ) base;	(psem).cnt = (ULONG ) base;
(psem).nopened = ((ULONG ) base) + 1;	(psem).nopened = ((ULONG ) base) + 1;
Line 801 sem_t	Line 953 sem_t
{	{
DosCloseMutexSem((*psem).hmtx);	DosCloseMutexSem((*psem).hmtx);

free(nom_absolu);	sys_free(nom_absolu);
free(nom_segment);	sys_free(nom_segment);
free(psem);	sys_free(psem);

return(SEM_FAILED);	return(SEM_FAILED);
}	}
Line 831 sem_t	Line 983 sem_t
if ((desc = open(nom_absolu, O_CREAT \| O_EXCL \| O_RDWR,	if ((desc = open(nom_absolu, O_CREAT \| O_EXCL \| O_RDWR,
S_IRUSR \| S_IWUSR)) == -1)	S_IRUSR \| S_IWUSR)) == -1)
{	{
free(semaphore);	if (errno != EEXIST)
free(nom_absolu);	{
	sys_free(semaphore);
	sys_free(nom_absolu);
	return(SEM_FAILED);
	}

return(SEM_FAILED);	if ((langue = getenv("LANG")) != NULL)
	{
	if (strncmp(langue, "fr", 2) == 0)
	{
	uprintf("+++Attention : Le sémaphore %s préexiste !\n",
	nom_absolu);
	}
	else
	{
	uprintf("+++Warning: %s semaphore preexists!\n",
	nom_absolu);
	}
	}
	else
	{
	uprintf("+++Warning: %s semaphore preexists!\n",
	nom_absolu);
	}

	if ((desc = open(nom_absolu, O_CREAT \| O_RDWR,
	S_IRUSR \| S_IWUSR)) == -1)
	{
	sys_free(semaphore);
	sys_free(nom_absolu);
	return(SEM_FAILED);
	}
}	}

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

return(SEM_FAILED);	return(SEM_FAILED);
}	}
Line 857 sem_t	Line 1038 sem_t

if ((*semaphore).sem == -1)	if ((*semaphore).sem == -1)
{	{
free(semaphore);	sys_free(semaphore);
free(nom_absolu);	sys_free(nom_absolu);

return(SEM_FAILED);	return(SEM_FAILED);
}	}

argument.val = valeur;	argument.val = (int) valeur;
semctl((*semaphore).sem, 0, SETVAL, argument);	semctl((*semaphore).sem, 0, SETVAL, argument);
# else // OS/2	# else // OS/2
if ((psem = malloc(sizeof(sem_t))) == NULL)	if ((psem = sys_malloc(sizeof(sem_t))) == NULL)
{	{
free(nom_absolu);	sys_free(nom_absolu);
free(nom_segment);	sys_free(nom_segment);

return(SEM_FAILED);	return(SEM_FAILED);
}	}
Line 878 sem_t	Line 1059 sem_t

if (DosCreateMutexSem(nom_absolu, &((*psem).hmtx), 0, 0) != 0)	if (DosCreateMutexSem(nom_absolu, &((*psem).hmtx), 0, 0) != 0)
{	{
free(psem);	sys_free(psem);
free(nom_absolu);	sys_free(nom_absolu);
free(nom_segment);	sys_free(nom_segment);

return(SEM_FAILED);	return(SEM_FAILED);
}	}
Line 892 sem_t	Line 1073 sem_t
{	{
DosCloseMutexSem((*psem).hmtx);	DosCloseMutexSem((*psem).hmtx);

free(nom_absolu);	sys_free(nom_absolu);
free(nom_segment);	sys_free(nom_segment);
free(psem);	sys_free(psem);

return(SEM_FAILED);	return(SEM_FAILED);
}	}
Line 904 sem_t	Line 1085 sem_t
{	{
DosCloseMutexSem((*psem).hmtx);	DosCloseMutexSem((*psem).hmtx);

free(nom_absolu);	sys_free(nom_absolu);
free(nom_segment);	sys_free(nom_segment);
free(psem);	sys_free(psem);

return(SEM_FAILED);	return(SEM_FAILED);
}	}

free(nom_segment);	sys_free(nom_segment);

(psem).cnt = (ULONG ) base;	(psem).cnt = (ULONG ) base;
(psem).nopened = ((ULONG ) base) + 1;	(psem).nopened = ((ULONG ) base) + 1;
Line 932 sem_close_SysV(sem_t *semaphore)	Line 1113 sem_close_SysV(sem_t *semaphore)
# ifndef OS2 // IPCS_SYSV	# ifndef OS2 // IPCS_SYSV
if ((*semaphore).path != NULL)	if ((*semaphore).path != NULL)
{	{
free((*semaphore).path);	sys_free((*semaphore).path);
}	}

if ((*semaphore).alloue == -1)	if ((*semaphore).alloue == -1)
{	{
free(semaphore);	sys_free(semaphore);
}	}

return(0);	return(0);
Line 960 sem_close_SysV(sem_t *semaphore)	Line 1141 sem_close_SysV(sem_t *semaphore)

if ((*psem).shared == 0)	if ((*psem).shared == 0)
{	{
free((*psem).cnt);	sys_free((*psem).cnt);
free((*psem).nopened);	sys_free((*psem).nopened);
}	}
else	else
{	{
Line 973 sem_close_SysV(sem_t *semaphore)	Line 1154 sem_close_SysV(sem_t *semaphore)

if ((*psem).allocated != 0)	if ((*psem).allocated != 0)
{	{
free(psem);	sys_free(psem);
}	}

return(0);	return(0);
Line 981 sem_close_SysV(sem_t *semaphore)	Line 1162 sem_close_SysV(sem_t *semaphore)
}	}

int	int
sem_unlink_SysV(const char *nom)	sem_unlink_SysV(char *nom)
{	{
// Détruit un sémaphore nommé créé par sem_open_SysV()	// Détruit un sémaphore nommé créé par sem_open_SysV()
# ifndef OS2 // IPCS_SYSV	# ifndef OS2 // IPCS_SYSV
Line 989 sem_unlink_SysV(const char *nom)	Line 1170 sem_unlink_SysV(const char *nom)

if (unlink(nom) == -1)	if (unlink(nom) == -1)
{	{
free(nom_absolu);
return(EACCES);	return(EACCES);
}	}

free(nom);	sys_free(nom);
return(0);	return(0);
# else	# else
return(0);	return(0);

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.42
changed lines
	Added in v.1.89