[BACK]Return to semaphores.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/semaphores.c between versions 1.26 and 1.44

version 1.26, 2011/07/22 07:38:41 version 1.44, 2012/04/13 14:13:04
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.1    RPL/2 (R) version 4.1.8
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2012 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 22 Line 22
   
 #include "rpl-conv.h"  #include "rpl-conv.h"
   
   
 #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, int ordre)
   {
       unsigned char               *fichier;
   
       if ((fichier = malloc((1 + 256 + 1) * sizeof(unsigned char))) == NULL)
       {
           return(NULL);
       }
   
       sprintf(fichier, "/RPL-%d-%d", (int) pid, ordre);
       return(fichier);
   }
   
   
   static unsigned char *
   nom_segment_semaphore_thread(pid_t pid, pthread_t tid, int ordre)
   {
       unsigned char               *fichier;
   
       if ((fichier = malloc((1 + 256 + 1) * sizeof(unsigned char))) == NULL)
       {
           return(NULL);
       }
   
       sprintf(fichier, "/RPL-%d-%llX-%d", (int) pid,
               (unsigned long long) tid, ordre);
       return(fichier);
   }
   
   
 /*  /*
 ================================================================================  ================================================================================
   Fonctions d'émulation de sémaphores anonymes    Fonctions d'émulation de sémaphores anonymes
Line 37 Line 73
 */  */
   
 sem_t *  sem_t *
 sem_init2(unsigned int valeur, enum t_semaphore semaphore)  sem_init2(unsigned int valeur, pid_t pid, int ordre)
 {  {
     snprintf(noms_semaphores[semaphore], LONGUEUR_NOM_SEMAPHORE,      sem_t                       *semaphore;
             "/RPL-SEM-%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, ordre)) == NULL)
             (S_IRUSR | S_IWUSR), valeur));      {
           return(SEM_FAILED);
       }
   
       semaphore = sem_open(chemin, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR,
               valeur);
       free(chemin);
   
       return(semaphore);
 }  }
   
   
   sem_t *
   sem_init3(unsigned int valeur, pid_t pid, pthread_t tid, int ordre)
   {
       sem_t                       *semaphore;
   
       unsigned char               *chemin;
   
       if ((chemin = nom_segment_semaphore_thread(pid, tid, ordre)) == NULL)
       {
           return(SEM_FAILED);
       }
   
       semaphore = sem_open(chemin, O_CREAT | O_EXCL | O_RDWR, S_IRUSR | S_IWUSR,
               valeur);
       free(chemin);
   
       return(semaphore);
   }
   
   
   sem_t *
   sem_open2(pid_t pid, int ordre)
   {
       unsigned char               *chemin;
   
       sem_t                       *semaphore;
   
       if ((chemin = nom_segment_semaphore(pid, ordre)) == NULL)
       {
           return(SEM_FAILED);
       }
   
       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, int ordre)
 {  {
     sem_close(semaphore_p);      int                         erreur;
     return(sem_unlink(noms_semaphores[semaphore]));  
       unsigned char               *chemin;
   
       sem_close(semaphore);
   
       if ((chemin = nom_segment_semaphore(pid, ordre)) == NULL)
       {
           return(1);
       }
   
       erreur = sem_unlink(chemin);
       free(chemin);
   
       return(erreur);
   }
   
   
   int
   sem_destroy3(sem_t *semaphore, pid_t pid, pthread_t tid, int ordre)
   {
       int                         erreur;
   
       unsigned char               *chemin;
   
       sem_close(semaphore);
   
       if ((chemin = nom_segment_semaphore_thread(pid, tid, ordre)) == NULL)
       {
           return(1);
       }
   
       erreur = sem_unlink(chemin);
       free(chemin);
   
       return(erreur);
 }  }
   
   
 #undef sem_post  #undef sem_post
 #undef sem_wait  #undef sem_wait
 #undef sem_trywait  #undef sem_trywait
