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

Diff for /rpl/src/semaphores.c between versions 1.32 and 1.89

version 1.32, 2011/09/19 17:33:17 version 1.89, 2020/01/10 11:15:51
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.3    RPL/2 (R) version 4.1.32
   Copyright (C) 1989-2011 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 22 Line 22
   
 #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.
   
 static unsigned char *  static unsigned char *
 nom_segment_semaphore(pid_t pid)  nom_segment_semaphore(pid_t pid, int ordre)
 {  {
     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-SIGSEMAPHORE-%d", (int) pid);      sprintf(fichier, "/RPL-%llu-%d", (unsigned long long) pid, ordre);
       return(fichier);
   }
   
   
   static unsigned char *
   nom_segment_semaphore_thread(pid_t pid, pthread_t tid, int ordre)
   {
       unsigned char               *fichier;
   
       if ((fichier = sys_malloc((1 + 256 + 1) * sizeof(unsigned char))) == NULL)
       {
           return(NULL);
       }
   
       sprintf(fichier, "/RPL-%llu-%llu-%d", (unsigned long long) pid,
               (unsigned long long) tid, ordre);
     return(fichier);      return(fichier);
 }  }
   
Line 56  nom_segment_semaphore(pid_t pid) Line 71  nom_segment_semaphore(pid_t pid)
 */  */
   
 sem_t *  sem_t *
 sem_init2(unsigned int valeur, pid_t pid)  sem_init2(unsigned int valeur, pid_t pid, int ordre)
 {  {
     sem_t                       *semaphore;      sem_t                       *semaphore;
   
     unsigned char               *chemin;      unsigned char               *chemin;
     unsigned int                i;      unsigned char               *langue;
   
     if ((chemin = nom_segment_semaphore(pid)) == NULL)      if ((chemin = nom_segment_semaphore(pid, ordre)) == NULL)
     {      {
         return(SEM_FAILED);          return(SEM_FAILED);
     }      }
   
     semaphore = sem_open(chemin, O_CREAT, (S_IRUSR | S_IWUSR), valeur);      if ((semaphore = sem_open(chemin, O_RDWR | O_CREAT | O_EXCL,
     free(chemin);              S_IRUSR | S_IWUSR, valeur)) == SEM_FAILED)
       {
           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);
   }
   
   
   sem_t *
   sem_init3(unsigned int valeur, pid_t pid, pthread_t tid, int ordre)
   {
       sem_t                       *semaphore;
   
       unsigned char               *chemin;
       unsigned char               *langue;
   
     for(i = 0; i < valeur; i++)      if ((chemin = nom_segment_semaphore_thread(pid, tid, ordre)) == NULL)
     {      {
         if (sem_post(semaphore) != 0)          return(SEM_FAILED);
       }
   
       if ((semaphore = sem_open(chemin, O_RDWR | O_CREAT | O_EXCL,
               S_IRUSR | S_IWUSR, valeur)) == SEM_FAILED)
       {
           if (errno == EEXIST)
         {          {
             sem_close(semaphore);              if ((langue = getenv("LANG")) != NULL)
             return(SEM_FAILED);              {
                   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);
 }  }
   
   
 sem_t *  sem_t *
 sem_open2(pid_t pid)  sem_open2(pid_t pid, int ordre)
 {  {
     unsigned char               *chemin;      unsigned char               *chemin;
   
     sem_t                       *semaphore;      sem_t                       *semaphore;
   
     if ((chemin = nom_segment_semaphore(pid)) == NULL)      if ((chemin = nom_segment_semaphore(pid, ordre)) == NULL)
     {      {
         return(1);          return(SEM_FAILED);
     }      }
   
     semaphore = sem_open(chemin, O_RDWR);      semaphore = sem_open(chemin, O_RDWR);
     free(chemin);      sys_free(chemin);
   
     return(semaphore);      return(semaphore);
 }  }
   
   
 int  int
 sem_destroy2(sem_t *semaphore, pid_t pid)  sem_destroy2(sem_t *semaphore, pid_t pid, int ordre)
 {  {
     int                         erreur;      int                         erreur;
   
Line 112  sem_destroy2(sem_t *semaphore, pid_t pid Line 196  sem_destroy2(sem_t *semaphore, pid_t pid
   
     sem_close(semaphore);      sem_close(semaphore);
   
     if ((chemin = nom_segment_semaphore(pid)) == NULL)      if ((chemin = nom_segment_semaphore(pid, ordre)) == NULL)
     {      {
         return(1);          return(1);
     }      }
   
     erreur = sem_unlink(chemin);      erreur = sem_unlink(chemin);
     free(chemin);      sys_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);
       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 182  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 192  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 229  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 236  sem_init_SysV(sem_t *semaphore, int shar Line 345  sem_init_SysV(sem_t *semaphore, int shar
                     S_IRUSR | S_IWUSR);                      S_IRUSR | S_IWUSR);
             (*semaphore).path = NULL;              (*semaphore).path = NULL;
             (*semaphore).pid = getpid();              (*semaphore).pid = getpid();
               (*semaphore).tid = pthread_self();
             (*semaphore).alloue = 0;              (*semaphore).alloue = 0;
         }          }
         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)
                     + 1 + 32 + 1) * sizeof(unsigned char))) == NULL)                      + 2 + 256 + 1) * sizeof(unsigned char))) == NULL)
             {              {
                 return(-1);                  return(-1);
             }              }
   
             sprintf((*semaphore).path, "%s/RPL-SIGSEMAPHORE-%d", racine_segment,              sprintf((*semaphore).path, "%s/RPL-SEMAPHORE-%d-%llX-%llX",
                     (int) getpid());                      racine_segment, (int) getpid(),
                       (long long unsigned) pthread_self(),
                       (long long unsigned) semaphore);
   
             if ((desc = open((*semaphore).path, 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();
               (*semaphore).tid = pthread_self();
             clef = ftok((*semaphore).path, 1);              clef = ftok((*semaphore).path, 1);
             close(desc);              close(desc);
   
             if (clef == -1)              if (clef == -1)
             {              {
                 free((*semaphore).path);                  sys_free((*semaphore).path);
                 return(-1);                  return(-1);
             }              }
   
Line 278  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);
 #   else // OS/2  #   else // OS/2
           sem_t           *psem;
   
     sem_t           *psem;          psem = semaphore;
   
     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)          if (((*psem).cnt = sys_malloc(sizeof(ULONG))) == NULL)
     {          {
         free((*psem).cnt);              sys_free(psem);
         free(psem);              errno = ENOMEM;
         errno = ENOMEM;              return(-1);
         return(-1);          }
     }  
   
     if (DosCreateMutexSem(NULL, &((*psem).hmtx), 0, 0) != 0)          if (((*psem).nopened = sys_malloc(sizeof(ULONG))) == NULL)
     {          {
         free((*psem).cnt);              sys_free((*psem).cnt);
         free((*psem).nopened);              sys_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);              sys_free((*psem).cnt);
         free((*psem).cnt);              sys_free((*psem).nopened);
         free((*psem).nopened);              sys_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);
               sys_free((*psem).cnt);
               sys_free((*psem).nopened);
               sys_free(psem);
               return(-1);
           }
   
     return(0);          (*(*psem).cnt) = valeur;
           (*(*psem).nopened) = 1;
           (*psem).shared = shared;
           (*psem).allocated = 0;
   
           return(0);
 #   endif  #   endif
 }  }
   
