Diff for /linux/kernel/signal.c between versions 1.1.1.2 and 1.1.1.3

version 1.1.1.2, 2018/04/24 18:02:25 version 1.1.1.3, 2018/04/24 18:03:19
Line 9 Line 9
 #include <asm/segment.h>  #include <asm/segment.h>
   
 #include <signal.h>  #include <signal.h>
   #include <errno.h>
 volatile void do_exit(int error_code);    
   
 int sys_sgetmask()  int sys_sgetmask()
 {  {
         return current->blocked;          return current->blocked;
Line 21  int sys_ssetmask(int newmask) Line 20  int sys_ssetmask(int newmask)
 {  {
         int old=current->blocked;          int old=current->blocked;
   
         current->blocked = newmask & ~(1<<(SIGKILL-1));          current->blocked = newmask & ~(1<<(SIGKILL-1)) & ~(1<<(SIGSTOP-1));
         return old;          return old;
 }  }
   
   int sys_sigpending(sigset_t *set)
   {
       /* fill in "set" with signals pending but blocked. */
       verify_area(set,4);
       put_fs_long(current->blocked & current->signal, (unsigned long *)set);
       return 0;
   }
   
   /* atomically swap in the new signal mask, and wait for a signal.
    *
    * we need to play some games with syscall restarting.  We get help
    * from the syscall library interface.  Note that we need to coordinate
    * the calling convention with the libc routine.
    *
    * "set" is just the sigmask as described in 1003.1-1988, 3.3.7.
    *      It is assumed that sigset_t can be passed as a 32 bit quantity.
    *
    * "restart" holds a restart indication.  If it's non-zero, then we 
    *      install the old mask, and return normally.  If it's zero, we store 
    *      the current mask in old_mask and block until a signal comes in.
    */
   int sys_sigsuspend(int restart, unsigned long old_mask, unsigned long set)
   {
       extern int sys_pause(void);
   
       if (restart) {
           /* we're restarting */
           current->blocked = old_mask;
           return -EINTR;
       }
       /* we're not restarting.  do the work */
       *(&restart) = 1;
       *(&old_mask) = current->blocked;
       current->blocked = set;
       (void) sys_pause();                 /* return after a signal arrives */
       return -ERESTARTNOINTR;             /* handle the signal, and come back */
   }
   
 static inline void save_old(char * from,char * to)  static inline void save_old(char * from,char * to)
 {  {
         int i;          int i;
Line 49  int sys_signal(int signum, long handler, Line 86  int sys_signal(int signum, long handler,
 {  {
         struct sigaction tmp;          struct sigaction tmp;
   
         if (signum<1 || signum>32 || signum==SIGKILL)          if (signum<1 || signum>32 || signum==SIGKILL || signum==SIGSTOP)
                 return -1;                  return -EINVAL;
         tmp.sa_handler = (void (*)(int)) handler;          tmp.sa_handler = (void (*)(int)) handler;
         tmp.sa_mask = 0;          tmp.sa_mask = 0;
         tmp.sa_flags = SA_ONESHOT | SA_NOMASK;          tmp.sa_flags = SA_ONESHOT | SA_NOMASK;
Line 65  int sys_sigaction(int signum, const stru Line 102  int sys_sigaction(int signum, const stru
 {  {
         struct sigaction tmp;          struct sigaction tmp;
   
         if (signum<1 || signum>32 || signum==SIGKILL)          if (signum<1 || signum>32 || signum==SIGKILL || signum==SIGSTOP)
                 return -1;                  return -EINVAL;
         tmp = current->sigaction[signum-1];          tmp = current->sigaction[signum-1];
         get_new((char *) action,          get_new((char *) action,
                 (char *) (signum-1+current->sigaction));                  (char *) (signum-1+current->sigaction));
Line 79  int sys_sigaction(int signum, const stru Line 116  int sys_sigaction(int signum, const stru
         return 0;          return 0;
 }  }
   
 void do_signal(long signr,long eax, long ebx, long ecx, long edx,  /*
    * Routine writes a core dump image in the current directory.
    * Currently not implemented.
    */
   int core_dump(long signr)
   {
           return(0);      /* We didn't do a dump */
   }
   
   int do_signal(long signr,long eax,long ebx, long ecx, long edx, long orig_eax,
         long fs, long es, long ds,          long fs, long es, long ds,
         long eip, long cs, long eflags,          long eip, long cs, long eflags,
         unsigned long * esp, long ss)          unsigned long * esp, long ss)
Line 88  void do_signal(long signr,long eax, long Line 134  void do_signal(long signr,long eax, long
         long old_eip=eip;          long old_eip=eip;
         struct sigaction * sa = current->sigaction + signr - 1;          struct sigaction * sa = current->sigaction + signr - 1;
         int longs;          int longs;
   
         unsigned long * tmp_esp;          unsigned long * tmp_esp;
   
   #ifdef notdef
           printk("pid: %d, signr: %x, eax=%d, oeax = %d, int=%d\n", 
                   current->pid, signr, eax, orig_eax, 
                   sa->sa_flags & SA_INTERRUPT);
   #endif
           if ((orig_eax != -1) &&
               ((eax == -ERESTARTSYS) || (eax == -ERESTARTNOINTR))) {
                   if ((eax == -ERESTARTSYS) && ((sa->sa_flags & SA_INTERRUPT) ||
                       signr < SIGCONT || signr > SIGTTOU))
                           *(&eax) = -EINTR;
                   else {
                           *(&eax) = orig_eax;
                           *(&eip) = old_eip -= 2;
                   }
           }
         sa_handler = (unsigned long) sa->sa_handler;          sa_handler = (unsigned long) sa->sa_handler;
         if (sa_handler==1)          if (sa_handler==1)
                 return;                  return(1);   /* Ignore, see if there are more signals... */
         if (!sa_handler) {          if (!sa_handler) {
                 if (signr==SIGCHLD)                  switch (signr) {
                         return;                  case SIGCONT:
                 else                  case SIGCHLD:
                         do_exit(1<<(signr-1));                          return(1);  /* Ignore, ... */
   
                   case SIGSTOP:
                   case SIGTSTP:
                   case SIGTTIN:
                   case SIGTTOU:
                           current->state = TASK_STOPPED;
                           current->exit_code = signr;
                           if (!(current->p_pptr->sigaction[SIGCHLD-1].sa_flags & 
                                           SA_NOCLDSTOP))
                                   current->p_pptr->signal |= (1<<(SIGCHLD-1));
                           return(1);  /* Reschedule another event */
   
                   case SIGQUIT:
                   case SIGILL:
                   case SIGTRAP:
                   case SIGIOT:
                   case SIGFPE:
                   case SIGSEGV:
                           if (core_dump(signr))
                                   do_exit(signr|0x80);
                           /* fall through */
                   default:
                           do_exit(signr);
                   }
         }          }
           /*
            * OK, we're invoking a handler 
            */
         if (sa->sa_flags & SA_ONESHOT)          if (sa->sa_flags & SA_ONESHOT)
                 sa->sa_handler = NULL;                  sa->sa_handler = NULL;
         *(&eip) = sa_handler;          *(&eip) = sa_handler;
Line 116  void do_signal(long signr,long eax, long Line 205  void do_signal(long signr,long eax, long
         put_fs_long(eflags,tmp_esp++);          put_fs_long(eflags,tmp_esp++);
         put_fs_long(old_eip,tmp_esp++);          put_fs_long(old_eip,tmp_esp++);
         current->blocked |= sa->sa_mask;          current->blocked |= sa->sa_mask;
           return(0);              /* Continue, execute handler */
 }  }

Removed from v.1.1.1.2  
changed lines
  Added in v.1.1.1.3


unix.superglobalmegacorp.com