Line 62  int Line 181  int
 sem_getvalue2(sem_t *semaphore, int *valeur)  sem_getvalue2(sem_t *semaphore, int *valeur)
 {  {
     int                     i;      int                     i;
       int                     j;
   
     logical1                drapeau_fin;      logical1                drapeau_fin;
   
     pthread_mutex_lock(&mutex_sem);      struct timespec         attente;
   
     (*valeur) = 0;      attente.tv_sec = 0;
     drapeau_fin = d_faux;      attente.tv_nsec = GRANULARITE_us * 1000;
   
     do      for(j = 0; j < 100; j++)
     {      {
         if (sem_trywait(semaphore) == -1)          if (pthread_mutex_trylock(&mutex_sem) == 0)
         {          {
             if (errno == EAGAIN)              (*valeur) = 0;
               drapeau_fin = d_faux;
   
               do
             {              {
                 // Le sémaphore avait une valeur nulle                  if (sem_trywait(semaphore) == -1)
                 drapeau_fin = d_vrai;                  {
             }                      if (errno == EAGAIN)
             else                      {
                           // Le sémaphore avait une valeur nulle
                           drapeau_fin = d_vrai;
                       }
                       else
                       {
                           // Autre erreur
                           pthread_mutex_unlock(&mutex_sem);
                           return(-1);
                       }
                   }
                   else
                   {
                       (*valeur)++;
                   }
               } while(drapeau_fin == d_faux);
   
               for(i = 0; i < (*valeur); i++)
             {              {
                 // Autre erreur                  if (sem_post(semaphore) != 0)
                 pthread_mutex_unlock(&mutex_sem);                  {
                 return(-1);                      pthread_mutex_unlock(&mutex_sem);
                       return(-1);
                   }
             }              }
         }  
         else  
         {  
             (*valeur)++;  
         }  
     } while(drapeau_fin == d_faux);  
   
     for(i = 0; i < (*valeur); i++)  
     {  
         if (sem_post(semaphore) != 0)  
         {  
             pthread_mutex_unlock(&mutex_sem);              pthread_mutex_unlock(&mutex_sem);
             return(-1);              return(0);
         }          }
   
           INCR_GRANULARITE(attente.tv_nsec);
     }      }
   
     pthread_mutex_unlock(&mutex_sem);      // Le mutex n'a pas pu être verrouillé. On peut raisonnablement penser
       // que le sémaphore est bloqué dans un sem_wait() protégé par ce mutex.
   
       (*valeur) = 0;
     return(0);      return(0);
 }  }
   