Line 359  sem_destroy_SysV(sem_t *semaphore) Line 494  sem_destroy_SysV(sem_t *semaphore)
   
         return(0);          return(0);
 #   else // OS/2  #   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)
     {          {
         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);              sys_free((*psem).cnt);
               sys_free((*psem).nopened);
           }
           else
           {
               if ((*(*psem).nopened) == 0)
               {
                   DosFreeMem((*psem).cnt);
               }
         }          }
     }  
   
     if ((*psem).allocated != 0)  
     {     
         free(psem);  
     }  
   
     return(0);          if ((*psem).allocated != 0)
           {   
               sys_free(psem);
           }
   
           return(0);
 #   endif  #   endif
 }  }
   
Line 410  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);
 #   else // OS/2  #   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
 }  }
   
Line 470  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);
 #   else // OS/2  #   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)
           {
               errno = (ios == ERROR_TIMEOUT) ? EAGAIN : EINVAL;
               return(-1);
           }
   
     if ((ios = DosWaitEventSem((*psem).hev, SEM_IMMEDIATE_RETURN)) != 0)          if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
     {          {
         errno = (ios == ERROR_TIMEOUT) ? EAGAIN : EINVAL;              errno = EINVAL;
         return(-1);              return(-1);
     }          }
   
     if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)          if ((*(*psem).cnt) > 0)
     {          {
         errno = EINVAL;              (*(*psem).cnt)--;
         return(-1);          }
     }  
   
     if ((*(*psem).cnt) > 0)          if ((*(*psem).cnt) == 0)
     {          {
         (*(*psem).cnt)--;              DosResetEventSem((*psem).hev, &cnt);
     }          }
   
     if ((*(*psem).cnt) == 0)          DosReleaseMutexSem((*psem).hmtx);
           return(0);
   #   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, >))
     {      {
         DosResetEventSem((*psem).hev, &cnt);          if (sem_trywait_SysV(sem) == 0)
     }          {
               return(0);
           }
   
     DosReleaseMutexSem((*psem).hmtx);          if (errno != EAGAIN)
     return(0);          {
               return(-1);
           }
   
 #   endif          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
Line 539  sem_post_SysV(sem_t *semaphore) Line 728  sem_post_SysV(sem_t *semaphore)
   
         return(0);          return(0);
 #   else // OS/2  #   else // OS/2
           sem_t               *psem;
   
     sem_t               *psem;          psem = semaphore;
   
     psem = semaphore;  
   
     if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)  
     {  
         errno = EINVAL;  
         return(-1);  
     }  
   
     (*(*psem).cnt)++;          if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
     DosPostEventSem((*psem).hev);          {
     DosReleaseMutexSem((*psem).hmtx);              errno = EINVAL;
               return(-1);
           }
   
     return(0);          (*(*psem).cnt)++;
           DosPostEventSem((*psem).hev);
           DosReleaseMutexSem((*psem).hmtx);
   
           return(0);
 #   endif  #   endif
 }  }
   
