version 1.31, 2011/09/18 18:45:31
|
version 1.33, 2011/09/20 07:16:40
|
Line 208 sem_getvalue2(sem_t *semaphore, int *val
|
Line 208 sem_getvalue2(sem_t *semaphore, int *val
|
================================================================================ |
================================================================================ |
*/ |
*/ |
|
|
#ifndef OS2 |
#ifndef OS2 // IPCS_SYSV |
extern unsigned char *chemin_semaphores_SysV; |
extern unsigned char *racine_segment; |
#else |
#else // OS/2 |
unsigned char racine_semaphores_OS2[] = "\\SEM32\\"; |
unsigned char racine_semaphores_OS2[] = "\\SEM32\\"; |
unsigned char racine_memoire_OS2[] = "\\SHAREMEM\\"; |
unsigned char racine_memoire_OS2[] = "\\SHAREMEM\\"; |
#endif |
#endif |
Line 220 sem_init_SysV(sem_t *semaphore, int shar
|
Line 220 sem_init_SysV(sem_t *semaphore, int shar
|
{ |
{ |
// Création d'un sémaphore anonyme qui devra être supprimé par |
// Création d'un sémaphore anonyme qui devra être supprimé par |
// sem_destroy_SysV |
// sem_destroy_SysV |
# ifndef OS2 |
|
|
|
int ios; |
|
|
|
union semun argument; |
|
|
|
if (shared != 0) |
# ifndef OS2 // IPCS_SYSV |
{ |
int desc; |
errno = ENOSYS; |
int ios; |
return(-1); |
|
} |
key_t clef; |
|
|
(*semaphore).sem = semget(IPC_PRIVATE, 1, IPC_CREAT | IPC_EXCL | |
union semun argument; |
S_IRUSR | S_IWUSR); |
|
(*semaphore).path = NULL; |
if (shared == 0) |
(*semaphore).pid = getpid(); |
{ |
|
// Sémaphore privé |
if ((*semaphore).sem == -1) |
(*semaphore).sem = semget(IPC_PRIVATE, 1, IPC_CREAT | IPC_EXCL | |
{ |
S_IRUSR | S_IWUSR); |
errno = EINVAL; |
(*semaphore).path = NULL; |
return(-1); |
(*semaphore).pid = getpid(); |
} |
(*semaphore).alloue = 0; |
|
} |
|
else |
|
{ |
|
// Sémaphore partagé entre plusieurs processus |
|
if (((*semaphore).path = malloc((strlen(racine_segment) |
|
+ 1 + 32 + 1) * sizeof(unsigned char))) == NULL) |
|
{ |
|
return(-1); |
|
} |
|
|
|
sprintf((*semaphore).path, "%s/RPL-SIGSEMAPHORE-%d", racine_segment, |
|
(int) getpid()); |
|
|
|
if ((desc = open((*semaphore).path, O_RDWR | O_CREAT | O_EXCL, |
|
S_IRUSR | S_IWUSR)) == -1) |
|
{ |
|
free((*semaphore).path); |
|
return(-1); |
|
} |
|
|
|
(*semaphore).pid = getpid(); |
|
clef = ftok((*semaphore).path, 1); |
|
close(desc); |
|
|
|
if (clef == -1) |
|
{ |
|
free((*semaphore).path); |
|
return(-1); |
|
} |
|
|
|
(*semaphore).alloue = 0; |
|
(*semaphore).sem = semget(clef, 1, IPC_CREAT | IPC_EXCL | |
|
S_IRUSR | S_IWUSR); |
|
} |
|
|
argument.val = valeur; |
if ((*semaphore).sem == -1) |
ios = semctl((*semaphore).sem, 0, SETVAL, argument); |
{ |
|
errno = EINVAL; |
|
return(-1); |
|
} |
|
|
return(ios); |
argument.val = valeur; |
|
ios = semctl((*semaphore).sem, 0, SETVAL, argument); |
|
|
# else |
return(ios); |
|
# else // OS/2 |
|
|
sem_t *psem; |
sem_t *psem; |
|
|
Line 306 int
|
Line 340 int
|
sem_destroy_SysV(sem_t *semaphore) |
sem_destroy_SysV(sem_t *semaphore) |
{ |
{ |
// Détruit un sémaphore anonmyme |
// Détruit un sémaphore anonmyme |
# ifndef OS2 |
|
|
|
if ((*semaphore).path != NULL) |
|
{ |
|
return(EINVAL); |
|
} |
|
|
|
if ((*semaphore).pid != getpid()) |
# ifndef OS2 // IPCS_SYSV |
{ |
if ((*semaphore).path != NULL) |
return(0); |
{ |
} |
return(EINVAL); |
|
} |
|
|
if (semctl((*semaphore).sem, 0, IPC_RMID) == -1) |
if ((*semaphore).pid != getpid()) |
{ |
{ |
return(EINVAL); |
return(0); |
} |
} |
|
|
return(0); |
if (semctl((*semaphore).sem, 0, IPC_RMID) == -1) |
|
{ |
|
return(EINVAL); |
|
} |
|
|
# else |
return(0); |
|
# else // OS/2 |
|
|
sem_t *psem; |
sem_t *psem; |
|
|
Line 374 sem_destroy_SysV(sem_t *semaphore)
|
Line 407 sem_destroy_SysV(sem_t *semaphore)
|
int |
int |
sem_wait_SysV(sem_t *semaphore) |
sem_wait_SysV(sem_t *semaphore) |
{ |
{ |
# ifndef OS2 |
# ifndef OS2 // IPCS_SYSV |
|
struct sembuf commande; |
|
|
struct sembuf commande; |
commande.sem_num = 0; |
|
commande.sem_op = -1; |
commande.sem_num = 0; |
commande.sem_flg = 0; |
commande.sem_op = -1; |
|
commande.sem_flg = 0; |
while(semop((*semaphore).sem, &commande, 1) == -1) |
|
{ |
while(semop((*semaphore).sem, &commande, 1) == -1) |
if (errno != EINTR) |
{ |
{ |
if (errno != EINTR) |
errno = EINVAL; |
{ |
return(-1); |
errno = EINVAL; |
} |
return(-1); |
|
} |
} |
} |
|
|
|
return(0); |
|
|
|
# else |
return(0); |
|
# else // OS/2 |
|
|
sem_t *psem; |
sem_t *psem; |
|
|
Line 432 sem_wait_SysV(sem_t *semaphore)
|
Line 463 sem_wait_SysV(sem_t *semaphore)
|
int |
int |
sem_trywait_SysV(sem_t *semaphore) |
sem_trywait_SysV(sem_t *semaphore) |
{ |
{ |
# ifndef OS2 |
# ifndef OS2 // IPCS_SYSV |
|
struct sembuf commande; |
struct sembuf commande; |
|
|
|
commande.sem_num = 0; |
|
commande.sem_op = -1; |
|
commande.sem_flg = IPC_NOWAIT; |
|
|
|
while(semop((*semaphore).sem, &commande, 1) == -1) |
commande.sem_num = 0; |
{ |
commande.sem_op = -1; |
if (errno != EINTR) |
commande.sem_flg = IPC_NOWAIT; |
{ |
|
errno = EINVAL; |
while(semop((*semaphore).sem, &commande, 1) == -1) |
return(-1); |
{ |
|
if (errno != EINTR) |
|
{ |
|
errno = EINVAL; |
|
return(-1); |
|
} |
} |
} |
} |
|
|
|
return(0); |
|
|
|
# else |
return(0); |
|
# else // OS/2 |
|
|
int ios; |
int ios; |
|
|
Line 492 sem_trywait_SysV(sem_t *semaphore)
|
Line 521 sem_trywait_SysV(sem_t *semaphore)
|
int |
int |
sem_post_SysV(sem_t *semaphore) |
sem_post_SysV(sem_t *semaphore) |
{ |
{ |
# ifndef OS2 |
# ifndef OS2 // IPCS_SYSV |
|
struct sembuf commande; |
|
|
struct sembuf commande; |
commande.sem_num = 0; |
|
commande.sem_op = 1; |
commande.sem_num = 0; |
commande.sem_flg = 0; |
commande.sem_op = 1; |
|
commande.sem_flg = 0; |
while(semop((*semaphore).sem, &commande, 1) == -1) |
|
{ |
while(semop((*semaphore).sem, &commande, 1) == -1) |
if (errno != EINTR) |
{ |
{ |
if (errno != EINTR) |
errno = EINVAL; |
{ |
return(-1); |
errno = EINVAL; |
} |
return(-1); |
|
} |
} |
} |
|
|
|
return(0); |
return(0); |
|
# else // OS/2 |
# else |
|
|
|
sem_t *psem; |
sem_t *psem; |
|
|
Line 535 sem_post_SysV(sem_t *semaphore)
|
Line 562 sem_post_SysV(sem_t *semaphore)
|
int |
int |
sem_getvalue_SysV(sem_t *semaphore, int *valeur) |
sem_getvalue_SysV(sem_t *semaphore, int *valeur) |
{ |
{ |
# ifndef OS2 |
# ifndef OS2 // IPCS_SYSV |
|
(*valeur) = semctl((*semaphore).sem, 0, GETVAL); |
(*valeur) = semctl((*semaphore).sem, 0, GETVAL); |
|
|
|
if ((*valeur) < 0) |
if ((*valeur) < 0) |
{ |
{ |
return(EINVAL); |
return(EINVAL); |
} |
} |
|
|
return(0); |
|
|
|
|
return(0); |
# else |
# else |
|
|
sem_t *psem; |
sem_t *psem; |
Line 576 sem_t
|
Line 601 sem_t
|
sem_t *semaphore; |
sem_t *semaphore; |
|
|
# ifndef OS2 |
# ifndef OS2 |
file *desc; |
int desc; |
|
|
key_t clef; |
key_t clef; |
|
|
union semun argument; |
union semun argument; |
# endif |
# endif |
|
|
unsigned char *nom_absolu; |
unsigned char *nom_absolu; |
Line 590 sem_t
|
Line 615 sem_t
|
va_list liste; |
va_list liste; |
|
|
# ifdef OS2 |
# ifdef OS2 |
sem_t *psem; |
sem_t *psem; |
|
|
PVOID base; |
PVOID base; |
|
|
unsigned char *ptr; |
unsigned char *ptr; |
unsigned char *nom_segment; |
unsigned char *nom_segment; |
# endif |
# endif |
|
|
# ifndef OS2 |
# ifndef OS2 // IPCS_SYSV |
|
if ((nom_absolu = malloc((strlen(racine_segment) + strlen(nom) |
if ((nom_absolu = malloc((strlen(chemin_semaphores_SysV) + strlen(nom) |
+ 2) * sizeof(unsigned char))) == NULL) |
+ 1) * sizeof(unsigned char))) == NULL) |
{ |
{ |
return(SEM_FAILED); |
return(SEM_FAILED); |
} |
} |
|
|
|
sprintf(nom_absolu, "%s%s", chemin_semaphores_SysV, nom); |
sprintf(nom_absolu, "%s/%s", racine_segment, nom); |
|
|
if ((semaphore = malloc(sizeof(sem_t))) == NULL) |
if ((semaphore = malloc(sizeof(sem_t))) == NULL) |
{ |
{ |
return(SEM_FAILED); |
return(SEM_FAILED); |
} |
} |
|
|
|
(*semaphore).alloue = -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 668 sem_t
|
Line 693 sem_t
|
{ |
{ |
// 2 arguments |
// 2 arguments |
|
|
# ifndef OS2 |
# ifndef OS2 // IPCS_SYSV |
|
clef = ftok(nom_absolu, 1); |
clef = ftok(nom_absolu, 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(nom_absolu); |
|
|
|
return(SEM_FAILED); |
|
} |
|
|
|
# else |
|
|
|
|
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(nom_absolu); |
|
|
|
return(SEM_FAILED); |
|
} |
|
# else // OS/2 |
if ((psem = malloc(sizeof(sem_t))) == NULL) |
if ((psem = malloc(sizeof(sem_t))) == NULL) |
{ |
{ |
free(nom_absolu); |
free(nom_absolu); |
Line 770 sem_t
|
Line 792 sem_t
|
valeur = va_arg(liste, unsigned int); |
valeur = va_arg(liste, unsigned int); |
va_end(liste); |
va_end(liste); |
|
|
# ifndef OS2 |
# ifndef OS2 // IPCS_SYSV |
|
if ((desc = open(nom_absolu, O_CREAT | O_EXCL | O_RDWR, |
if ((desc = fopen(nom_absolu, "w")) == NULL) |
S_IRUSR | S_IWUSR)) == -1) |
{ |
{ |
free(semaphore); |
free(semaphore); |
free(nom_absolu); |
free(nom_absolu); |
|
|
return(SEM_FAILED); |
return(SEM_FAILED); |
} |
} |
|
|
fclose(desc); |
if ((clef = ftok(nom_absolu, 1)) == -1) |
|
{ |
if ((clef = ftok(nom_absolu, 1)) == -1) |
close(desc); |
{ |
free(semaphore); |
free(semaphore); |
free(nom_absolu); |
free(nom_absolu); |
|
|
return(SEM_FAILED); |
return(SEM_FAILED); |
} |
} |
|
|
close(desc); |
(*semaphore).sem = semget(clef, 1, |
|
(((oflag & O_CREAT) == 0) ? 0 : IPC_CREAT) | |
(*semaphore).sem = semget(clef, 1, |
(((oflag & O_EXCL) == 0) ? 0 : IPC_EXCL) | |
(((oflag & O_CREAT) == 0) ? 0 : IPC_CREAT) | |
(int) mode); |
(((oflag & O_EXCL) == 0) ? 0 : IPC_EXCL) | |
(*semaphore).path = nom_absolu; |
(int) mode); |
(*semaphore).pid = getpid(); |
(*semaphore).path = nom_absolu; |
|
(*semaphore).pid = getpid(); |
if ((*semaphore).sem == -1) |
|
{ |
if ((*semaphore).sem == -1) |
free(semaphore); |
{ |
free(nom_absolu); |
free(semaphore); |
|
free(nom_absolu); |
return(SEM_FAILED); |
|
} |
return(SEM_FAILED); |
|
} |
argument.val = valeur; |
|
semctl((*semaphore).sem, 0, SETVAL, argument); |
argument.val = valeur; |
|
semctl((*semaphore).sem, 0, SETVAL, argument); |
# else |
# else // OS/2 |
|
|
if ((psem = malloc(sizeof(sem_t))) == NULL) |
if ((psem = malloc(sizeof(sem_t))) == NULL) |
{ |
{ |
Line 874 int
|
Line 896 int
|
sem_close_SysV(sem_t *semaphore) |
sem_close_SysV(sem_t *semaphore) |
{ |
{ |
// Ferme un sémaphore nommé créé par sem_open_SysV() |
// Ferme un sémaphore nommé créé par sem_open_SysV() |
# ifndef OS2 |
# ifndef OS2 // IPCS_SYSV |
|
if ((*semaphore).path != NULL) |
if ((*semaphore).path != NULL) |
{ |
{ |
free((*semaphore).path); |
free((*semaphore).path); |
} |
} |
|
|
|
free(semaphore); |
if ((*semaphore).alloue == -1) |
return(0); |
{ |
|
free(semaphore); |
|
} |
|
|
|
return(0); |
# else |
# else |
|
|
sem_t *psem; |
sem_t *psem; |
Line 929 int
|
Line 953 int
|
sem_unlink_SysV(const char *nom) |
sem_unlink_SysV(const 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 |
# ifndef OS2 // IPCS_SYSV |
|
unsigned char *nom_absolu; |
|
|
unsigned char *nom_absolu; |
if ((nom_absolu = malloc((strlen(racine_segment) + strlen(nom) |
|
+ 2) * sizeof(unsigned char))) == NULL) |
|
{ |
|
return(ENOMEM); |
|
} |
|
|
if ((nom_absolu = malloc((strlen(chemin_semaphores_SysV) + strlen(nom) |
sprintf(nom_absolu, "%s/%s", racine_segment, nom); |
+ 1) * sizeof(unsigned char))) == NULL) |
semctl(semget(ftok(nom_absolu, 1), 0, 0), 0, IPC_RMID); |
{ |
|
return(ENOMEM); |
|
} |
|
|
|
sprintf(nom_absolu, "%s%s", chemin_semaphores_SysV, nom); |
if (unlink(nom_absolu) == -1) |
semctl(semget(ftok(nom_absolu, 1), 0, 0), 0, IPC_RMID); |
{ |
|
free(nom_absolu); |
|
return(EACCES); |
|
} |
|
|
if (unlink(nom_absolu) == -1) |
|
{ |
|
free(nom_absolu); |
free(nom_absolu); |
return(EACCES); |
return(0); |
} |
|
|
|
free(nom_absolu); |
|
|
|
return(0); |
|
|
|
# else |
# else |
|
|
return(0); |
return(0); |