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.44 and 1.67

version 1.44, 2012/04/13 14:13:04	version 1.67, 2015/01/05 15:32:25
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.8	RPL/2 (R) version 4.1.20
Copyright (C) 1989-2012 Dr. BERTRAND Joël	Copyright (C) 1989-2015 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 39 nom_segment_semaphore(pid_t pid, int ord	Line 37 nom_segment_semaphore(pid_t pid, int ord
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 54 nom_segment_semaphore_thread(pid_t pid,	Line 52 nom_segment_semaphore_thread(pid_t pid,
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 173 sem_destroy3(sem_t *semaphore, pid_t pid	Line 171 sem_destroy3(sem_t *semaphore, pid_t pid
}	}


#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 242 sem_getvalue2(sem_t semaphore, int val	Line 236 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 298 sem_init_SysV(sem_t *semaphore, int shar	Line 296 sem_init_SysV(sem_t *semaphore, int shar
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)
Line 330 sem_init_SysV(sem_t *semaphore, int shar	Line 330 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 453 sem_wait_SysV(sem_t *semaphore)	Line 453 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 517 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 559 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 863 sem_t	Line 923 sem_t
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 = malloc(sizeof(sem_t))) == NULL)
Line 981 sem_close_SysV(sem_t *semaphore)	Line 1041 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 1049 sem_unlink_SysV(const char *nom)

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

CVSweb interface <joel.bertrand@systella.fr>

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