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

Diff for /rpl/src/semaphores.c between versions 1.8 and 1.9

version 1.8, 2010/08/09 13:51:48 version 1.9, 2010/08/13 21:00:37
Line 121  sem_getvalue2(sem_t *semaphore, int *val Line 121  sem_getvalue2(sem_t *semaphore, int *val
 ================================================================================  ================================================================================
 */  */
   
 extern unsigned char *chemin_semaphores_SysV;  #ifndef OS2
       extern unsigned char *chemin_semaphores_SysV;
   #else
       unsigned char racine_semaphores_OS2[] = "\\SEM32\\";
       unsigned char racine_memoire_OS2[] = "\\SHAREDMEM\\";
   #endif
   
 #ifndef UNION_SEMUN  #ifndef UNION_SEMUN
 union semun  union semun
Line 136  union semun Line 141  union semun
 int  int
 sem_init_SysV(sem_t *semaphore, int shared, unsigned int valeur)  sem_init_SysV(sem_t *semaphore, int shared, unsigned int valeur)
 {  {
   #   ifndef OS2
   
     int             ios;      int             ios;
   
     union semun     argument;      union semun     argument;
   
     if (shared != 0)      if (shared != 0)
     {      {
         return(ENOSYS);          errno = ENOSYS;
           return(-1);
     }      }
   
     (*semaphore) = semget(IPC_PRIVATE, 1, IPC_CREAT | IPC_EXCL | SEM_R | SEM_A);      (*semaphore) = semget(IPC_PRIVATE, 1, IPC_CREAT | IPC_EXCL | SEM_R | SEM_A);
   
     if ((*semaphore) == -1)      if ((*semaphore) == -1)
     {      {
         return(EINVAL);          errno = EINVAL;
           return(-1);
     }      }
   
     argument.val = valeur;      argument.val = valeur;
     ios = semctl((*semaphore), 0, SETVAL, argument);      ios = semctl((*semaphore), 0, SETVAL, argument);
   
     return(ios);      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  int
 sem_destroy_SysV(sem_t *semaphore)  sem_destroy_SysV(sem_t *semaphore)
 {  {
   #   ifndef OS2
   
     if (semctl((*semaphore), IPC_RMID, 0) == -1)      if (semctl((*semaphore), IPC_RMID, 0) == -1)
     {      {
         return(EINVAL);          return(EINVAL);
     }      }
   
     return(0);      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  int
 sem_wait_SysV(sem_t *semaphore)  sem_wait_SysV(sem_t *semaphore)
 {  {
   #   ifndef OS2
   
     struct sembuf       commande;      struct sembuf       commande;
   
     commande.sem_num = 0;      commande.sem_num = 0;
Line 180  sem_wait_SysV(sem_t *semaphore) Line 291  sem_wait_SysV(sem_t *semaphore)
   
     if (semop((*semaphore), &commande, 1) == -1)      if (semop((*semaphore), &commande, 1) == -1)
     {      {
         return(EINVAL);          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);      return(0);
   
   #   endif
 }  }
   
 int  int
 sem_trywait_SysV(sem_t *semaphore)  sem_trywait_SysV(sem_t *semaphore)
 {  {
   #   ifndef OS2
   
     struct sembuf       commande;      struct sembuf       commande;
   
     commande.sem_num = 0;      commande.sem_num = 0;
Line 197  sem_trywait_SysV(sem_t *semaphore) Line 346  sem_trywait_SysV(sem_t *semaphore)
   
     if (semop((*semaphore), &commande, 1) == -1)      if (semop((*semaphore), &commande, 1) == -1)
     {      {
         if (errno == EAGAIN)          return(-1);
         {      }
             return(EAGAIN);  
         }  
   
         return(EINVAL);      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);      return(0);
   
   #   endif
 }  }
   
 int  int
 sem_post_SysV(sem_t *semaphore)  sem_post_SysV(sem_t *semaphore)
 {  {
   #   ifndef OS2
   
     struct sembuf       commande;      struct sembuf       commande;
   
     commande.sem_num = 0;      commande.sem_num = 0;
Line 219  sem_post_SysV(sem_t *semaphore) Line 402  sem_post_SysV(sem_t *semaphore)
   
     if (semop((*semaphore), &commande, 1) == -1)      if (semop((*semaphore), &commande, 1) == -1)
     {      {
         return(EINVAL);          errno = EINVAL;
           return(-1);
     }      }
   
     return(0);      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  int
 sem_getvalue_SysV(sem_t *semaphore, int *valeur)  sem_getvalue_SysV(sem_t *semaphore, int *valeur)
 {  {
   #   ifndef OS2
   
     (*valeur) = semctl((*semaphore), 0, GETVAL);      (*valeur) = semctl((*semaphore), 0, GETVAL);
   
     if ((*valeur) < 0)      if ((*valeur) < 0)
Line 236  sem_getvalue_SysV(sem_t *semaphore, int Line 442  sem_getvalue_SysV(sem_t *semaphore, int
     }      }
   
     return(0);      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_t
Line 247  sem_t Line 472  sem_t
   
     sem_t               *semaphore;      sem_t               *semaphore;
   
   #   ifndef OS2
     union semun         argument;      union semun         argument;
   #   endif
   
     unsigned char       *nom_absolu;      unsigned char       *nom_absolu;
   
Line 255  sem_t Line 482  sem_t
   
     va_list             liste;      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)      if ((nom_absolu = malloc((strlen(chemin_semaphores_SysV) + strlen(nom)
             + 1) * sizeof(unsigned char))) == NULL)              + 1) * sizeof(unsigned char))) == NULL)
     {      {
Line 268  sem_t Line 506  sem_t
         return(SEM_FAILED);          return(SEM_FAILED);
     }      }
   
       (*psem).allocated = 1;
   
   #   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);
       }
   
   #   endif
   
     if ((oflag & O_CREAT) == 0)      if ((oflag & O_CREAT) == 0)
     {      {
         // 2 arguments          // 2 arguments
   
   #       ifndef OS2
   
         (*semaphore) = semget(ftok(nom_absolu, 1), 0, 0);          (*semaphore) = semget(ftok(nom_absolu, 1), 0, 0);
   
         if ((*semaphore) == -1)          if ((*semaphore) == -1)
Line 280  sem_t Line 572  sem_t
   
             return(SEM_FAILED);              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      else
     {      {
Line 293  sem_t Line 654  sem_t
         valeur = va_arg(liste, unsigned int);          valeur = va_arg(liste, unsigned int);
         va_end(liste);          va_end(liste);
   
   #       ifndef OS2
   
         (*semaphore) = semget(ftok(nom_absolu, 1), 1,          (*semaphore) = semget(ftok(nom_absolu, 1), 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 |
Line 309  sem_t Line 672  sem_t
   
         argument.val = valeur;          argument.val = valeur;
         semctl((*semaphore), 0, SETVAL, argument);          semctl((*semaphore), 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
     }      }
   
     free(nom_absolu);      free(nom_absolu);
Line 319  sem_t Line 740  sem_t
 int  int
 sem_close_SysV(sem_t *semaphore)  sem_close_SysV(sem_t *semaphore)
 {  {
   #   ifndef OS2
   
     free(semaphore);      free(semaphore);
     return(0);      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  int
 sem_unlink_SysV(const char *nom)  sem_unlink_SysV(const char *nom)
 {  {
   #   ifndef OS2
   
     sem_t               semaphore;      sem_t               semaphore;
   
     struct sembuf       commande;      struct sembuf       commande;
Line 371  sem_unlink_SysV(const char *nom) Line 836  sem_unlink_SysV(const char *nom)
     free(nom_absolu);      free(nom_absolu);
   
     return(0);      return(0);
   
   #   else
   
       return(0);
   
   #   endif
 }  }
   
 #endif  #endif
Removed from v.1.8  
changed lines
  Added in v.1.9

CVSweb interface <joel.bertrand@systella.fr>