Line 572  sem_getvalue_SysV(sem_t *semaphore, int Line 759  sem_getvalue_SysV(sem_t *semaphore, int
   
         return(0);          return(0);
 #   else  #   else
           sem_t               *psem;
   
     sem_t               *psem;          psem = semaphore;
   
     psem = semaphore;  
   
     if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)  
     {  
         errno = EINVAL;  
         return(-1);  
     }  
   
     (*valeur) = (*(*psem).cnt);          if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
     DosReleaseMutexSem((*psem).hmtx);          {
               errno = EINVAL;
               return(-1);
           }
   
     return(0);          (*valeur) = (*(*psem).cnt);
           DosReleaseMutexSem((*psem).hmtx);
   
           return(0);
 #   endif  #   endif
 }  }
   
Line 606  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 624  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 632  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);
         }          }
   
         (*semaphore).alloue = -1;          (*semaphore).alloue = -1;
           (*semaphore).pid = getpid();
           (*semaphore).tid = pthread_self();
 #   else  #   else
           if ((nom_segment = sys_malloc((strlen(racine_memoire_OS2) + strlen(nom)
     if ((nom_segment = malloc((strlen(racine_memoire_OS2) + strlen(nom) + 1)                  + 1) * sizeof(unsigned char))) == NULL)
             * 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_segment, "%s%s", racine_memoire_OS2, nom);
     }          ptr = nom_segment;
   
     if ((nom_absolu = malloc((strlen(racine_semaphores_OS2) + strlen(nom)          while((*ptr) != d_code_fin_chaine)
             + 2) * sizeof(unsigned char))) == NULL)          {
     {              if ((*ptr) == '/')
         return(SEM_FAILED);              {
     }                  (*ptr) = '\\';
               }
   
     sprintf(nom_absolu, "%s%s", racine_semaphores_OS2, nom);              ptr++;
     ptr = nom_absolu;          }
   
     while((*ptr) != d_code_fin_chaine)          if ((nom_absolu = sys_malloc((strlen(racine_semaphores_OS2) +
     {                  strlen(nom) + 2) * sizeof(unsigned char))) == NULL)
         if ((*ptr) == '/')  
         {          {
             (*ptr) = '\\';              return(SEM_FAILED);
         }          }
   
         ptr++;          sprintf(nom_absolu, "%s%s", racine_semaphores_OS2, nom);
     }          ptr = nom_absolu;
   
     (*(ptr + 1)) = d_code_fin_chaine;          while((*ptr) != d_code_fin_chaine)
           {
               if ((*ptr) == '/')
               {
                   (*ptr) = '\\';
               }
   
     if ((psem = malloc(sizeof(sem_t))) == NULL)              ptr++;
     {          }
         return(SEM_FAILED);  
     }  
   
     (*psem).allocated = 1;          (*(ptr + 1)) = d_code_fin_chaine;
   
           if ((psem = sys_malloc(sizeof(sem_t))) == NULL)
           {
               return(SEM_FAILED);
           }
   
           (*psem).allocated = 1;
 #   endif  #   endif
   
     if ((oflag & O_CREAT) == 0)      if ((oflag & O_CREAT) == 0)
Line 707  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);
         }              }
   
         (*ptr) = 'M';  
   
         if (DosOpenMutexSem(nom_absolu, &((*psem).hmtx)) != 0)              (*ptr) = 'M';
         {  
             free(psem);  
             free(nom_absolu);  
             free(nom_segment);  
   
             return(SEM_FAILED);              if (DosOpenMutexSem(nom_absolu, &((*psem).hmtx)) != 0)
         }              {
                   sys_free(psem);
                   sys_free(nom_absolu);
                   sys_free(nom_segment);
   
         (*ptr) = 'S';                  return(SEM_FAILED);
               }
   
         if (DosOpenEventSem(nom_absolu, &((*psem).hev)) != 0)              (*ptr) = 'S';
         {  
             DosCloseMutexSem((*psem).hmtx);  
   
             free(psem);              if (DosOpenEventSem(nom_absolu, &((*psem).hev)) != 0)
             free(nom_absolu);              {
             free(nom_segment);                  DosCloseMutexSem((*psem).hmtx);
   
             return(SEM_FAILED);                  sys_free(psem);
         }                  sys_free(nom_absolu);
                   sys_free(nom_segment);
   
         if (DosGetNamedSharedMem(&base, nom_segment, PAG_WRITE | PAG_READ) != 0)                  return(SEM_FAILED);
         {              }
             DosCloseMutexSem((*psem).hmtx);  
   
             free(nom_absolu);              if (DosGetNamedSharedMem(&base, nom_segment, PAG_WRITE | PAG_READ)
             free(nom_segment);                      != 0)
             free(psem);              {
                   DosCloseMutexSem((*psem).hmtx);
   
             return(SEM_FAILED);                  sys_free(nom_absolu);
         }                  sys_free(nom_segment);
                   sys_free(psem);
   
         free(nom_segment);                  return(SEM_FAILED);
               }
   
         (*psem).cnt = (ULONG *) base;              sys_free(nom_segment);
         (*psem).nopened = ((ULONG *) base) + 1;  
         (*psem).shared = 1;  
   
         if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)              (*psem).cnt = (ULONG *) base;
         {              (*psem).nopened = ((ULONG *) base) + 1;
             DosCloseMutexSem((*psem).hmtx);              (*psem).shared = 1;
   
             free(nom_absolu);              if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
             free(nom_segment);              {
             free(psem);                  DosCloseMutexSem((*psem).hmtx);
   
             return(SEM_FAILED);                  sys_free(nom_absolu);
         }                  sys_free(nom_segment);
                   sys_free(psem);
   
         (*((*psem).nopened))++;                  return(SEM_FAILED);
               }
   
         DosReleaseMutexSem((*psem).hmtx);              (*((*psem).nopened))++;
   
         semaphore = psem;              DosReleaseMutexSem((*psem).hmtx);
   
               semaphore = psem;
 #       endif  #       endif
     }      }
     else      else
