Diff for /linux/kernel/signal.c between versions 1.1.1.4 and 1.1.1.8

version 1.1.1.4, 2018/04/24 18:04:29 version 1.1.1.8, 2018/04/24 18:15:15
Line 1 Line 1
 /*  /*
  *  linux/kernel/signal.c   *  linux/kernel/signal.c
  *   *
  *  (C) 1991  Linus Torvalds   *  Copyright (C) 1991, 1992  Linus Torvalds
  */   */
   
 #include <linux/sched.h>  #include <linux/sched.h>
 #include <linux/kernel.h>  #include <linux/kernel.h>
   #include <linux/signal.h>
   #include <linux/errno.h>
   #include <linux/wait.h>
   #include <linux/ptrace.h>
   
 #include <asm/segment.h>  #include <asm/segment.h>
   
 #include <signal.h>  extern int core_dump(long signr,struct pt_regs * regs);
 #include <sys/wait.h>  
 #include <errno.h>  
     
 int send_sig (int, struct task_struct *, int);  
     
 int sys_sgetmask()  int sys_sgetmask()
 {  {
         return current->blocked;          return current->blocked;
Line 93  int sys_signal(int signum, long handler, Line 94  int sys_signal(int signum, long handler,
                 return -EINVAL;                  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 | SA_INTERRUPT;
         tmp.sa_restorer = (void (*)(void)) restorer;          tmp.sa_restorer = (void (*)(void)) restorer;
         handler = (long) current->sigaction[signum-1].sa_handler;          handler = (long) current->sigaction[signum-1].sa_handler;
         current->sigaction[signum-1] = tmp;          current->sigaction[signum-1] = tmp;
Line 119  int sys_sigaction(int signum, const stru Line 120  int sys_sigaction(int signum, const stru
         return 0;          return 0;
 }  }
   
 /*  
  * 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 */  
 }  
   
 extern int sys_waitpid(pid_t pid,unsigned long * stat_addr, int options);  extern int sys_waitpid(pid_t pid,unsigned long * stat_addr, int options);
   
 int do_signal(long signr,long ebx, long ecx, long edx,  /*
               long esi, long edi, long ebp, long eax,   * Note that 'init' is a special process: it doesn't get signals it doesn't
               long ds, long es, long fs, long gs,   * want to handle. Thus you cannot kill init even with a SIGKILL even by
               long orig_eax,   * mistake.
         long eip, long cs, long eflags,   */
         unsigned long * esp, long ss)  int do_signal(long signr,struct pt_regs * regs)
 {  {
         unsigned long sa_handler;          unsigned long sa_handler;
         long old_eip=eip;          long old_eip = regs->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          sa_handler = (unsigned long) sa->sa_handler;
         printk("pid: %d, signr: %x, eax=%d, oeax = %d, int=%d\n",           if ((regs->orig_eax >= 0) &&
                 current->pid, signr, eax, orig_eax,               ((regs->eax == -ERESTARTSYS) || (regs->eax == -ERESTARTNOINTR))) {
                 sa->sa_flags & SA_INTERRUPT);                  if ((sa_handler > 1) && (regs->eax == -ERESTARTSYS) &&
 #endif                      (sa->sa_flags & SA_INTERRUPT))
         if ((orig_eax != -1) &&                          regs->eax = -EINTR;
             ((eax == -ERESTARTSYS) || (eax == -ERESTARTNOINTR))) {  
                 if ((eax == -ERESTARTSYS) && ((sa->sa_flags & SA_INTERRUPT) ||  
                     signr < SIGCONT || signr > SIGTTOU))  
                         *(&eax) = -EINTR;  
                 else {                  else {
                         *(&eax) = orig_eax;                          regs->eax = regs->orig_eax;
                         *(&eip) = old_eip -= 2;                          regs->eip = old_eip -= 2;
                 }                  }
         }          }
         sa_handler = (unsigned long) sa->sa_handler;  
         if (sa_handler==1) {          if (sa_handler==1) {
 /* check for SIGCHLD: it's special */  /* check for SIGCHLD: it's special */
                 if (signr == SIGCHLD)                  if (signr == SIGCHLD)
Line 168  int do_signal(long signr,long ebx, long  Line 154  int do_signal(long signr,long ebx, long 
                 return(1);   /* Ignore, see if there are more signals... */                  return(1);   /* Ignore, see if there are more signals... */
         }          }
         if (!sa_handler) {          if (!sa_handler) {
                   if (current->pid == 1)
                           return 1;
                 switch (signr) {                  switch (signr) {
                 case SIGCONT:                  case SIGCONT:
                 case SIGCHLD:                  case SIGCHLD:
Line 182  int do_signal(long signr,long ebx, long  Line 170  int do_signal(long signr,long ebx, long 
                         current->exit_code = signr;                          current->exit_code = signr;
                         if (!(current->p_pptr->sigaction[SIGCHLD-1].sa_flags &                           if (!(current->p_pptr->sigaction[SIGCHLD-1].sa_flags & 
                                         SA_NOCLDSTOP))                                          SA_NOCLDSTOP))
                           send_sig(SIGCHLD, current->p_pptr, 1);                                  send_sig(SIGCHLD, current->p_pptr, 1);                  
 /*                              current->p_pptr->signal |= (1<<(SIGCHLD-1));*/  
                           
                         return(1);  /* Reschedule another event */                          return(1);  /* Reschedule another event */
   
                 case SIGQUIT:                  case SIGQUIT:
Line 193  int do_signal(long signr,long ebx, long  Line 179  int do_signal(long signr,long ebx, long 
                 case SIGIOT:                  case SIGIOT:
                 case SIGFPE:                  case SIGFPE:
                 case SIGSEGV:                  case SIGSEGV:
                         if (core_dump(signr))                          if (core_dump(signr,regs))
                                 do_exit(signr|0x80);                                  signr |= 0x80;
                         /* fall through */                          /* fall through */
                 default:                  default:
                           current->signal |= 1<<((signr & 0x7f)-1);
                         do_exit(signr);                          do_exit(signr);
                 }                  }
         }          }
Line 205  int do_signal(long signr,long ebx, long  Line 192  int do_signal(long signr,long ebx, long 
          */           */
         if (sa->sa_flags & SA_ONESHOT)          if (sa->sa_flags & SA_ONESHOT)
                 sa->sa_handler = NULL;                  sa->sa_handler = NULL;
         *(&eip) = sa_handler;          regs->eip = sa_handler;
         longs = (sa->sa_flags & SA_NOMASK)?7:8;          longs = (sa->sa_flags & SA_NOMASK)?(7*4):(8*4);
         *(&esp) -= longs;          regs->esp -= longs;
         verify_area(esp,longs*4);          tmp_esp = (unsigned long *) regs->esp;
         tmp_esp=esp;          verify_area(tmp_esp,longs);
         put_fs_long((long) sa->sa_restorer,tmp_esp++);          put_fs_long((long) sa->sa_restorer,tmp_esp++);
         put_fs_long(signr,tmp_esp++);          put_fs_long(signr,tmp_esp++);
         if (!(sa->sa_flags & SA_NOMASK))          if (!(sa->sa_flags & SA_NOMASK))
                 put_fs_long(current->blocked,tmp_esp++);                  put_fs_long(current->blocked,tmp_esp++);
         put_fs_long(eax,tmp_esp++);          put_fs_long(regs->eax,tmp_esp++);
         put_fs_long(ecx,tmp_esp++);          put_fs_long(regs->ecx,tmp_esp++);
         put_fs_long(edx,tmp_esp++);          put_fs_long(regs->edx,tmp_esp++);
         put_fs_long(eflags,tmp_esp++);          put_fs_long(regs->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;
 /* force a supervisor-mode page-in of the signal handler to reduce races */  /* force a supervisor-mode page-in of the signal handler to reduce races */

Removed from v.1.1.1.4  
changed lines
  Added in v.1.1.1.8


unix.superglobalmegacorp.com