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.5 and 1.13

-version 1.5, 2010/07/14 14:19:40
+version 1.13, 2010/08/26 19:07:42
  Line 1
  /*
  ================================================================================
-   RPL/2 (R) version 4.0.18
+   RPL/2 (R) version 4.0.19
    Copyright (C) 1989-2010 Dr. BERTRAND Joël
    This file is part of RPL/2.
  Line 20
  */
- #ifdef SEMAPHORES_NOMMES
+ #include "rpl-conv.h"
- #include "rpl.conv.h"
+ #ifdef SEMAPHORES_NOMMES
  /*
  ================================================================================
  Line 40  sem_t *
  sem_init2(unsigned int valeur, enum t_semaphore semaphore)
  {
      snprintf(noms_semaphores[semaphore], LONGUEUR_NOM_SEMAPHORE,
-             "/RPLSEM-%d-%llu-%d", (int) getpid(),
+             "/RPL-SEM-%d-%llu-%d", (int) getpid(),
              (unsigned long long) pthread_self(),
              (int) semaphore);
      return(sem_open(noms_semaphores[semaphore], O_CREAT,
  Line 106  sem_getvalue2(sem_t *semaphore, int *val
  }
  #endif
+ #ifdef SEMAPHORES_SYSV
+ /*
+ ================================================================================
+   Fonctions d'émulation de sémaphores POSIX en fonction des sémaphores SysV
+ ================================================================================
+   Entrées :
+ --------------------------------------------------------------------------------
+   Sorties :
+ --------------------------------------------------------------------------------
+   Effets de bord : néant
+ ================================================================================
+ */
+ #ifndef OS2
+     extern unsigned char *chemin_semaphores_SysV;
+ #else
+     unsigned char racine_semaphores_OS2[] = "\\SEM32\\";
+     unsigned char racine_memoire_OS2[] = "\\SHAREDMEM\\";
+ #endif
+ int
+ 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
+     int             ios;
+     union semun     argument;
+     if (shared != 0)
+     {
+         errno = ENOSYS;
+         return(-1);
+     }
+     (*semaphore).sem = semget(IPC_PRIVATE, 1, IPC_CREAT | IPC_EXCL |
+             S_IRUSR | S_IWUSR);
+     (*semaphore).path = NULL;
+     (*semaphore).pid = getpid();
+     if ((*semaphore).sem == -1)
+     {
+         errno = EINVAL;
+         return(-1);
+     }
+     argument.val = valeur;
+     ios = semctl((*semaphore).sem, 0, SETVAL, argument);
+     return(ios);
+ #   else
+     sem_t           *psem;
+     psem = semaphore;
+     if (shared != 0)
+     {
+         errno = ENOSYS;
+         return(-1);
+     }
+     if (((*psem).cnt = malloc(sizeof(ULONG))) == NULL)
+     {
+         free(psem);
+         errno = ENOMEM;
+         return(-1);
+     }
+     if (((*psem).nopened = malloc(sizeof(ULONG))) == NULL)
+     {
+         free((*psem).cnt);
+         free(psem);
+         errno = ENOMEM;
+         return(-1);
+     }
+     if (DosCreateMutexSem(NULL, &((*psem).hmtx), 0, 0) != 0)
+     {
+         free((*psem).cnt);
+         free((*psem).nopened);
+         free(psem);
+         return(-1);
+     }
+     if (DosCreateEventSem(NULL, &((*psem).hev), 0, (valeur != 0) ? 1 : 0) != 0)
+     {
+         DosCloseMutexSem((*psem).hmtx);
+         free((*psem).cnt);
+         free((*psem).nopened);
+         free(psem);
+         return(-1);
+     }
+     (*(*psem).cnt) = valeur;
+     (*(*psem).nopened) = 1;
+     (*psem).shared = shared;
+     (*psem).allocated = 0;
+     return(0);
+ #   endif
+ }
+ int
+ sem_destroy_SysV(sem_t *semaphore)
+ {
+     // Détruit un sémaphore anonmyme
+ #   ifndef OS2
+     if ((*semaphore).path != NULL)
+     {
+         return(EINVAL);
+     }
+     if ((*semaphore).pid != getpid())
+     {
+         return(0);
+     }
+     if (semctl((*semaphore).sem, 0, IPC_RMID) == -1)
+     {
+         return(EINVAL);
+     }
+     return(0);
+ #   else
+     sem_t       *psem;
+     psem = semaphore;
+     if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
+     {
+         return(EINVAL);
+     }
+     if (DosCloseMutexSem((*psem).hmtx) != 0)
+     {
+         return(EINVAL);
+     }
+     while(DosCloseEventSem((*psem).hev) == ERROR_SEM_BUSY)
+     {
+         DosPostEventSem((*psem).hev);
+     }
+     (*(*psem).nopened)--;
+     if ((*psem).shared == 0)
+     {
+         free((*psem).cnt);
+         free((*psem).nopened);
+     }
+     else
+     {
+         if ((*(*psem).nopened) == 0)
+         {
+             DosFreeMem((*psem).cnt);
+         }
+     }
+     if ((*psem).allocated != 0)
+     {
+         free(psem);
+     }
+     return(0);
+ #   endif
+ }
+ int
+ sem_wait_SysV(sem_t *semaphore)
+ {
+ #   ifndef OS2
+     struct sembuf       commande;
+     commande.sem_num = 0;
+     commande.sem_op = -1;
+     commande.sem_flg = 0;
+     while(semop((*semaphore).sem, &commande, 1) == -1)
+     {
+         if (errno != EINTR)
+         {
+             errno = EINVAL;
+             return(-1);
+         }
+     }
+     return(0);
+ #   else
+     sem_t       *psem;
+     ULONG       cnt;
+     psem = semaphore;
+     if (DosWaitEventSem((*psem).hev, SEM_INDEFINITE_WAIT) != 0)
+     {
+         errno = EINVAL;
+         return(-1);
+     }
+     if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
+     {
+         errno = EINVAL;
+         return(-1);
+     }
+     if ((*(*psem).cnt) > 0)
+     {
+         (*(*psem).cnt)--;
+     }
+     if ((*(*psem).cnt) == 0)
+     {
+         DosResetEventSem((*psem).hev, &cnt);
+     }
+     DosReleaseMutexSem((*psem).hmtx);
+     return(0);
+ #   endif
+ }
+ int
+ sem_trywait_SysV(sem_t *semaphore)
+ {
+ #   ifndef OS2
+     struct sembuf       commande;
+     commande.sem_num = 0;
+     commande.sem_op = -1;
+     commande.sem_flg = IPC_NOWAIT;
+     while(semop((*semaphore).sem, &commande, 1) == -1)
+     {
+         if (errno != EINTR)
+         {
+             errno = EINVAL;
+             return(-1);
+         }
+     }
+     return(0);
+ #   else
+     int         ios;
+     sem_t       *psem;
+     ULONG       cnt;
+     psem = semaphore;
+     if ((ios = DosWaitEventSem((*psem).hev, SEM_IMMEDIATE_RETURN)) != 0)
+     {
+         errno = (ios == ERROR_TIMEOUT) ? EAGAIN : EINVAL;
+         return(-1);
+     }
+     if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
+     {
+         errno = EINVAL;
+         return(-1);
+     }
+     if ((*(*psem).cnt) > 0)
+     {
+         (*(*psem).cnt)--;
+     }
+     if ((*(*psem).cnt) == 0)
+     {
+         DosResetEventSem((*psem).hev, &cnt);
+     }
+     DosReleaseMutexSem((*psem).hmtx);
+     return(0);
+ #   endif
+ }
+ int
+ sem_post_SysV(sem_t *semaphore)
+ {
+ #   ifndef OS2
+     struct sembuf       commande;
+     commande.sem_num = 0;
+     commande.sem_op = 1;
+     commande.sem_flg = 0;
+     while(semop((*semaphore).sem, &commande, 1) == -1)
+     {
+         if (errno != EINTR)
+         {
+             errno = EINVAL;
+             return(-1);
+         }
+     }
+     return(0);
+ #   else
+     sem_t               *psem;
+     psem = semaphore;
+     if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
+     {
+         errno = EINVAL;
+         return(-1);
+     }
+     (*(*psem).cnt)++;
+     DosPostEventSem((*psem).hev);
+     DosReleaseMutexSem((*psem).hmtx);
+     return(0);
+ #   endif
+ }
+ int
+ sem_getvalue_SysV(sem_t *semaphore, int *valeur)
+ {
+ #   ifndef OS2
+     (*valeur) = semctl((*semaphore).sem, 0, GETVAL);
+     if ((*valeur) < 0)
+     {
+         return(EINVAL);
+     }
+     return(0);
+ #   else
+     sem_t               *psem;
+     psem = semaphore;
+     if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
+     {
+         errno = EINVAL;
+         return(-1);
+     }
+     (*valeur) = (*(*psem).cnt);
+     DosReleaseMutexSem((*psem).hmtx);
+     return(0);
+ #   endif
+ }
+ sem_t
+ *sem_open_SysV(const char *nom, int oflag, ...)
+ //*sem_open(const char *nom, int oflag)
+ //*sem_open(const char *nom, int oflag, mode_t mode, unsigned int value)
+ {
+     mode_t              mode;
+     sem_t               *semaphore;
+ #   ifndef OS2
+     file                *desc;
+     key_t               clef;
+     union semun         argument;
+ #   endif
+     unsigned char       *nom_absolu;
+     unsigned int        valeur;
+     va_list             liste;
+ #   ifdef OS2
+     sem_t               *psem;
+     PVOID               base;
+     unsigned char       *ptr;
+     unsigned char       *nom_segment;
+ #   endif
+ #   ifndef OS2
+     if ((nom_absolu = malloc((strlen(chemin_semaphores_SysV) + strlen(nom)
+             + 1) * sizeof(unsigned char))) == NULL)
+     {
+         return(SEM_FAILED);
+     }
+     sprintf(nom_absolu, "%s%s", chemin_semaphores_SysV, nom);
+     if ((semaphore = malloc(sizeof(sem_t))) == NULL)
+     {
+         return(SEM_FAILED);
+     }
+ #   else
+     if ((nom_segment = malloc((strlen(racine_memoire_OS2) + strlen(nom) + 1)
+             * sizeof(unsigned char))) == NULL)
+     {
+         return(SEM_FAILED);
+     }
+     sprintf(nom_segment, "%s%s", racine_memoire_OS2, nom);
+     ptr = nom_segment;
+     while((*ptr) != d_code_fin_chaine)
+     {
+         if ((*ptr) == '/')
+         {
+             (*ptr) = '\\';
+         }
+         ptr++;
+     }
+     if ((nom_absolu = malloc((strlen(racine_semaphores_OS2) + strlen(nom)
+             + 2) * sizeof(unsigned char))) == NULL)
+     {
+         return(SEM_FAILED);
+     }
+     sprintf(nom_absolu, "%s%s", racine_semaphores_OS2, nom);
+     ptr = nom_absolu;
+     while((*ptr) != d_code_fin_chaine)
+     {
+         if ((*ptr) == '/')
+         {
+             (*ptr) = '\\';
+         }
+         ptr++;
+     }
+     (*(ptr + 1)) = d_code_fin_chaine;
+     if ((psem = malloc(sizeof(sem_t))) == NULL)
+     {
+         return(SEM_FAILED);
+     }
+     (*psem).allocated = 1;
+ #   endif
+     if ((oflag & O_CREAT) == 0)
+     {
+         // 2 arguments
+ #       ifndef OS2
+         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 ((psem = malloc(sizeof(sem_t))) == NULL)
+         {
+             free(nom_absolu);
+             free(nom_segment);
+             return(SEM_FAILED);
+         }
+         (*ptr) = 'M';
+         if (DosOpenMutexSem(nom_absolu, &((*psem).hmtx)) != 0)
+         {
+             free(psem);
+             free(nom_absolu);
+             free(nom_segment);
+             return(SEM_FAILED);
+         }
+         (*ptr) = 'S';
+         if (DosOpenEventSem(nom_absolu, &((*psem).hev)) != 0)
+         {
+             DosCloseMutexSem((*psem).hmtx);
+             free(psem);
+             free(nom_absolu);
+             free(nom_segment);
+             return(SEM_FAILED);
+         }
+         if (DosGetNamedSharedMem(&base, nom_segment, PAG_WRITE | PAG_READ) != 0)
+         {
+             DosCloseMutexSem((*psem).hmtx);
+             free(nom_absolu);
+             free(nom_segment);
+             free(psem);
+             return(SEM_FAILED);
+         }
+         free(nom_segment);
+         (*psem).cnt = (ULONG *) base;
+         (*psem).nopened = ((ULONG *) base) + 1;
+         (*psem).shared = 1;
+         if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
+         {
+             DosCloseMutexSem((*psem).hmtx);
+             free(nom_absolu);
+             free(nom_segment);
+             free(psem);
+             return(SEM_FAILED);
+         }
+         (*((*psem).nopened))++;
+         DosReleaseMutexSem((*psem).hmtx);
+         semaphore = psem;
+ #       endif
+     }
+     else
+     {
+         // 4 arguments
+         // O_CREAT O_EXCL
+         // S_IRUSR S_IWUSR
+         va_start(liste, oflag);
+         mode = va_arg(liste, mode_t);
+         valeur = va_arg(liste, unsigned int);
+         va_end(liste);
+ #       ifndef OS2
+         if ((desc = fopen(nom_absolu, "w")) == NULL)
+         {
+             free(semaphore);
+             free(nom_absolu);
+             return(SEM_FAILED);
+         }
+         fclose(desc);
+         if ((clef = ftok(nom_absolu, 1)) == -1)
+         {
+             free(semaphore);
+             free(nom_absolu);
+             return(SEM_FAILED);
+         }
+         (*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(nom_absolu);
+             return(SEM_FAILED);
+         }
+         argument.val = valeur;
+         semctl((*semaphore).sem, 0, SETVAL, argument);
+ #       else
+         if ((psem = malloc(sizeof(sem_t))) == NULL)
+         {
+             free(nom_absolu);
+             free(nom_segment);
+             return(SEM_FAILED);
+         }
+         (*ptr) = 'M';
+         if (DosCreateMutexSem(nom_absolu, &((*psem).hmtx), 0, 0) != 0)
+         {
+             free(psem);
+             free(nom_absolu);
+             free(nom_segment);
+             return(SEM_FAILED);
+         }
+         (*ptr) = 'S';
+         if (DosCreateEventSem(nom_absolu, &((*psem).hev), 0,
+                 (valeur != 0) ? 1 : 0) != 0)
+         {
+             DosCloseMutexSem((*psem).hmtx);
+             free(nom_absolu);
+             free(nom_segment);
+             free(psem);
+             return(SEM_FAILED);
+         }
+         if (DosAllocSharedMem(&base, nom_segment, 2 * sizeof(ULONG),
+                 PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)
+         {
+             DosCloseMutexSem((*psem).hmtx);
+             free(nom_absolu);
+             free(nom_segment);
+             free(psem);
+             return(SEM_FAILED);
+         }
+         free(nom_segment);
+         (*psem).cnt = (ULONG *) base;
+         (*psem).nopened = ((ULONG *) base) + 1;
+         (*(*psem).cnt) = valeur;
+         (*(*psem).nopened) = 1;
+         (*psem).shared = 1;
+         semaphore = psem;
+ #       endif
+     }
+     return(semaphore);
+ }
+ int
+ sem_close_SysV(sem_t *semaphore)
+ {
+     // Ferme un sémaphore nommé créé par sem_open_SysV()
+ #   ifndef OS2
+     if ((*semaphore).path != NULL)
+     {
+         free((*semaphore).path);
+     }
+     free(semaphore);
+     return(0);
+ #   else
+     sem_t       *psem;
+     psem = semaphore;
+     if (DosCloseMutexSem((*psem).hmtx) != 0)
+     {
+         return(EINVAL);
+     }
+     while(DosCloseEventSem((*psem).hev) == ERROR_SEM_BUSY)
+     {
+         DosPostEventSem((*psem).hev);
+     }
+     (*(*psem).nopened)--;
+     if ((*psem).shared == 0)
+     {
+         free((*psem).cnt);
+         free((*psem).nopened);
+     }
+     else
+     {
+         if ((*(*psem).nopened) == 0)
+         {
+             DosFreeMem((*psem).cnt);
+         }
+     }
+     if ((*psem).allocated != 0)
+     {
+         free(psem);
+     }
+     return(0);
+ #   endif
+ }
+ int
+ sem_unlink_SysV(const char *nom)
+ {
+     // Détruit un sémaphore nommé créé par sem_open_SysV()
+ #   ifndef OS2
+     unsigned char       *nom_absolu;
+     if ((nom_absolu = malloc((strlen(chemin_semaphores_SysV) + strlen(nom)
+             + 1) * sizeof(unsigned char))) == NULL)
+     {
+         return(ENOMEM);
+     }
+     sprintf(nom_absolu, "%s%s", chemin_semaphores_SysV, nom);
+     semctl(semget(ftok(nom_absolu, 1), 0, 0), 0, IPC_RMID);
+     if (unlink(nom_absolu) == -1)
+     {
+         free(nom_absolu);
+         return(EACCES);
+     }
+     free(nom_absolu);
+     return(0);
+ #   else
+     return(0);
+ #   endif
+ }
+ #endif
  // vim: ts=4

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.5
changed lines
	Added in v.1.13