Line 121  sem_getvalue2(sem_t *semaphore, int *val Line 258  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 133  sem_init_SysV(sem_t *semaphore, int shar Line 270  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;  #   ifndef OS2 // IPCS_SYSV
           int             desc;
     if (shared != 0)          int             ios;
     {  
         errno = ENOSYS;          key_t           clef;
         return(-1);  
     }          union semun     argument;
   
           if (shared == 0)
           {
               // Sémaphore privé
               (*semaphore).sem = semget(IPC_PRIVATE, 1, IPC_CREAT | IPC_EXCL |
                       S_IRUSR | S_IWUSR);
               (*semaphore).path = NULL;
               (*semaphore).pid = getpid();
               (*semaphore).tid = pthread_self();
               (*semaphore).alloue = 0;
           }
           else
           {
               // Sémaphore partagé entre plusieurs processus
               if (((*semaphore).path = malloc((strlen(racine_segment)
                       + 2 + 256 + 1) * sizeof(unsigned char))) == NULL)
               {
                   return(-1);
               }
   
     (*semaphore).sem = semget(IPC_PRIVATE, 1, IPC_CREAT | IPC_EXCL |              sprintf((*semaphore).path, "%s/RPL-SEMAPHORE-%d-%llX-%d",
             S_IRUSR | S_IWUSR);                      racine_segment, (int) getpid(), pthread_self(), shared);
     (*semaphore).path = NULL;  
     (*semaphore).pid = getpid();  
   
     if ((*semaphore).sem == -1)              if ((desc = open((*semaphore).path, O_RDWR | O_CREAT | O_EXCL,
     {                      S_IRUSR | S_IWUSR)) == -1)
         errno = EINVAL;              {
         return(-1);                  free((*semaphore).path);
     }                  return(-1);
               }
   
     argument.val = valeur;              (*semaphore).pid = getpid();
     ios = semctl((*semaphore).sem, 0, SETVAL, argument);              (*semaphore).tid = pthread_self();
               clef = ftok((*semaphore).path, 1);
               close(desc);
   
     return(ios);              if (clef == -1)
               {
                   free((*semaphore).path);
                   return(-1);
               }
   
 #   else              (*semaphore).alloue = 0;
               (*semaphore).sem = semget(clef, 1, IPC_CREAT | IPC_EXCL |
                       S_IRUSR | S_IWUSR);
           }
   
     sem_t           *psem;          if ((*semaphore).sem == -1)
           {
               errno = EINVAL;
               return(-1);
           }
   
     psem = semaphore;          argument.val = valeur;
           ios = semctl((*semaphore).sem, 0, SETVAL, argument);
   
     if (shared != 0)          return(ios);
     {  #   else // OS/2
         errno = ENOSYS;          sem_t           *psem;
         return(-1);  
     }  
   
     if (((*psem).cnt = malloc(sizeof(ULONG))) == NULL)          psem = semaphore;
     {  
         free(psem);  
         errno = ENOMEM;  
         return(-1);  
     }  
   
     if (((*psem).nopened = malloc(sizeof(ULONG))) == NULL)          if (((*psem).cnt = malloc(sizeof(ULONG))) == NULL)
     {          {
         free((*psem).cnt);              free(psem);
         free(psem);              errno = ENOMEM;
         errno = ENOMEM;              return(-1);
         return(-1);          }
     }  
   
     if (DosCreateMutexSem(NULL, &((*psem).hmtx), 0, 0) != 0)          if (((*psem).nopened = malloc(sizeof(ULONG))) == NULL)
     {          {
         free((*psem).cnt);              free((*psem).cnt);
         free((*psem).nopened);              free(psem);
         free(psem);              errno = ENOMEM;
         return(-1);              return(-1);
     }          }
   
     if (DosCreateEventSem(NULL, &((*psem).hev), 0, (valeur != 0) ? 1 : 0) != 0)          if (DosCreateMutexSem(NULL, &((*psem).hmtx), 0, 0) != 0)
     {          {
         DosCloseMutexSem((*psem).hmtx);              free((*psem).cnt);
         free((*psem).cnt);              free((*psem).nopened);
         free((*psem).nopened);              free(psem);
         free(psem);              return(-1);
         return(-1);          }
     }  
   
     (*(*psem).cnt) = valeur;          if (DosCreateEventSem(NULL, &((*psem).hev), 0, (valeur != 0) ? 1 : 0)
     (*(*psem).nopened) = 1;                  != 0)
     (*psem).shared = shared;          {
     (*psem).allocated = 0;              DosCloseMutexSem((*psem).hmtx);
               free((*psem).cnt);
               free((*psem).nopened);
               free(psem);
               return(-1);
           }
   
     return(0);          (*(*psem).cnt) = valeur;
           (*(*psem).nopened) = 1;
           (*psem).shared = shared;
           (*psem).allocated = 0;
   
           return(0);
 #   endif  #   endif
 }  }
   
