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

Diff for /rpl/src/interruptions.c between versions 1.142 and 1.147

version 1.142, 2014/04/25 07:37:34 version 1.147, 2014/07/15 14:12:38
Line 1468  verrouillage_gestionnaire_signaux(struct Line 1468  verrouillage_gestionnaire_signaux(struct
         return;          return;
     }      }
   
 #   ifndef SEMAPHORES_NOMMES  
     if (sem_post(&semaphore_gestionnaires_signaux) == -1)  
 #   else  
     if (sem_post(semaphore_gestionnaires_signaux) == -1)  
 #   endif  
     {  
 #       ifndef SEMAPHORES_NOMMES  
         sem_wait(&((*s_etat_processus).semaphore_fork));  
 #       else  
         sem_wait((*s_etat_processus).semaphore_fork);  
 #       endif  
         BUG(1, uprintf("Lock error !\n"));  
         return;  
     }  
   
     return;      return;
 }  }
   
Line 1612  thread_signaux(void *argument) Line 1597  thread_signaux(void *argument)
             pthread_exit(NULL);              pthread_exit(NULL);
         }          }
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
         read(fds.fd, &signal, 1);          read(fds.fd, &signal, 1);
   
   #   pragma GCC diagnostic pop
   
         if (signal != (0xFF & rpl_sigmax))          if (signal != (0xFF & rpl_sigmax))
         {          {
             envoi_signal_processus(getpid(), signal);              envoi_signal_processus(getpid(), signal);
Line 1636  interruption1(int signal) Line 1626  interruption1(int signal)
   
     test_signal(signal);      test_signal(signal);
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
     switch(signal)      switch(signal)
     {      {
         case SIGINT:          case SIGINT:
Line 1658  interruption1(int signal) Line 1651  interruption1(int signal)
             break;              break;
     }      }
   
   #   pragma GCC diagnostic pop
   
     return;      return;
 }  }
   
Line 1679  interruption2(int signal) Line 1674  interruption2(int signal)
     test_signal(signal);      test_signal(signal);
   
     signal_tronque = (unsigned char) (rpl_sigtstp & 0xFF);      signal_tronque = (unsigned char) (rpl_sigtstp & 0xFF);
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
     write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));      write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
   
   #   pragma GCC diagnostic pop
   
     return;      return;
 }  }
   
Line 1702  interruption3(int signal) Line 1704  interruption3(int signal)
         kill(pid_processus_pere, SIGUSR1);          kill(pid_processus_pere, SIGUSR1);
     }      }
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
     if (signal != SIGUSR2)      if (signal != SIGUSR2)
     {      {
         write(STDERR_FILENO, message_1, strlen(message_1));          write(STDERR_FILENO, message_1, strlen(message_1));
Line 1711  interruption3(int signal) Line 1716  interruption3(int signal)
         write(STDERR_FILENO, message_2, strlen(message_2));          write(STDERR_FILENO, message_2, strlen(message_2));
     }      }
   
   #   pragma GCC diagnostic pop
   
     _exit(EXIT_FAILURE);      _exit(EXIT_FAILURE);
 }  }
   
Line 1725  interruption4(int signal) Line 1732  interruption4(int signal)
     test_signal(signal);      test_signal(signal);
   
     signal_tronque = (unsigned char) (rpl_sighup & 0xFF);      signal_tronque = (unsigned char) (rpl_sighup & 0xFF);
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
     write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));      write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
   
   #   pragma GCC diagnostic pop
   
     return;      return;
 }  }
   
Line 1741  interruption5(int signal) Line 1755  interruption5(int signal)
   
     test_signal(signal);      test_signal(signal);
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
     if (pid_processus_pere == getpid())      if (pid_processus_pere == getpid())
     {      {
         signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF);          signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF);
Line 1748  interruption5(int signal) Line 1765  interruption5(int signal)
     }      }
   
     write(STDERR_FILENO, message, strlen(message));      write(STDERR_FILENO, message, strlen(message));
   
   #   pragma GCC diagnostic pop
   
     return;      return;
 }  }
   
