[BACK]Return to linux_signal.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / compat / linux / common

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/compat/linux/common/linux_signal.c between version 1.24 and 1.24.2.2

version 1.24, 1999/10/04 17:46:37 version 1.24.2.2, 2001/02/11 19:14:04
Line 84 
Line 84 
                                         |= (1 << ((n) - 1) % LINUX__NSIG_BPW))                                          |= (1 << ((n) - 1) % LINUX__NSIG_BPW))
   
 /* Note: linux_to_native_sig[] is in <arch>/linux_sigarray.c */  /* Note: linux_to_native_sig[] is in <arch>/linux_sigarray.c */
 int native_to_linux_sig[NSIG] = {  const int native_to_linux_sig[NSIG] = {
         0,          0,
         LINUX_SIGHUP,          LINUX_SIGHUP,
         LINUX_SIGINT,          LINUX_SIGINT,
Line 318  native_to_linux_sigaction(bsa, lsa)
Line 318  native_to_linux_sigaction(bsa, lsa)
  */   */
 int  int
 linux_sys_rt_sigaction(p, v, retval)  linux_sys_rt_sigaction(p, v, retval)
         register struct proc *p;          struct proc *p;
         void *v;          void *v;
         register_t *retval;          register_t *retval;
 {  {
Line 330  linux_sys_rt_sigaction(p, v, retval)
Line 330  linux_sys_rt_sigaction(p, v, retval)
         } */ *uap = v;          } */ *uap = v;
         struct linux_sigaction nlsa, olsa;          struct linux_sigaction nlsa, olsa;
         struct sigaction nbsa, obsa;          struct sigaction nbsa, obsa;
         int error;          int error, sig;
   
         if (SCARG(uap, sigsetsize) != sizeof(linux_sigset_t))          if (SCARG(uap, sigsetsize) != sizeof(linux_sigset_t))
                 return (EINVAL);                  return (EINVAL);
Line 341  linux_sys_rt_sigaction(p, v, retval)
Line 341  linux_sys_rt_sigaction(p, v, retval)
                         return (error);                          return (error);
                 linux_to_native_sigaction(&nlsa, &nbsa);                  linux_to_native_sigaction(&nlsa, &nbsa);
         }          }
         error = sigaction1(p, linux_to_native_sig[SCARG(uap, signum)],          sig = SCARG(uap, signum);
             SCARG(uap, nsa) ? &nbsa : 0, SCARG(uap, osa) ? &obsa : 0);          if (sig < 0 || sig >= LINUX__NSIG)
         if (error)                  return (EINVAL);
                 return (error);          if (sig > 0 && !linux_to_native_sig[sig]) {
                   /* Pretend that we did something useful for unknown signals. */
                   obsa.sa_handler = SIG_IGN;
                   sigemptyset(&obsa.sa_mask);
                   obsa.sa_flags = 0;
           } else {
                   error = sigaction1(p, linux_to_native_sig[sig],
                       SCARG(uap, nsa) ? &nbsa : NULL, SCARG(uap, osa) ? &obsa : NULL);
                   if (error)
                           return (error);
           }
         if (SCARG(uap, osa)) {          if (SCARG(uap, osa)) {
                 native_to_linux_sigaction(&obsa, &olsa);                  native_to_linux_sigaction(&obsa, &olsa);
                 error = copyout(&olsa, SCARG(uap, osa), sizeof(olsa));                  error = copyout(&olsa, SCARG(uap, osa), sizeof(olsa));
Line 356  linux_sys_rt_sigaction(p, v, retval)
Line 366  linux_sys_rt_sigaction(p, v, retval)
   
 int  int
 linux_sigprocmask1(p, how, set, oset)  linux_sigprocmask1(p, how, set, oset)
         register struct proc *p;          struct proc *p;
         int how;          int how;
         const linux_old_sigset_t *set;          const linux_old_sigset_t *set;
         linux_old_sigset_t *oset;          linux_old_sigset_t *oset;
Line 386  linux_sigprocmask1(p, how, set, oset)
Line 396  linux_sigprocmask1(p, how, set, oset)
                 linux_old_to_native_sigset(&nlss, &nbss);                  linux_old_to_native_sigset(&nlss, &nbss);
         }          }
         error = sigprocmask1(p, how,          error = sigprocmask1(p, how,
             set ? &nbss : 0, oset ? &obss : 0);              set ? &nbss : NULL, oset ? &obss : NULL);
         if (error)          if (error)
                 return (error);                  return (error);
         if (oset) {          if (oset) {
Line 400  linux_sigprocmask1(p, how, set, oset)
Line 410  linux_sigprocmask1(p, how, set, oset)
   
 int  int
 linux_sys_rt_sigprocmask(p, v, retval)  linux_sys_rt_sigprocmask(p, v, retval)
         register struct proc *p;          struct proc *p;
         void *v;          void *v;
         register_t *retval;          register_t *retval;
 {  {
Line 443  linux_sys_rt_sigprocmask(p, v, retval)
Line 453  linux_sys_rt_sigprocmask(p, v, retval)
                 linux_to_native_sigset(&nlss, &nbss);                  linux_to_native_sigset(&nlss, &nbss);
         }          }
         error = sigprocmask1(p, how,          error = sigprocmask1(p, how,
             set ? &nbss : 0, oset ? &obss : 0);              set ? &nbss : NULL, oset ? &obss : NULL);
         if (error)          if (!error && oset) {
                 return (error);  
         if (oset) {  
                 native_to_linux_sigset(&obss, &olss);                  native_to_linux_sigset(&obss, &olss);
                 error = copyout(&olss, oset, sizeof(olss));                  error = copyout(&olss, oset, sizeof(olss));
                 if (error)  
                         return (error);  
         }          }
         return (error);          return (error);
 }  }
   
 int  int
 linux_sys_rt_sigpending(p, v, retval)  linux_sys_rt_sigpending(p, v, retval)
         register struct proc *p;          struct proc *p;
         void *v;          void *v;
         register_t *retval;          register_t *retval;
 {  {
Line 478  linux_sys_rt_sigpending(p, v, retval)
Line 484  linux_sys_rt_sigpending(p, v, retval)
   
 int  int
 linux_sys_sigpending(p, v, retval)  linux_sys_sigpending(p, v, retval)
         register struct proc *p;          struct proc *p;
         void *v;          void *v;
         register_t *retval;          register_t *retval;
 {  {
Line 495  linux_sys_sigpending(p, v, retval)
Line 501  linux_sys_sigpending(p, v, retval)
   
 int  int
 linux_sys_sigsuspend(p, v, retval)  linux_sys_sigsuspend(p, v, retval)
         register struct proc *p;          struct proc *p;
         void *v;          void *v;
         register_t *retval;          register_t *retval;
 {  {
Line 513  linux_sys_sigsuspend(p, v, retval)
Line 519  linux_sys_sigsuspend(p, v, retval)
 }  }
 int  int
 linux_sys_rt_sigsuspend(p, v, retval)  linux_sys_rt_sigsuspend(p, v, retval)
         register struct proc *p;          struct proc *p;
         void *v;          void *v;
         register_t *retval;          register_t *retval;
 {  {
Line 543  linux_sys_rt_sigsuspend(p, v, retval)
Line 549  linux_sys_rt_sigsuspend(p, v, retval)
  */   */
 int  int
 linux_sys_rt_queueinfo(p, v, retval)  linux_sys_rt_queueinfo(p, v, retval)
         register struct proc *p;          struct proc *p;
         void *v;          void *v;
         register_t *retval;          register_t *retval;
 {  {
Line 563  linux_sys_rt_queueinfo(p, v, retval)
Line 569  linux_sys_rt_queueinfo(p, v, retval)
   
 int  int
 linux_sys_kill(p, v, retval)  linux_sys_kill(p, v, retval)
         register struct proc *p;          struct proc *p;
         void *v;          void *v;
         register_t *retval;          register_t *retval;
 {  {
Line 572  linux_sys_kill(p, v, retval)
Line 578  linux_sys_kill(p, v, retval)
                 syscallarg(int) signum;                  syscallarg(int) signum;
         } */ *uap = v;          } */ *uap = v;
         struct sys_kill_args ka;          struct sys_kill_args ka;
           int sig;
   
         SCARG(&ka, pid) = SCARG(uap, pid);          SCARG(&ka, pid) = SCARG(uap, pid);
         SCARG(&ka, signum) = linux_to_native_sig[SCARG(uap, signum)];          sig = SCARG(uap, signum);
           if (sig < 0 || sig >= LINUX__NSIG)
                   return (EINVAL);
           SCARG(&ka, signum) = linux_to_native_sig[sig];
         return sys_kill(p, &ka, retval);          return sys_kill(p, &ka, retval);
 }  }
   
   #ifdef LINUX_SS_ONSTACK
   static void linux_to_native_sigaltstack __P((struct sigaltstack *,
       const struct linux_sigaltstack *));
   static void native_to_linux_sigaltstack __P((struct linux_sigaltstack *,
       const struct sigaltstack *));
   
   static void
   linux_to_native_sigaltstack(bss, lss)
           struct sigaltstack *bss;
           const struct linux_sigaltstack *lss;
   {
           bss->ss_sp = lss->ss_sp;
           bss->ss_size = lss->ss_size;
           if (lss->ss_flags & LINUX_SS_ONSTACK)
               bss->ss_flags = SS_ONSTACK;
           else if (lss->ss_flags & LINUX_SS_DISABLE)
               bss->ss_flags = SS_DISABLE;
           else
               bss->ss_flags = 0;
   }
   
   static void
   native_to_linux_sigaltstack(lss, bss)
           struct linux_sigaltstack *lss;
           const struct sigaltstack *bss;
   {
           lss->ss_sp = bss->ss_sp;
           lss->ss_size = bss->ss_size;
           if (bss->ss_flags & SS_ONSTACK)
               lss->ss_flags = LINUX_SS_ONSTACK;
           else if (bss->ss_flags & SS_DISABLE)
               lss->ss_flags = LINUX_SS_DISABLE;
           else
               lss->ss_flags = 0;
   }
   
   int
   linux_sys_sigaltstack(p, v, retval)
           struct proc *p;
           void *v;
           register_t *retval;
   {
           struct linux_sys_sigaltstack_args /* {
                   syscallarg(const struct linux_sigaltstack *) ss;
                   syscallarg(struct linux_sigaltstack *) oss;
           } */ *uap = v;
           struct linux_sigaltstack ss;
           struct sigaltstack nss, oss;
           int error;
   
           if (SCARG(uap, ss) != NULL) {
                   if ((error = copyin(SCARG(uap, ss), &ss, sizeof(ss))) != 0)
                           return error;
                   linux_to_native_sigaltstack(&nss, &ss);
           }
   
           error = sigaltstack1(p,
               SCARG(uap, ss) ? &nss : NULL, SCARG(uap, oss) ? &oss : NULL);
           if (error)
                   return error;
   
           if (SCARG(uap, oss) != NULL) {
                   native_to_linux_sigaltstack(&ss, &oss);
                   if ((error = copyout(&ss, SCARG(uap, oss), sizeof(ss))) != 0)
                           return error;
           }
           return 0;
   }
   #endif
Legend:
Removed from v.1.24  
changed lines
  Added in v.1.24.2.2
CVSweb <webmaster@jp.NetBSD.org>