Line 219  int Line 385  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)  #   ifndef OS2 // IPCS_SYSV
     {          if ((*semaphore).path != NULL)
         return(EINVAL);          {
     }              return(EINVAL);
           }
     if ((*semaphore).pid != getpid())  
     {  
         return(0);  
     }  
   
     if (semctl((*semaphore).sem, 0, IPC_RMID) == -1)  
     {  
         return(EINVAL);  
     }  
   
     return(0);          if ((*semaphore).pid != getpid())
           {
               return(0);
           }
   
 #   else          if (semctl((*semaphore).sem, 0, IPC_RMID) == -1)
           {
               return(EINVAL);
           }
   
     sem_t       *psem;          return(0);
   #   else // OS/2
           sem_t       *psem;
   
     psem = semaphore;          psem = semaphore;
   
     if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)          if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
     {          {
         return(EINVAL);              return(EINVAL);
     }          }
   
     if (DosCloseMutexSem((*psem).hmtx) != 0)          if (DosCloseMutexSem((*psem).hmtx) != 0)
     {          {
         return(EINVAL);              return(EINVAL);
     }          }
   
     while(DosCloseEventSem((*psem).hev) == ERROR_SEM_BUSY)          while(DosCloseEventSem((*psem).hev) == ERROR_SEM_BUSY)
     {          {
         DosPostEventSem((*psem).hev);              DosPostEventSem((*psem).hev);
     }          }
   
     (*(*psem).nopened)--;          (*(*psem).nopened)--;
   
     if ((*psem).shared == 0)          if ((*psem).shared == 0)
     {  
         free((*psem).cnt);  
         free((*psem).nopened);  
     }  
     else  
     {  
         if ((*(*psem).nopened) == 0)  
         {          {
             DosFreeMem((*psem).cnt);              free((*psem).cnt);
               free((*psem).nopened);
           }
           else
           {
               if ((*(*psem).nopened) == 0)
               {
                   DosFreeMem((*psem).cnt);
               }
         }          }
     }  
   
     if ((*psem).allocated != 0)  
     {     
         free(psem);  
     }  
   
     return(0);          if ((*psem).allocated != 0)
           {   
               free(psem);
           }
   
           return(0);
 #   endif  #   endif
 }  }
   
 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_flg = 0;
   
     commande.sem_num = 0;          while(semop((*semaphore).sem, &commande, 1) == -1)
     commande.sem_op = -1;  
     commande.sem_flg = 0;  
   
     while(semop((*semaphore).sem, &commande, 1) == -1)  
     {  
         if (errno != EINTR)  
         {          {
             errno = EINVAL;              if (errno != EINTR)
             return(-1);              {
                   errno = EINVAL;
                   return(-1);
               }
         }          }
     }  
   
     return(0);  
   
 #   else          return(0);
   #   else // OS/2
     sem_t       *psem;          sem_t       *psem;
   
     ULONG       cnt;          ULONG       cnt;
   
     psem = semaphore;          psem = semaphore;
   
     if (DosWaitEventSem((*psem).hev, SEM_INDEFINITE_WAIT) != 0)          if (DosWaitEventSem((*psem).hev, SEM_INDEFINITE_WAIT) != 0)
     {          {
         errno = EINVAL;              errno = EINVAL;
         return(-1);              return(-1);
     }          }
   
     if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)  
     {  
         errno = EINVAL;  
         return(-1);  
     }  
   
     if ((*(*psem).cnt) > 0)          if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
     {          {
         (*(*psem).cnt)--;              errno = EINVAL;
     }              return(-1);
           }
   
     if ((*(*psem).cnt) == 0)          if ((*(*psem).cnt) > 0)
     {          {
         DosResetEventSem((*psem).hev, &cnt);              (*(*psem).cnt)--;
     }          }
   
     DosReleaseMutexSem((*psem).hmtx);          if ((*(*psem).cnt) == 0)
     return(0);          {
               DosResetEventSem((*psem).hev, &cnt);
           }
   
           DosReleaseMutexSem((*psem).hmtx);
           return(0);
 #   endif  #   endif
 }  }
   
 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_num = 0;
     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)          while(semop((*semaphore).sem, &commande, 1) == -1)
     {  
         if (errno != EINTR)  
         {          {
             errno = EINVAL;              if (errno != EINTR)
             return(-1);              {
                   errno = EINVAL;
                   return(-1);
               }
         }          }
     }  
   
     return(0);  
   
 #   else          return(0);
   #   else // OS/2
     int         ios;          int         ios;
   
     sem_t       *psem;          sem_t       *psem;
   
     ULONG       cnt;          ULONG       cnt;
   
     psem = semaphore;          psem = semaphore;
   
     if ((ios = DosWaitEventSem((*psem).hev, SEM_IMMEDIATE_RETURN)) != 0)          if ((ios = DosWaitEventSem((*psem).hev, SEM_IMMEDIATE_RETURN)) != 0)
     {          {
         errno = (ios == ERROR_TIMEOUT) ? EAGAIN : EINVAL;              errno = (ios == ERROR_TIMEOUT) ? EAGAIN : EINVAL;
         return(-1);              return(-1);
     }          }
   
     if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)  
     {  
         errno = EINVAL;  
         return(-1);  
     }  
   
     if ((*(*psem).cnt) > 0)          if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
     {          {
         (*(*psem).cnt)--;              errno = EINVAL;
     }              return(-1);
           }
   
     if ((*(*psem).cnt) == 0)          if ((*(*psem).cnt) > 0)
     {          {
         DosResetEventSem((*psem).hev, &cnt);              (*(*psem).cnt)--;
     }          }
   
     DosReleaseMutexSem((*psem).hmtx);          if ((*(*psem).cnt) == 0)
     return(0);          {
               DosResetEventSem((*psem).hev, &cnt);
           }
   
           DosReleaseMutexSem((*psem).hmtx);
           return(0);
 #   endif  #   endif
 }  }
   
 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_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)          while(semop((*semaphore).sem, &commande, 1) == -1)
     {  
         if (errno != EINTR)  
         {          {
             errno = EINVAL;              if (errno != EINTR)
             return(-1);              {
                   errno = EINVAL;
                   return(-1);
               }
         }          }
     }  
   
     return(0);  
   
 #   else          return(0);
   #   else // OS/2
     sem_t               *psem;          sem_t               *psem;
   
     psem = semaphore;          psem = semaphore;
   
     if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)          if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
     {          {
         errno = EINVAL;              errno = EINVAL;
         return(-1);              return(-1);
     }          }
   
     (*(*psem).cnt)++;  
     DosPostEventSem((*psem).hev);  
     DosReleaseMutexSem((*psem).hmtx);  
   
     return(0);          (*(*psem).cnt)++;
           DosPostEventSem((*psem).hev);
           DosReleaseMutexSem((*psem).hmtx);
   
           return(0);
 #   endif  #   endif
 }  }
   
 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;          psem = semaphore;
   
     psem = semaphore;          if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
           {
     if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)              errno = EINVAL;
     {              return(-1);
         errno = EINVAL;          }
         return(-1);  
     }  
   
     (*valeur) = (*(*psem).cnt);  
     DosReleaseMutexSem((*psem).hmtx);  
   
     return(0);          (*valeur) = (*(*psem).cnt);
           DosReleaseMutexSem((*psem).hmtx);
   
           return(0);
 #   endif  #   endif
 }  }
   