Line 793  sem_t Line 980  sem_t
         va_end(liste);          va_end(liste);
   
 #       ifndef OS2 // IPCS_SYSV  #       ifndef OS2 // IPCS_SYSV
             if ((desc = open(nom_absolu, O_CREAT | O_EXCL | S_IRUSR | S_IWUSR))              if ((desc = open(nom_absolu, O_CREAT | O_EXCL | O_RDWR,
                     == -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 822  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 = sys_malloc(sizeof(sem_t))) == NULL)
               {
                   sys_free(nom_absolu);
                   sys_free(nom_segment);
   
         if ((psem = malloc(sizeof(sem_t))) == NULL)                  return(SEM_FAILED);
         {              }
             free(nom_absolu);  
             free(nom_segment);  
   
             return(SEM_FAILED);  
         }  
   
         (*ptr) = 'M';  
   
         if (DosCreateMutexSem(nom_absolu, &((*psem).hmtx), 0, 0) != 0)              (*ptr) = 'M';
         {  
             free(psem);  
             free(nom_absolu);  
             free(nom_segment);  
   
             return(SEM_FAILED);              if (DosCreateMutexSem(nom_absolu, &((*psem).hmtx), 0, 0) != 0)
         }              {
                   sys_free(psem);
                   sys_free(nom_absolu);
                   sys_free(nom_segment);
   
         (*ptr) = 'S';                  return(SEM_FAILED);
               }
   
         if (DosCreateEventSem(nom_absolu, &((*psem).hev), 0,              (*ptr) = 'S';
                 (valeur != 0) ? 1 : 0) != 0)  
         {  
             DosCloseMutexSem((*psem).hmtx);  
   
             free(nom_absolu);              if (DosCreateEventSem(nom_absolu, &((*psem).hev), 0,
             free(nom_segment);                      (valeur != 0) ? 1 : 0) != 0)
             free(psem);              {
                   DosCloseMutexSem((*psem).hmtx);
   
             return(SEM_FAILED);                  sys_free(nom_absolu);
         }                  sys_free(nom_segment);
                   sys_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);              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);                  sys_free(nom_absolu);
         }                  sys_free(nom_segment);
                   sys_free(psem);
   
         free(nom_segment);                  return(SEM_FAILED);
               }
   
         (*psem).cnt = (ULONG *) base;              sys_free(nom_segment);
         (*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 899  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);
 #   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);              sys_free((*psem).cnt);
               sys_free((*psem).nopened);
           }
           else
           {
               if ((*(*psem).nopened) == 0)
               {
                   DosFreeMem((*psem).cnt);
               }
         }          }
     }  
   
     if ((*psem).allocated != 0)  
     {  
         free(psem);  
     }  
   
     return(0);          if ((*psem).allocated != 0)
           {
               sys_free(psem);
           }
   
           return(0);
 #   endif  #   endif
 }  }
   
 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
         unsigned char       *nom_absolu;          semctl(semget(ftok(nom, 1), 0, 0), 0, IPC_RMID);
   
         if ((nom_absolu = malloc((strlen(racine_segment) + strlen(nom)          if (unlink(nom) == -1)
                 + 2) * sizeof(unsigned char))) == NULL)  
         {          {
             return(ENOMEM);  
         }  
   
         sprintf(nom_absolu, "%s/%s", racine_segment, nom);  
         semctl(semget(ftok(nom_absolu, 1), 0, 0), 0, IPC_RMID);  
   
         if (unlink(nom_absolu) == -1)  
         {  
             free(nom_absolu);  
             return(EACCES);              return(EACCES);
         }          }
   
         free(nom_absolu);          sys_free(nom);
         return(0);          return(0);
 #   else  #   else
           return(0);
     return(0);  
   
 #   endif  #   endif
 }  }
   
Removed from v.1.32  
changed lines
  Added in v.1.89

CVSweb interface <joel.bertrand@systella.fr>