Diff for /linux/kernel/exit.c between versions 1.1.1.11 and 1.1.1.12

version 1.1.1.11, 2018/04/24 18:13:04 version 1.1.1.12, 2018/04/24 18:15:09
Line 11 Line 11
 #include <linux/signal.h>  #include <linux/signal.h>
 #include <linux/sched.h>  #include <linux/sched.h>
 #include <linux/kernel.h>  #include <linux/kernel.h>
   #include <linux/resource.h>
 #include <linux/mm.h>  #include <linux/mm.h>
 #include <linux/tty.h>  #include <linux/tty.h>
   
 #include <asm/segment.h>  #include <asm/segment.h>
   
 int sys_close(int fd);  int sys_close(int fd);
   void getrusage(struct task_struct *, int, struct rusage *);
   
 int send_sig(long sig,struct task_struct * p,int priv)  int send_sig(long sig,struct task_struct * p,int priv)
 {  {
Line 203  int kill_pg(int pgrp, int sig, int priv) Line 205  int kill_pg(int pgrp, int sig, int priv)
         return(found ? 0 : retval);          return(found ? 0 : retval);
 }  }
   
   /* This routine is used by vhangup.  It send's sigkill to everything
      waiting on a particular wait_queue.  It assumes root privledges.
      We don't want to destroy the wait queue here, because the caller
      should call wake_up immediately after calling kill_wait. */
   
   void
   kill_wait (struct wait_queue **q, int sig)
   {
      struct wait_queue *next;
      struct wait_queue *tmp;
      struct task_struct *p;
      
      if (!q || !(next = *q))
        return;
      do { 
         tmp = next;
         next = tmp->next;
         if (p = tmp->task)
           {
              send_sig (sig, p , 1);
           }
      } while (next && next != *q);
   }
   
 int kill_proc(int pid, int sig, int priv)  int kill_proc(int pid, int sig, int priv)
 {  {
         struct task_struct **p;          struct task_struct **p;
Line 297  volatile void do_exit(long code) Line 323  volatile void do_exit(long code)
         int i;          int i;
   
 fake_volatile:  fake_volatile:
         free_page_tables(get_base(current->ldt[1]),get_limit(0x0f));          free_page_tables(current);
         free_page_tables(get_base(current->ldt[2]),get_limit(0x17));  
         for (i=0 ; i<NR_OPEN ; i++)          for (i=0 ; i<NR_OPEN ; i++)
                 if (current->filp[i])                  if (current->filp[i])
                         sys_close(i);                          sys_close(i);
Line 412  int sys_exit(int error_code) Line 437  int sys_exit(int error_code)
         do_exit((error_code&0xff)<<8);          do_exit((error_code&0xff)<<8);
 }  }
   
 int sys_waitpid(pid_t pid,unsigned long * stat_addr, int options)  int sys_wait4(pid_t pid,unsigned long * stat_addr, int options, struct rusage * ru)
 {  {
         int flag;          int flag;
         struct task_struct *p;          struct task_struct *p;
Line 444  repeat: Line 469  repeat:
                                         put_fs_long((p->exit_code << 8) | 0x7f,                                          put_fs_long((p->exit_code << 8) | 0x7f,
                                                 stat_addr);                                                  stat_addr);
                                 p->exit_code = 0;                                  p->exit_code = 0;
                                   if (ru != NULL)
                                           getrusage(p, RUSAGE_BOTH, ru);
                                 return p->pid;                                  return p->pid;
                         case TASK_ZOMBIE:                          case TASK_ZOMBIE:
                                 current->cutime += p->utime + p->cutime;                                  current->cutime += p->utime + p->cutime;
                                 current->cstime += p->stime + p->cstime;                                  current->cstime += p->stime + p->cstime;
                                 current->cmin_flt += p->min_flt + p->cmin_flt;                                  current->cmin_flt += p->min_flt + p->cmin_flt;
                                 current->cmaj_flt += p->maj_flt + p->cmaj_flt;                                  current->cmaj_flt += p->maj_flt + p->cmaj_flt;
                                   if (ru != NULL)
                                           getrusage(p, RUSAGE_BOTH, ru);
                                 flag = p->pid;                                  flag = p->pid;
                                 if (stat_addr)                                  if (stat_addr)
                                         put_fs_long(p->exit_code, stat_addr);                                          put_fs_long(p->exit_code, stat_addr);
Line 484  repeat: Line 513  repeat:
         }          }
         return -ECHILD;          return -ECHILD;
 }  }
   
   /*
    * sys_waitpid() remains for compatibility. waitpid() should be
    * implemented by calling sys_wait4() from libc.a.
    */
   int sys_waitpid(pid_t pid,unsigned long * stat_addr, int options)
   {
           return sys_wait4(pid, stat_addr, options, NULL);
   }

Removed from v.1.1.1.11  
changed lines
  Added in v.1.1.1.12


unix.superglobalmegacorp.com