Line 489  sem_t Line 636  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 503  sem_t Line 650  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);  
     }  
   
     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) = '\\';              return(SEM_FAILED);
         }          }
   
         ptr++;          sprintf(nom_absolu, "%s/%s", racine_segment, nom);
     }  
   
     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 ((semaphore = malloc(sizeof(sem_t))) == NULL)
     {  
         if ((*ptr) == '/')  
         {          {
             (*ptr) = '\\';              return(SEM_FAILED);
         }          }
   
         ptr++;          (*semaphore).alloue = -1;
     }          (*semaphore).pid = getpid();
           (*semaphore).tid = pthread_self();
     (*(ptr + 1)) = d_code_fin_chaine;  #   else
           if ((nom_segment = malloc((strlen(racine_memoire_OS2) + strlen(nom) + 1)
     if ((psem = malloc(sizeof(sem_t))) == NULL)                  * sizeof(unsigned char))) == NULL)
     {          {
         return(SEM_FAILED);              return(SEM_FAILED);
     }          }   
   
     (*psem).allocated = 1;  
   
 #   endif          sprintf(nom_segment, "%s%s", racine_memoire_OS2, nom);
           ptr = nom_segment;
   
     if ((oflag & O_CREAT) == 0)          while((*ptr) != d_code_fin_chaine)
     {          {
         // 2 arguments              if ((*ptr) == '/')
               {
 #       ifndef OS2                  (*ptr) = '\\';
               }
   
         clef = ftok(nom_absolu, 1);              ptr++;
           }
   
         if (clef == -1)          if ((nom_absolu = malloc((strlen(racine_semaphores_OS2) + strlen(nom)
                   + 2) * sizeof(unsigned char))) == NULL)
         {          {
             return(SEM_FAILED);              return(SEM_FAILED);
         }          }
   
         (*semaphore).sem = semget(clef, 0, 0);          sprintf(nom_absolu, "%s%s", racine_semaphores_OS2, nom);
         (*semaphore).path = nom_absolu;          ptr = nom_absolu;
         (*semaphore).pid = getpid();  
   
         if ((*semaphore).sem == -1)          while((*ptr) != d_code_fin_chaine)
         {             {
             free(semaphore);              if ((*ptr) == '/')
             free(nom_absolu);              {
                   (*ptr) = '\\';
               }
   
             return(SEM_FAILED);              ptr++;
         }          }
   
 #       else          (*(ptr + 1)) = d_code_fin_chaine;
   
         if ((psem = malloc(sizeof(sem_t))) == NULL)          if ((psem = malloc(sizeof(sem_t))) == NULL)
         {          {
             free(nom_absolu);  
             free(nom_segment);  
             return(SEM_FAILED);              return(SEM_FAILED);
         }          }
   
         (*ptr) = 'M';          (*psem).allocated = 1;
   #   endif
   
         if (DosOpenMutexSem(nom_absolu, &((*psem).hmtx)) != 0)      if ((oflag & O_CREAT) == 0)
         {      {
             free(psem);          // 2 arguments
             free(nom_absolu);  
             free(nom_segment);  
   
             return(SEM_FAILED);  #       ifndef OS2 // IPCS_SYSV
         }              clef = ftok(nom_absolu, 1);
   
         (*ptr) = 'S';              if (clef == -1)
               {
                   return(SEM_FAILED);
               }
   
         if (DosOpenEventSem(nom_absolu, &((*psem).hev)) != 0)              (*semaphore).sem = semget(clef, 0, 0);
         {              (*semaphore).path = nom_absolu;
             DosCloseMutexSem((*psem).hmtx);              (*semaphore).pid = getpid();
   
               if ((*semaphore).sem == -1)
               {   
                   free(semaphore);
                   free(nom_absolu);
   
             free(psem);                  return(SEM_FAILED);
             free(nom_absolu);              }
             free(nom_segment);  #       else // OS/2
               if ((psem = malloc(sizeof(sem_t))) == NULL)
               {
                   free(nom_absolu);
                   free(nom_segment);
                   return(SEM_FAILED);
               }
   
             return(SEM_FAILED);              (*ptr) = 'M';
         }  
   
         if (DosGetNamedSharedMem(&base, nom_segment, PAG_WRITE | PAG_READ) != 0)              if (DosOpenMutexSem(nom_absolu, &((*psem).hmtx)) != 0)
         {              {
             DosCloseMutexSem((*psem).hmtx);                  free(psem);
                   free(nom_absolu);
                   free(nom_segment);
   
             free(nom_absolu);                  return(SEM_FAILED);
             free(nom_segment);              }
             free(psem);  
   
             return(SEM_FAILED);              (*ptr) = 'S';
         }  
   
         free(nom_segment);              if (DosOpenEventSem(nom_absolu, &((*psem).hev)) != 0)
               {
                   DosCloseMutexSem((*psem).hmtx);
   
         (*psem).cnt = (ULONG *) base;                  free(psem);
         (*psem).nopened = ((ULONG *) base) + 1;                  free(nom_absolu);
         (*psem).shared = 1;                  free(nom_segment);
   
         if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)                  return(SEM_FAILED);
         {              }
             DosCloseMutexSem((*psem).hmtx);  
               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_absolu);  
             free(nom_segment);              free(nom_segment);
             free(psem);  
   
             return(SEM_FAILED);              (*psem).cnt = (ULONG *) base;
         }              (*psem).nopened = ((ULONG *) base) + 1;
               (*psem).shared = 1;
   
         (*((*psem).nopened))++;              if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
               {
                   DosCloseMutexSem((*psem).hmtx);
   
         DosReleaseMutexSem((*psem).hmtx);                  free(nom_absolu);
                   free(nom_segment);
                   free(psem);
   
                   return(SEM_FAILED);
               }
   
         semaphore = psem;              (*((*psem).nopened))++;
   
               DosReleaseMutexSem((*psem).hmtx);
   
               semaphore = psem;
 #       endif  #       endif
     }      }
     else      else