Line 2029  interruption_violation_access(void *adre Line 2049  interruption_violation_access(void *adre
         return(0);          return(0);
     }      }
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
     write(STDERR_FILENO, message, strlen(message));      write(STDERR_FILENO, message, strlen(message));
   
   #   pragma GCC diagnostic pop
   
     if (pid_processus_pere == getpid())      if (pid_processus_pere == getpid())
     {      {
         longjmp(contexte_initial, -1);          longjmp(contexte_initial, -1);
Line 2290  signal_hup(struct_processus *s_etat_proc Line 2315  signal_hup(struct_processus *s_etat_proc
             (unsigned long long) getpid(),              (unsigned long long) getpid(),
             (unsigned long long) pthread_self());              (unsigned long long) pthread_self());
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
     if ((fichier = fopen(nom, "w+")) != NULL)      if ((fichier = fopen(nom, "w+")) != NULL)
     {      {
         fclose(fichier);          fclose(fichier);
Line 2300  signal_hup(struct_processus *s_etat_proc Line 2328  signal_hup(struct_processus *s_etat_proc
   
     freopen("/dev/null", "r", stdin);      freopen("/dev/null", "r", stdin);
   
   #   pragma GCC diagnostic pop
   
     if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)      if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
     {      {
         printf("[%d] RPL/SIGHUP (thread %llu)\n", (int) getpid(),          printf("[%d] RPL/SIGHUP (thread %llu)\n", (int) getpid(),
Line 2436  scrutation_interruptions(struct_processu Line 2466  scrutation_interruptions(struct_processu
                     ((*s_queue_signaux).pointeur_lecture + 1)                      ((*s_queue_signaux).pointeur_lecture + 1)
                     % LONGUEUR_QUEUE_SIGNAUX;                      % LONGUEUR_QUEUE_SIGNAUX;
   
   #           ifndef IPCS_SYSV
             if (msync(s_queue_signaux, sizeof(s_queue_signaux),              if (msync(s_queue_signaux, sizeof(s_queue_signaux),
                     MS_ASYNC | MS_INVALIDATE) != 0)                      MS_ASYNC | MS_INVALIDATE) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
   #           endif
   
             while(sem_wait(semaphore_signalisation) != 0)              while(sem_wait(semaphore_signalisation) != 0)
             {              {
Line 2606  envoi_signal_processus(pid_t pid, enum s Line 2638  envoi_signal_processus(pid_t pid, enum s
                 ((*s_queue_signaux).pointeur_ecriture + 1)                  ((*s_queue_signaux).pointeur_ecriture + 1)
                 % LONGUEUR_QUEUE_SIGNAUX;                  % LONGUEUR_QUEUE_SIGNAUX;
   
   #       ifndef IPCS_SYSV
         if (msync(s_queue_signaux, sizeof(s_queue_signaux),          if (msync(s_queue_signaux, sizeof(s_queue_signaux),
                 MS_ASYNC | MS_INVALIDATE) != 0)                  MS_ASYNC | MS_INVALIDATE) != 0)
         {          {
             return(1);              return(1);
         }          }
   #       endif
   
         if (sem_post(semaphore_queue_signaux) != 0)          if (sem_post(semaphore_queue_signaux) != 0)
         {          {
Line 2719  envoi_signal_processus(pid_t pid, enum s Line 2753  envoi_signal_processus(pid_t pid, enum s
         (*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1)          (*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1)
                 % LONGUEUR_QUEUE_SIGNAUX;                  % LONGUEUR_QUEUE_SIGNAUX;
   
   #       ifndef IPCS_SYSV
         if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)          if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
         {          {
             sem_close(semaphore);              sem_close(semaphore);
             sem_close(signalisation);              sem_close(signalisation);
             return(1);              return(1);
         }          }
   #       endif
   
         if (sem_post(semaphore) != 0)          if (sem_post(semaphore) != 0)
         {          {
Line 2950  creation_queue_signaux(struct_processus Line 2986  creation_queue_signaux(struct_processus
   
         (*s_queue_signaux).requete_arret = d_faux;          (*s_queue_signaux).requete_arret = d_faux;
   
   #       ifndef IPCS_SYSV
         if (msync(s_queue_signaux, sizeof(struct_queue_signaux), MS_SYNC))          if (msync(s_queue_signaux, sizeof(struct_queue_signaux), MS_SYNC))
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
   #       endif
 #   else // IPCS_SYSV  #   else // IPCS_SYSV
 #       ifndef OS2  #       ifndef OS2
             int                             segment;              int                             segment;
Line 3136  void Line 3174  void
 liberation_queue_signaux(struct_processus *s_etat_processus)  liberation_queue_signaux(struct_processus *s_etat_processus)
 {  {
     sem_wait(semaphore_arret_signalisation);      sem_wait(semaphore_arret_signalisation);
   
     (*s_queue_signaux).requete_arret = d_vrai;      (*s_queue_signaux).requete_arret = d_vrai;
   
   #   ifndef IPCS_SYSV
     msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE);      msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE);
   #   endif
   
     sem_post(semaphore_arret_signalisation);      sem_post(semaphore_arret_signalisation);
   
     // Incrémenter le sémaphore pour être sûr de le débloquer.      // Incrémenter le sémaphore pour être sûr de le débloquer.
   
     sem_post(semaphore_signalisation);      sem_post(semaphore_signalisation);
   
     pthread_join((*s_queue_signaux).thread_signaux, NULL);      pthread_join((*s_queue_signaux).thread_signaux, NULL);
   
 #   ifdef IPCS_SYSV // SystemV  #   ifdef IPCS_SYSV // SystemV
Line 3198  destruction_queue_signaux(struct_process Line 3237  destruction_queue_signaux(struct_process
     sem_wait(semaphore_arret_signalisation);      sem_wait(semaphore_arret_signalisation);
   
     (*s_queue_signaux).requete_arret = d_vrai;      (*s_queue_signaux).requete_arret = d_vrai;
   
   #   ifndef IPCS_SYSV
     msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE);      msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE);
   #   endif
   
     sem_post(semaphore_arret_signalisation);      sem_post(semaphore_arret_signalisation);
   
     // Incrémenter le sémaphore pour être sûr de le débloquer.      // Incrémenter le sémaphore pour être sûr de le débloquer.
   
     sem_post(semaphore_signalisation);      sem_post(semaphore_signalisation);
   
     pthread_join((*s_queue_signaux).thread_signaux, NULL);      pthread_join((*s_queue_signaux).thread_signaux, NULL);
   
 #   ifdef IPCS_SYSV // SystemV  #   ifdef IPCS_SYSV // SystemV
Line 3276  destruction_queue_signaux(struct_process Line 3318  destruction_queue_signaux(struct_process
             }              }
 #       endif  #       endif
 #   else // POSIX  #   else // POSIX
         sem_close(semaphore_queue_signaux);  
         sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);          sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);
   
         sem_close(semaphore_signalisation);  
         sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION);          sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION);
   
         sem_close(semaphore_arret_signalisation);  
         sem_destroy2(semaphore_arret_signalisation, getpid(),          sem_destroy2(semaphore_arret_signalisation, getpid(),
                 SEM_ARRET_SIGNALISATION);                  SEM_ARRET_SIGNALISATION);
   
Removed from v.1.142  
changed lines
  Added in v.1.147

CVSweb interface <joel.bertrand@systella.fr>