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

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

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

CVSweb interface <joel.bertrand@systella.fr>