Line 683  sem_t Line 827  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)
               {
                   close(desc);
                   free(semaphore);
                   free(nom_absolu);
   
         if ((clef = ftok(nom_absolu, 1)) == -1)                  return(SEM_FAILED);
         {              }
             free(semaphore);  
             free(nom_absolu);  
   
             return(SEM_FAILED);              close(desc);
         }  
   
         (*semaphore).sem = semget(clef, 1,              (*semaphore).sem = semget(clef, 1,
                 (((oflag & O_CREAT) == 0) ? 0 : IPC_CREAT) |                      (((oflag & O_CREAT) == 0) ? 0 : IPC_CREAT) |
                 (((oflag & O_EXCL) == 0) ? 0 : IPC_EXCL) |                      (((oflag & O_EXCL) == 0) ? 0 : IPC_EXCL) |
                 (int) mode);                      (int) mode);
         (*semaphore).path = nom_absolu;              (*semaphore).path = nom_absolu;
         (*semaphore).pid = getpid();              (*semaphore).pid = getpid();
   
               if ((*semaphore).sem == -1)
               {   
                   free(semaphore);
                   free(nom_absolu);
   
         if ((*semaphore).sem == -1)                  return(SEM_FAILED);
         {                 }
             free(semaphore);  
             free(nom_absolu);  
   
             return(SEM_FAILED);              argument.val = valeur;
         }              semctl((*semaphore).sem, 0, SETVAL, argument);
   #       else // OS/2
               if ((psem = malloc(sizeof(sem_t))) == NULL)
               {
                   free(nom_absolu);
                   free(nom_segment);
   
         argument.val = valeur;                  return(SEM_FAILED);
         semctl((*semaphore).sem, 0, SETVAL, argument);              }
   
 #       else              (*ptr) = 'M';
   
         if ((psem = malloc(sizeof(sem_t))) == NULL)              if (DosCreateMutexSem(nom_absolu, &((*psem).hmtx), 0, 0) != 0)
         {              {
             free(nom_absolu);                  free(psem);
             free(nom_segment);                  free(nom_absolu);
                   free(nom_segment);
             return(SEM_FAILED);  
         }  
   
         (*ptr) = 'M';                  return(SEM_FAILED);
               }
   
         if (DosCreateMutexSem(nom_absolu, &((*psem).hmtx), 0, 0) != 0)              (*ptr) = 'S';
         {  
             free(psem);  
             free(nom_absolu);  
             free(nom_segment);  
   
             return(SEM_FAILED);              if (DosCreateEventSem(nom_absolu, &((*psem).hev), 0,
         }                      (valeur != 0) ? 1 : 0) != 0)
               {
                   DosCloseMutexSem((*psem).hmtx);
   
         (*ptr) = 'S';                  free(nom_absolu);
                   free(nom_segment);
                   free(psem);
   
         if (DosCreateEventSem(nom_absolu, &((*psem).hev), 0,                  return(SEM_FAILED);
                 (valeur != 0) ? 1 : 0) != 0)              }
         {  
             DosCloseMutexSem((*psem).hmtx);  
   
             free(nom_absolu);              if (DosAllocSharedMem(&base, nom_segment, 2 * sizeof(ULONG),
             free(nom_segment);                      PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)
             free(psem);              {
                   DosCloseMutexSem((*psem).hmtx);
   
             return(SEM_FAILED);                  free(nom_absolu);
         }                  free(nom_segment);
                   free(psem);
   
         if (DosAllocSharedMem(&base, nom_segment, 2 * sizeof(ULONG),                  return(SEM_FAILED);
                 PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)              }
         {  
             DosCloseMutexSem((*psem).hmtx);  
   
             free(nom_absolu);  
             free(nom_segment);              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;  
   
               (*psem).cnt = (ULONG *) base;
               (*psem).nopened = ((ULONG *) base) + 1;
               (*(*psem).cnt) = valeur;
               (*(*psem).nopened) = 1;
               (*psem).shared = 1;
               semaphore = psem;
 #       endif  #       endif
     }      }
   
Line 787  int Line 929  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;          psem = semaphore;
   
     psem = semaphore;          if (DosCloseMutexSem((*psem).hmtx) != 0)
           {
     if (DosCloseMutexSem((*psem).hmtx) != 0)              return(EINVAL);
     {          }
         return(EINVAL);  
     }  
   
     while(DosCloseEventSem((*psem).hev) == ERROR_SEM_BUSY)          while(DosCloseEventSem((*psem).hev) == ERROR_SEM_BUSY)
     {          {
         DosPostEventSem((*psem).hev);              DosPostEventSem((*psem).hev);
     }          }
   
     (*(*psem).nopened)--;          (*(*psem).nopened)--;
   
     if ((*psem).shared == 0)          if ((*psem).shared == 0)
     {  
         free((*psem).cnt);  
         free((*psem).nopened);  
     }  
     else  
     {  
         if ((*(*psem).nopened) == 0)  
         {          {
             DosFreeMem((*psem).cnt);              free((*psem).cnt);
               free((*psem).nopened);
           }
           else
           {
               if ((*(*psem).nopened) == 0)
               {
                   DosFreeMem((*psem).cnt);
               }
         }          }
     }  
   
     if ((*psem).allocated != 0)  
     {  
         free(psem);  
     }  
   
     return(0);          if ((*psem).allocated != 0)
           {
               free(psem);
           }
   
           return(0);
 #   endif  #   endif
 }  }
   
Line 842  int Line 984  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
           semctl(semget(ftok(nom, 1), 0, 0), 0, IPC_RMID);
     unsigned char       *nom_absolu;  
   
     if ((nom_absolu = malloc((strlen(chemin_semaphores_SysV) + strlen(nom)          if (unlink(nom) == -1)
             + 1) * sizeof(unsigned char))) == NULL)          {
     {              free(nom_absolu);
         return(ENOMEM);              return(EACCES);
     }          }
   
     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);  
   
           free(nom);
           return(0);
 #   else  #   else
           return(0);
     return(0);  
   
 #   endif  #   endif
 }  }
   
Removed from v.1.26  
changed lines
  Added in v.1.44

CVSweb interface <joel.bertrand@systella.fr>