diff options
Diffstat (limited to 'sys/i386/linux')
| -rw-r--r-- | sys/i386/linux/linux.h | 91 | ||||
| -rw-r--r-- | sys/i386/linux/linux_dummy.c | 1 | ||||
| -rw-r--r-- | sys/i386/linux/linux_misc.c | 20 | ||||
| -rw-r--r-- | sys/i386/linux/linux_proto.h | 27 | ||||
| -rw-r--r-- | sys/i386/linux/linux_signal.c | 615 | ||||
| -rw-r--r-- | sys/i386/linux/linux_sysent.c | 2 | ||||
| -rw-r--r-- | sys/i386/linux/linux_sysvec.c | 96 | ||||
| -rw-r--r-- | sys/i386/linux/syscalls.master | 24 |
8 files changed, 477 insertions, 399 deletions
diff --git a/sys/i386/linux/linux.h b/sys/i386/linux/linux.h index e55a367..f581314 100644 --- a/sys/i386/linux/linux.h +++ b/sys/i386/linux/linux.h @@ -47,35 +47,32 @@ typedef struct { long val[2]; } linux_fsid_t; typedef int linux_pid_t; -typedef unsigned long linux_sigset_t; -typedef void (*linux_handler_t)(int); -typedef struct { - void (*lsa_handler)(int); - linux_sigset_t lsa_mask; - unsigned long lsa_flags; - void (*lsa_restorer)(void); -} linux_sigaction_t; typedef int linux_key_t; +/* + * Signal stuff... + */ +typedef void (*linux_handler_t)(int); + +typedef unsigned long linux_osigset_t; + typedef struct { - unsigned long sig[2]; -} linux_new_sigset_t; + unsigned int __bits[2]; +} linux_sigset_t; + typedef struct { - void (*lsa_handler)(int); - unsigned long lsa_flags; - void (*lsa_restorer)(void); - linux_new_sigset_t lsa_mask; -} linux_new_sigaction_t; + void (*lsa_handler)(int); + linux_osigset_t lsa_mask; + unsigned long lsa_flags; + void (*lsa_restorer)(void); +} linux_osigaction_t; -#define LINUX_MAX_UTSNAME 65 -struct linux_new_utsname { - char sysname[LINUX_MAX_UTSNAME]; - char nodename[LINUX_MAX_UTSNAME]; - char release[LINUX_MAX_UTSNAME]; - char version[LINUX_MAX_UTSNAME]; - char machine[LINUX_MAX_UTSNAME]; - char domainname[LINUX_MAX_UTSNAME]; -}; +typedef struct { + void (*lsa_handler)(int); + unsigned long lsa_flags; + void (*lsa_restorer)(void); + linux_sigset_t lsa_mask; +} linux_sigaction_t; /* * The Linux sigcontext, pretty much a standard 386 trapframe. @@ -121,20 +118,6 @@ struct linux_sigframe { extern int bsd_to_linux_signal[]; extern int linux_to_bsd_signal[]; -extern char linux_sigcode[]; -extern int linux_szsigcode; -extern const char linux_emul_path[]; - -extern struct sysent linux_sysent[LINUX_SYS_MAXSYSCALL]; -extern struct sysentvec linux_sysvec; -extern struct sysentvec elf_linux_sysvec; - -/* dummy struct definitions */ -struct image_params; -struct trapframe; - -/* misc defines */ -#define LINUX_NAME_MAX 255 /* signal numbers */ #define LINUX_SIGHUP 1 @@ -170,7 +153,8 @@ struct trapframe; #define LINUX_SIGPOLL LINUX_SIGIO #define LINUX_SIGPWR 30 #define LINUX_SIGUNUSED 31 -#define LINUX_NSIG 32 +#define LINUX_NSIG 64 +#define LINUX_SIGTBLSZ 31 /* sigaction flags */ #define LINUX_SA_NOCLDSTOP 0x00000001 @@ -188,6 +172,35 @@ struct trapframe; #define LINUX_SIG_UNBLOCK 1 #define LINUX_SIG_SETMASK 2 +#define LINUX_SIGEMPTYSET(set) (set).__bits[0] = (set).__bits[1] = 0 +#define LINUX_SIGISMEMBER(set, sig) SIGISMEMBER(set, sig) +#define LINUX_SIGADDSET(set, sig) SIGADDSET(set, sig) + +extern char linux_sigcode[]; +extern int linux_szsigcode; +extern const char linux_emul_path[]; + +extern struct sysent linux_sysent[LINUX_SYS_MAXSYSCALL]; +extern struct sysentvec linux_sysvec; +extern struct sysentvec elf_linux_sysvec; + +/* dummy struct definitions */ +struct image_params; +struct trapframe; + +#define LINUX_MAX_UTSNAME 65 +struct linux_new_utsname { + char sysname[LINUX_MAX_UTSNAME]; + char nodename[LINUX_MAX_UTSNAME]; + char release[LINUX_MAX_UTSNAME]; + char version[LINUX_MAX_UTSNAME]; + char machine[LINUX_MAX_UTSNAME]; + char domainname[LINUX_MAX_UTSNAME]; +}; + +/* misc defines */ +#define LINUX_NAME_MAX 255 + /* resource limits */ #define LINUX_RLIMIT_CPU 0 #define LINUX_RLIMIT_FSIZE 1 diff --git a/sys/i386/linux/linux_dummy.c b/sys/i386/linux/linux_dummy.c index 018446d..04c3b4a 100644 --- a/sys/i386/linux/linux_dummy.c +++ b/sys/i386/linux/linux_dummy.c @@ -102,7 +102,6 @@ DUMMY(rt_sigreturn); DUMMY(rt_sigpending); DUMMY(rt_sigtimedwait); DUMMY(rt_sigqueueinfo); -DUMMY(rt_sigsuspend); DUMMY(pread); DUMMY(pwrite); DUMMY(capget); diff --git a/sys/i386/linux/linux_misc.c b/sys/i386/linux/linux_misc.c index 919a5e7..ff5ba44 100644 --- a/sys/i386/linux/linux_misc.c +++ b/sys/i386/linux/linux_misc.c @@ -47,6 +47,7 @@ #include <sys/vnode.h> #include <sys/wait.h> #include <sys/time.h> +#include <sys/signalvar.h> #include <vm/vm.h> #include <vm/pmap.h> @@ -67,6 +68,9 @@ #include <posix4/sched.h> +#define BSD_TO_LINUX_SIGNAL(sig) \ + (((sig) <= LINUX_SIGTBLSZ) ? bsd_to_linux_signal[_SIG_IDX(sig)] : sig) + static unsigned int linux_to_bsd_resource[LINUX_RLIM_NLIMITS] = { RLIMIT_CPU, RLIMIT_FSIZE, RLIMIT_DATA, RLIMIT_STACK, RLIMIT_CORE, RLIMIT_RSS, RLIMIT_NPROC, RLIMIT_NOFILE, @@ -622,7 +626,9 @@ linux_clone(struct proc *p, struct linux_clone_args *args) exit_signal = args->flags & 0x000000ff; if (exit_signal >= LINUX_NSIG) return EINVAL; - exit_signal = linux_to_bsd_signal[exit_signal]; + + if (exit_signal <= LINUX_SIGTBLSZ) + exit_signal = linux_to_bsd_signal[_SIG_IDX(exit_signal)]; /* RFTHREAD probably not necessary here, but it shouldn't hurt either */ ff |= RFTHREAD; @@ -979,10 +985,10 @@ linux_waitpid(struct proc *p, struct linux_waitpid_args *args) return error; if (WIFSIGNALED(tmpstat)) tmpstat = (tmpstat & 0xffffff80) | - bsd_to_linux_signal[WTERMSIG(tmpstat)]; + BSD_TO_LINUX_SIGNAL(WTERMSIG(tmpstat)); else if (WIFSTOPPED(tmpstat)) tmpstat = (tmpstat & 0xffff00ff) | - (bsd_to_linux_signal[WSTOPSIG(tmpstat)]<<8); + (BSD_TO_LINUX_SIGNAL(WSTOPSIG(tmpstat)) << 8); return copyout(&tmpstat, args->status, sizeof(int)); } else return 0; @@ -1015,17 +1021,17 @@ linux_wait4(struct proc *p, struct linux_wait4_args *args) if ((error = wait4(p, &tmp)) != 0) return error; - p->p_siglist &= ~sigmask(SIGCHLD); + SIGDELSET(p->p_siglist, SIGCHLD); if (args->status) { if ((error = copyin(args->status, &tmpstat, sizeof(int))) != 0) return error; if (WIFSIGNALED(tmpstat)) tmpstat = (tmpstat & 0xffffff80) | - bsd_to_linux_signal[WTERMSIG(tmpstat)]; + BSD_TO_LINUX_SIGNAL(WTERMSIG(tmpstat)); else if (WIFSTOPPED(tmpstat)) tmpstat = (tmpstat & 0xffff00ff) | - (bsd_to_linux_signal[WSTOPSIG(tmpstat)]<<8); + (BSD_TO_LINUX_SIGNAL(WSTOPSIG(tmpstat)) << 8); return copyout(&tmpstat, args->status, sizeof(int)); } else return 0; @@ -1312,7 +1318,7 @@ linux_sched_setscheduler(p, uap) #ifdef DEBUG printf("Linux-emul(%ld): sched_setscheduler(%d, %d, %p)\n", - (long)p->p_pid, uap->pid, uap->policy, (void *)uap->param); + (long)p->p_pid, uap->pid, uap->policy, (const void *)uap->param); #endif switch (uap->policy) { diff --git a/sys/i386/linux/linux_proto.h b/sys/i386/linux/linux_proto.h index 2ae69ab..48c4409 100644 --- a/sys/i386/linux/linux_proto.h +++ b/sys/i386/linux/linux_proto.h @@ -183,22 +183,22 @@ struct linux_ustat_args { }; struct linux_sigaction_args { int sig; char sig_[PAD_(int)]; - struct linux_sigaction * nsa; char nsa_[PAD_(struct linux_sigaction *)]; - struct linux_sigaction * osa; char osa_[PAD_(struct linux_sigaction *)]; + linux_osigaction_t * nsa; char nsa_[PAD_(linux_osigaction_t *)]; + linux_osigaction_t * osa; char osa_[PAD_(linux_osigaction_t *)]; }; struct linux_siggetmask_args { register_t dummy; }; struct linux_sigsetmask_args { - linux_sigset_t mask; char mask_[PAD_(linux_sigset_t)]; + linux_osigset_t mask; char mask_[PAD_(linux_osigset_t)]; }; struct linux_sigsuspend_args { int restart; char restart_[PAD_(int)]; - linux_sigset_t oldmask; char oldmask_[PAD_(linux_sigset_t)]; - linux_sigset_t mask; char mask_[PAD_(linux_sigset_t)]; + linux_osigset_t oldmask; char oldmask_[PAD_(linux_osigset_t)]; + linux_osigset_t mask; char mask_[PAD_(linux_osigset_t)]; }; struct linux_sigpending_args { - linux_sigset_t * mask; char mask_[PAD_(linux_sigset_t *)]; + linux_osigset_t * mask; char mask_[PAD_(linux_osigset_t *)]; }; struct linux_setrlimit_args { u_int resource; char resource_[PAD_(u_int)]; @@ -338,8 +338,8 @@ struct linux_adjtimex_args { }; struct linux_sigprocmask_args { int how; char how_[PAD_(int)]; - linux_sigset_t * mask; char mask_[PAD_(linux_sigset_t *)]; - linux_sigset_t * omask; char omask_[PAD_(linux_sigset_t *)]; + linux_osigset_t * mask; char mask_[PAD_(linux_osigset_t *)]; + linux_osigset_t * omask; char omask_[PAD_(linux_osigset_t *)]; }; struct linux_create_module_args { register_t dummy; @@ -459,14 +459,14 @@ struct linux_rt_sigreturn_args { }; struct linux_rt_sigaction_args { int sig; char sig_[PAD_(int)]; - struct linux_new_sigaction * act; char act_[PAD_(struct linux_new_sigaction *)]; - struct linux_new_sigaction * oact; char oact_[PAD_(struct linux_new_sigaction *)]; + linux_sigaction_t * act; char act_[PAD_(linux_sigaction_t *)]; + linux_sigaction_t * oact; char oact_[PAD_(linux_sigaction_t *)]; size_t sigsetsize; char sigsetsize_[PAD_(size_t)]; }; struct linux_rt_sigprocmask_args { int how; char how_[PAD_(int)]; - struct linux_new_sigset * mask; char mask_[PAD_(struct linux_new_sigset *)]; - struct linux_new_sigset * omask; char omask_[PAD_(struct linux_new_sigset *)]; + linux_sigset_t * mask; char mask_[PAD_(linux_sigset_t *)]; + linux_sigset_t * omask; char omask_[PAD_(linux_sigset_t *)]; size_t sigsetsize; char sigsetsize_[PAD_(size_t)]; }; struct linux_rt_sigpending_args { @@ -479,7 +479,8 @@ struct linux_rt_sigqueueinfo_args { register_t dummy; }; struct linux_rt_sigsuspend_args { - register_t dummy; + linux_sigset_t * newset; char newset_[PAD_(linux_sigset_t *)]; + size_t sigsetsize; char sigsetsize_[PAD_(size_t)]; }; struct linux_pread_args { register_t dummy; diff --git a/sys/i386/linux/linux_signal.c b/sys/i386/linux/linux_signal.c index 9f2200e..39334a7 100644 --- a/sys/i386/linux/linux_signal.c +++ b/sys/i386/linux/linux_signal.c @@ -38,382 +38,384 @@ #include <i386/linux/linux_proto.h> #include <i386/linux/linux_util.h> -static sigset_t -linux_to_bsd_sigset(linux_sigset_t mask) { - int b, l; - sigset_t new = 0; - - for (l = 1; l < LINUX_NSIG; l++) { - if (mask & (1 << (l - 1))) { - if ((b = linux_to_bsd_signal[l])) - new |= (1 << (b - 1)); +static void +linux_to_bsd_sigset(linux_sigset_t *lss, sigset_t *bss) +{ + int b, l; + + SIGEMPTYSET(*bss); + bss->__bits[0] = lss->__bits[0] & ~((1U << LINUX_SIGTBLSZ) - 1); + bss->__bits[1] = lss->__bits[1]; + for (l = 1; l <= LINUX_SIGTBLSZ; l++) { + if (LINUX_SIGISMEMBER(*lss, l)) { + b = linux_to_bsd_signal[_SIG_IDX(l)]; + if (b) + SIGADDSET(*bss, b); + } } - } - return new; } -static linux_sigset_t -bsd_to_linux_sigset(sigset_t mask) { - int b, l; - sigset_t new = 0; - - for (b = 1; b < NSIG; b++) { - if (mask & (1 << (b - 1))) { - if ((l = bsd_to_linux_signal[b])) - new |= (1 << (l - 1)); +static void +bsd_to_linux_sigset(sigset_t *bss, linux_sigset_t *lss) +{ + int b, l; + + LINUX_SIGEMPTYSET(*lss); + lss->__bits[0] = bss->__bits[0] & ~((1U << LINUX_SIGTBLSZ) - 1); + lss->__bits[1] = bss->__bits[1]; + for (b = 1; b <= LINUX_SIGTBLSZ; b++) { + if (SIGISMEMBER(*bss, b)) { + l = bsd_to_linux_signal[_SIG_IDX(b)]; + if (l) + LINUX_SIGADDSET(*lss, l); + } } - } - return new; } static void linux_to_bsd_sigaction(linux_sigaction_t *lsa, struct sigaction *bsa) { - bsa->sa_mask = linux_to_bsd_sigset(lsa->lsa_mask); - bsa->sa_handler = lsa->lsa_handler; - bsa->sa_flags = 0; - if (lsa->lsa_flags & LINUX_SA_NOCLDSTOP) - bsa->sa_flags |= SA_NOCLDSTOP; - if (lsa->lsa_flags & LINUX_SA_NOCLDWAIT) - bsa->sa_flags |= SA_NOCLDWAIT; - if (lsa->lsa_flags & LINUX_SA_SIGINFO) - bsa->sa_flags |= SA_SIGINFO; - if (lsa->lsa_flags & LINUX_SA_ONSTACK) - bsa->sa_flags |= SA_ONSTACK; - if (lsa->lsa_flags & LINUX_SA_RESTART) - bsa->sa_flags |= SA_RESTART; - if (lsa->lsa_flags & LINUX_SA_ONESHOT) - bsa->sa_flags |= SA_RESETHAND; - if (lsa->lsa_flags & LINUX_SA_NOMASK) - bsa->sa_flags |= SA_NODEFER; + + linux_to_bsd_sigset(&lsa->lsa_mask, &bsa->sa_mask); + bsa->sa_handler = lsa->lsa_handler; + bsa->sa_flags = 0; + if (lsa->lsa_flags & LINUX_SA_NOCLDSTOP) + bsa->sa_flags |= SA_NOCLDSTOP; + if (lsa->lsa_flags & LINUX_SA_NOCLDWAIT) + bsa->sa_flags |= SA_NOCLDWAIT; + if (lsa->lsa_flags & LINUX_SA_SIGINFO) + bsa->sa_flags |= SA_SIGINFO; + if (lsa->lsa_flags & LINUX_SA_ONSTACK) + bsa->sa_flags |= SA_ONSTACK; + if (lsa->lsa_flags & LINUX_SA_RESTART) + bsa->sa_flags |= SA_RESTART; + if (lsa->lsa_flags & LINUX_SA_ONESHOT) + bsa->sa_flags |= SA_RESETHAND; + if (lsa->lsa_flags & LINUX_SA_NOMASK) + bsa->sa_flags |= SA_NODEFER; } static void bsd_to_linux_sigaction(struct sigaction *bsa, linux_sigaction_t *lsa) { - lsa->lsa_handler = bsa->sa_handler; - lsa->lsa_restorer = NULL; /* unsupported */ - lsa->lsa_mask = bsd_to_linux_sigset(bsa->sa_mask); - lsa->lsa_flags = 0; - if (bsa->sa_flags & SA_NOCLDSTOP) - lsa->lsa_flags |= LINUX_SA_NOCLDSTOP; - if (bsa->sa_flags & SA_NOCLDWAIT) - lsa->lsa_flags |= LINUX_SA_NOCLDWAIT; - if (bsa->sa_flags & SA_SIGINFO) - lsa->lsa_flags |= LINUX_SA_SIGINFO; - if (bsa->sa_flags & SA_ONSTACK) - lsa->lsa_flags |= LINUX_SA_ONSTACK; - if (bsa->sa_flags & SA_RESTART) - lsa->lsa_flags |= LINUX_SA_RESTART; - if (bsa->sa_flags & SA_RESETHAND) - lsa->lsa_flags |= LINUX_SA_ONESHOT; - if (bsa->sa_flags & SA_NODEFER) - lsa->lsa_flags |= LINUX_SA_NOMASK; + + bsd_to_linux_sigset(&bsa->sa_mask, &lsa->lsa_mask); + lsa->lsa_handler = bsa->sa_handler; + lsa->lsa_restorer = NULL; /* unsupported */ + lsa->lsa_flags = 0; + if (bsa->sa_flags & SA_NOCLDSTOP) + lsa->lsa_flags |= LINUX_SA_NOCLDSTOP; + if (bsa->sa_flags & SA_NOCLDWAIT) + lsa->lsa_flags |= LINUX_SA_NOCLDWAIT; + if (bsa->sa_flags & SA_SIGINFO) + lsa->lsa_flags |= LINUX_SA_SIGINFO; + if (bsa->sa_flags & SA_ONSTACK) + lsa->lsa_flags |= LINUX_SA_ONSTACK; + if (bsa->sa_flags & SA_RESTART) + lsa->lsa_flags |= LINUX_SA_RESTART; + if (bsa->sa_flags & SA_RESETHAND) + lsa->lsa_flags |= LINUX_SA_ONESHOT; + if (bsa->sa_flags & SA_NODEFER) + lsa->lsa_flags |= LINUX_SA_NOMASK; } static int linux_do_sigaction(struct proc *p, int linux_sig, linux_sigaction_t *linux_nsa, linux_sigaction_t *linux_osa) { - struct sigaction *nsa, *osa, sa; - struct sigaction_args sa_args; - int error; - caddr_t sg = stackgap_init(); - - if (linux_sig <= 0 || linux_sig >= LINUX_NSIG) - return EINVAL; - - if (linux_osa) - osa = stackgap_alloc(&sg, sizeof(struct sigaction)); - else - osa = NULL; - - if (linux_nsa) { - nsa = stackgap_alloc(&sg, sizeof(struct sigaction)); - linux_to_bsd_sigaction(linux_nsa, &sa); - error = copyout(&sa, nsa, sizeof(struct sigaction)); - if (error) - return error; - } - else - nsa = NULL; - - sa_args.signum = linux_to_bsd_signal[linux_sig]; - sa_args.nsa = nsa; - sa_args.osa = osa; - error = sigaction(p, &sa_args); - if (error) - return error; - - if (linux_osa) { - error = copyin(osa, &sa, sizeof(struct sigaction)); + struct sigaction *nsa, *osa, sa; + struct sigaction_args sa_args; + int error; + caddr_t sg = stackgap_init(); + + if (linux_sig <= 0 || linux_sig > LINUX_NSIG) + return (EINVAL); + + if (linux_osa != NULL) + osa = stackgap_alloc(&sg, sizeof(struct sigaction)); + else + osa = NULL; + + if (linux_nsa != NULL) { + nsa = stackgap_alloc(&sg, sizeof(struct sigaction)); + linux_to_bsd_sigaction(linux_nsa, &sa); + error = copyout(&sa, nsa, sizeof(struct sigaction)); + if (error) + return (error); + } + else + nsa = NULL; + + if (linux_sig <= LINUX_SIGTBLSZ) + sa_args.sig = linux_to_bsd_signal[_SIG_IDX(linux_sig)]; + else + sa_args.sig = linux_sig; + + sa_args.act = nsa; + sa_args.oact = osa; + error = sigaction(p, &sa_args); if (error) - return error; - bsd_to_linux_sigaction(&sa, linux_osa); - } + return (error); + + if (linux_osa != NULL) { + error = copyin(osa, &sa, sizeof(struct sigaction)); + if (error) + return (error); + bsd_to_linux_sigaction(&sa, linux_osa); + } - return 0; + return (0); } int linux_sigaction(struct proc *p, struct linux_sigaction_args *args) { - linux_sigaction_t nsa, osa; - int error; + linux_osigaction_t osa; + linux_sigaction_t act, oact; + int error; #ifdef DEBUG - printf("Linux-emul(%ld): sigaction(%d, %p, %p)\n", - (long)p->p_pid, args->sig, (void *)args->nsa, (void *)args->osa); + printf("Linux-emul(%ld): sigaction(%d, %p, %p)\n", (long)p->p_pid, + args->sig, (void *)args->nsa, (void *)args->osa); #endif - if (args->nsa) { - error = copyin(args->nsa, &nsa, sizeof(linux_sigaction_t)); - if (error) - return error; - } + if (args->nsa != NULL) { + error = copyin(args->nsa, &osa, sizeof(linux_osigaction_t)); + if (error) + return (error); + act.lsa_handler = osa.lsa_handler; + act.lsa_flags = osa.lsa_flags; + act.lsa_restorer = osa.lsa_restorer; + LINUX_SIGEMPTYSET(act.lsa_mask); + act.lsa_mask.__bits[0] = osa.lsa_mask; + } - error = linux_do_sigaction(p, args->sig, - args->nsa ? &nsa : NULL, - args->osa ? &osa : NULL); - if (error) - return error; + error = linux_do_sigaction(p, args->sig, + args->nsa ? &act : NULL, + args->osa ? &oact : NULL); - if (args->osa) { - error = copyout(&osa, args->osa, sizeof(linux_sigaction_t)); - if (error) - return error; - } + if (args->osa != NULL && !error) { + osa.lsa_handler = oact.lsa_handler; + osa.lsa_flags = oact.lsa_flags; + osa.lsa_restorer = oact.lsa_restorer; + osa.lsa_mask = oact.lsa_mask.__bits[0]; + error = copyout(&osa, args->osa, sizeof(linux_osigaction_t)); + } - return 0; + return (error); } int linux_signal(struct proc *p, struct linux_signal_args *args) { - linux_sigaction_t nsa, osa; - int error; + linux_sigaction_t nsa, osa; + int error; #ifdef DEBUG - printf("Linux-emul(%ld): signal(%d, %p)\n", - (long)p->p_pid, args->sig, (void *)args->handler); + printf("Linux-emul(%ld): signal(%d, %p)\n", + (long)p->p_pid, args->sig, (void *)args->handler); #endif - nsa.lsa_handler = args->handler; - nsa.lsa_flags = LINUX_SA_ONESHOT | LINUX_SA_NOMASK; - nsa.lsa_mask = NULL; + nsa.lsa_handler = args->handler; + nsa.lsa_flags = LINUX_SA_ONESHOT | LINUX_SA_NOMASK; + LINUX_SIGEMPTYSET(nsa.lsa_mask); - error = linux_do_sigaction(p, args->sig, &nsa, &osa); + error = linux_do_sigaction(p, args->sig, &nsa, &osa); + p->p_retval[0] = (int)osa.lsa_handler; - p->p_retval[0] = (int)osa.lsa_handler; - - return 0; + return (error); } int linux_rt_sigaction(struct proc *p, struct linux_rt_sigaction_args *args) { - linux_sigaction_t nsa, osa; - linux_new_sigaction_t new_sa; - int error; + linux_sigaction_t nsa, osa; + int error; #ifdef DEBUG - printf("Linux-emul(%ld): rt_sigaction(%d, %p, %p, %d)\n", - (long)p->p_pid, args->sig, (void *)args->act, - (void *)args->oact, args->sigsetsize); + printf("Linux-emul(%ld): rt_sigaction(%d, %p, %p, %d)\n", + (long)p->p_pid, args->sig, (void *)args->act, + (void *)args->oact, args->sigsetsize); #endif - if (args->sigsetsize != sizeof(linux_new_sigset_t)) - return EINVAL; - -#ifdef DEBUG - if (args->sig >= LINUX_NSIG) { - printf("LINUX(%ld): rt_sigaction: 64-bit signal (%d)\n", - (long)p->p_pid, args->sig); - } -#endif + if (args->sigsetsize != sizeof(linux_sigset_t)) + return (EINVAL); - if (args->act) { - error = copyin(args->act, &new_sa, sizeof(linux_new_sigaction_t)); - if (error) - return error; + if (args->act != NULL) { + error = copyin(args->act, &nsa, sizeof(linux_sigaction_t)); + if (error) + return (error); + } - nsa.lsa_handler = new_sa.lsa_handler; - nsa.lsa_mask = new_sa.lsa_mask.sig[0]; - nsa.lsa_flags = new_sa.lsa_flags; - nsa.lsa_restorer = new_sa.lsa_restorer; + error = linux_do_sigaction(p, args->sig, + args->act ? &nsa : NULL, + args->oact ? &osa : NULL); -#ifdef DEBUG - if (new_sa.lsa_mask.sig[1] != 0) - printf("LINUX(%ld): rt_sigaction: sig[1] = 0x%08lx\n", - (long)p->p_pid, new_sa.lsa_mask.sig[1]); -#endif - } - - error = linux_do_sigaction(p, args->sig, - args->act ? &nsa : NULL, - args->oact ? &osa : NULL); - if (error) - return error; - - if (args->oact) { - new_sa.lsa_handler = osa.lsa_handler; - new_sa.lsa_flags = osa.lsa_flags; - new_sa.lsa_restorer = osa.lsa_restorer; - new_sa.lsa_mask.sig[0] = osa.lsa_mask; - new_sa.lsa_mask.sig[1] = 0; - error = copyout(&osa, args->oact, sizeof(linux_new_sigaction_t)); - if (error) - return error; - } + if (args->oact != NULL && !error) { + error = copyout(&osa, args->oact, sizeof(linux_sigaction_t)); + } - return 0; + return (error); } static int linux_do_sigprocmask(struct proc *p, int how, linux_sigset_t *new, linux_sigset_t *old) { - int error = 0, s; - sigset_t mask; - - p->p_retval[0] = 0; - - if (old != NULL) - *old = bsd_to_linux_sigset(p->p_sigmask); - - if (new != NULL) { - mask = linux_to_bsd_sigset(*new); - - s = splhigh(); - - switch (how) { - case LINUX_SIG_BLOCK: - p->p_sigmask |= (mask & ~sigcantmask); - break; - case LINUX_SIG_UNBLOCK: - p->p_sigmask &= ~mask; - break; - case LINUX_SIG_SETMASK: - p->p_sigmask = (mask & ~sigcantmask); - break; - default: - error = EINVAL; - break; + int error, s; + sigset_t mask; + + error = 0; + p->p_retval[0] = 0; + + if (old != NULL) + bsd_to_linux_sigset(&p->p_sigmask, old); + + if (new != NULL) { + linux_to_bsd_sigset(new, &mask); + + s = splhigh(); + + switch (how) { + case LINUX_SIG_BLOCK: + SIGSETOR(p->p_sigmask, mask); + SIG_CANTMASK(p->p_sigmask); + break; + case LINUX_SIG_UNBLOCK: + SIGSETNAND(p->p_sigmask, mask); + break; + case LINUX_SIG_SETMASK: + p->p_sigmask = mask; + SIG_CANTMASK(p->p_sigmask); + break; + default: + error = EINVAL; + break; + } + + splx(s); } - splx(s); - } - - return error; + return (error); } int linux_sigprocmask(struct proc *p, struct linux_sigprocmask_args *args) { - linux_sigset_t mask; - linux_sigset_t omask; - int error; + linux_osigset_t mask; + linux_sigset_t set, oset; + int error; #ifdef DEBUG - printf("Linux-emul(%d): sigprocmask(%d, *, *)\n", p->p_pid, args->how); + printf("Linux-emul(%d): sigprocmask(%d, *, *)\n", p->p_pid, args->how); #endif - if (args->mask != NULL) { - error = copyin(args->mask, &mask, sizeof(linux_sigset_t)); - if (error) - return error; - } + if (args->mask != NULL) { + error = copyin(args->mask, &mask, sizeof(linux_osigset_t)); + if (error) + return (error); + LINUX_SIGEMPTYSET(set); + set.__bits[0] = mask; + } - error = linux_do_sigprocmask(p, args->how, - args->mask ? &mask : NULL, - args->omask ? &omask : NULL); + error = linux_do_sigprocmask(p, args->how, + args->mask ? &set : NULL, + args->omask ? &oset : NULL); - if (!error && args->omask != NULL) { - error = copyout(&omask, args->omask, sizeof(linux_sigset_t)); - } + if (args->omask != NULL && !error) { + mask = oset.__bits[0]; + error = copyout(&mask, args->omask, sizeof(linux_osigset_t)); + } - return error; + return (error); } int linux_rt_sigprocmask(struct proc *p, struct linux_rt_sigprocmask_args *args) { - linux_new_sigset_t new_mask; - linux_sigset_t old_mask; - int error; + linux_sigset_t set, oset; + int error; #ifdef DEBUG - printf("Linux-emul(%ld): rt_sigprocmask(%d, %p, %p, %d)\n", - (long)p->p_pid, args->how, (void *)args->mask, - (void *)args->omask, args->sigsetsize); + printf("Linux-emul(%ld): rt_sigprocmask(%d, %p, %p, %d)\n", + (long)p->p_pid, args->how, (void *)args->mask, + (void *)args->omask, args->sigsetsize); #endif - if (args->sigsetsize != sizeof(linux_new_sigset_t)) - return EINVAL; - - if (args->mask != NULL) { - error = copyin(args->mask, &new_mask, sizeof(linux_new_sigset_t)); - if (error) - return error; + if (args->sigsetsize != sizeof(linux_sigset_t)) + return EINVAL; -#ifdef DEBUG - if (new_mask.sig[1] != 0) - printf("LINUX(%ld): rt_sigprocmask: sig[1] = 0x%08lx\n", - (long)p->p_pid, new_mask.sig[1]); -#endif - } + if (args->mask != NULL) { + error = copyin(args->mask, &set, sizeof(linux_sigset_t)); + if (error) + return (error); + } - error = linux_do_sigprocmask(p, args->how, - args->mask ? new_mask.sig : NULL, - args->omask ? &old_mask : NULL); + error = linux_do_sigprocmask(p, args->how, + args->mask ? &set : NULL, + args->omask ? &oset : NULL); - if (!error && args->omask != NULL) { - new_mask.sig[0] = old_mask; - error = copyout(&new_mask, args->omask, sizeof(linux_new_sigset_t)); - } + if (args->omask != NULL && !error) { + error = copyout(&oset, args->omask, sizeof(linux_sigset_t)); + } - return error; + return (error); } int linux_siggetmask(struct proc *p, struct linux_siggetmask_args *args) { + linux_sigset_t mask; + #ifdef DEBUG - printf("Linux-emul(%d): siggetmask()\n", p->p_pid); + printf("Linux-emul(%d): siggetmask()\n", p->p_pid); #endif - p->p_retval[0] = bsd_to_linux_sigset(p->p_sigmask); - return 0; + + bsd_to_linux_sigset(&p->p_sigmask, &mask); + p->p_retval[0] = mask.__bits[0]; + return (0); } int linux_sigsetmask(struct proc *p, struct linux_sigsetmask_args *args) { - int s; - sigset_t mask; + linux_sigset_t lset; + sigset_t bset; + int s; #ifdef DEBUG - printf("Linux-emul(%ld): sigsetmask(%08lx)\n", - (long)p->p_pid, (unsigned long)args->mask); + printf("Linux-emul(%ld): sigsetmask(%08lx)\n", + (long)p->p_pid, (unsigned long)args->mask); #endif - p->p_retval[0] = bsd_to_linux_sigset(p->p_sigmask); - mask = linux_to_bsd_sigset(args->mask); - s = splhigh(); - p->p_sigmask = mask & ~sigcantmask; - splx(s); - return 0; + bsd_to_linux_sigset(&p->p_sigmask, &lset); + p->p_retval[0] = lset.__bits[0]; + LINUX_SIGEMPTYSET(lset); + lset.__bits[0] = args->mask; + linux_to_bsd_sigset(&lset, &bset); + s = splhigh(); + p->p_sigmask = bset; + SIG_CANTMASK(p->p_sigmask); + splx(s); + return (0); } int linux_sigpending(struct proc *p, struct linux_sigpending_args *args) { - linux_sigset_t linux_sig; + sigset_t bset; + linux_sigset_t lset; + linux_osigset_t mask; #ifdef DEBUG - printf("Linux-emul(%d): sigpending(*)\n", p->p_pid); + printf("Linux-emul(%d): sigpending(*)\n", p->p_pid); #endif - linux_sig = bsd_to_linux_sigset(p->p_siglist & p->p_sigmask); - return copyout(&linux_sig, args->mask, sizeof(linux_sig)); + + bset = p->p_siglist; + SIGSETAND(bset, p->p_sigmask); + bsd_to_linux_sigset(&bset, &lset); + mask = lset.__bits[0]; + return (copyout(&mask, args->mask, sizeof(mask))); } /* @@ -424,43 +426,94 @@ linux_sigpending(struct proc *p, struct linux_sigpending_args *args) int linux_sigsuspend(struct proc *p, struct linux_sigsuspend_args *args) { - struct sigsuspend_args tmp; + struct sigsuspend_args bsd; + sigset_t *sigmask; + linux_sigset_t mask; + caddr_t sg = stackgap_init(); #ifdef DEBUG - printf("Linux-emul(%ld): sigsuspend(%08lx)\n", - (long)p->p_pid, (unsigned long)args->mask); + printf("Linux-emul(%ld): sigsuspend(%08lx)\n", + (long)p->p_pid, (unsigned long)args->mask); #endif - tmp.mask = linux_to_bsd_sigset(args->mask); - return sigsuspend(p, &tmp); + + sigmask = stackgap_alloc(&sg, sizeof(sigset_t)); + LINUX_SIGEMPTYSET(mask); + mask.__bits[0] = args->mask; + linux_to_bsd_sigset(&mask, sigmask); + bsd.sigmask = sigmask; + return (sigsuspend(p, &bsd)); +} + +int +linux_rt_sigsuspend(p, uap) + struct proc *p; + struct linux_rt_sigsuspend_args *uap; +{ + linux_sigset_t lmask; + sigset_t *bmask; + struct sigsuspend_args bsd; + caddr_t sg = stackgap_init(); + int error; + +#ifdef DEBUG + printf("Linux-emul(%ld): rt_sigsuspend(%p, %d)\n", (long)p->p_pid, + (void *)uap->newset, uap->sigsetsize); +#endif + + if (uap->sigsetsize != sizeof(linux_sigset_t)) + return (EINVAL); + + error = copyin(uap->newset, &lmask, sizeof(linux_sigset_t)); + if (error) + return (error); + + bmask = stackgap_alloc(&sg, sizeof(sigset_t)); + linux_to_bsd_sigset(&lmask, bmask); + bsd.sigmask = bmask; + return (sigsuspend(p, &bsd)); } int linux_pause(struct proc *p, struct linux_pause_args *args) { - struct sigsuspend_args tmp; + struct sigsuspend_args bsd; + sigset_t *sigmask; + caddr_t sg = stackgap_init(); #ifdef DEBUG - printf("Linux-emul(%d): pause()\n", p->p_pid); + printf("Linux-emul(%d): pause()\n", p->p_pid); #endif - tmp.mask = p->p_sigmask; - return sigsuspend(p, &tmp); + + sigmask = stackgap_alloc(&sg, sizeof(sigset_t)); + *sigmask = p->p_sigmask; + bsd.sigmask = sigmask; + return sigsuspend(p, &bsd); } int linux_kill(struct proc *p, struct linux_kill_args *args) { - struct kill_args /* { - int pid; - int signum; - } */ tmp; + struct kill_args /* { + int pid; + int signum; + } */ tmp; #ifdef DEBUG - printf("Linux-emul(%d): kill(%d, %d)\n", - p->p_pid, args->pid, args->signum); + printf("Linux-emul(%d): kill(%d, %d)\n", + p->p_pid, args->pid, args->signum); #endif - if (args->signum < 0 || args->signum >= LINUX_NSIG) - return EINVAL; - tmp.pid = args->pid; - tmp.signum = linux_to_bsd_signal[args->signum]; - return kill(p, &tmp); + + /* + * Allow signal 0 as a means to check for privileges + */ + if (args->signum < 0 || args->signum > LINUX_NSIG) + return EINVAL; + + if (args->signum > 0 && args->signum <= LINUX_SIGTBLSZ) + tmp.signum = linux_to_bsd_signal[_SIG_IDX(args->signum)]; + else + tmp.signum = args->signum; + + tmp.pid = args->pid; + return (kill(p, &tmp)); } diff --git a/sys/i386/linux/linux_sysent.c b/sys/i386/linux/linux_sysent.c index 92b7d00..d62b616 100644 --- a/sys/i386/linux/linux_sysent.c +++ b/sys/i386/linux/linux_sysent.c @@ -194,7 +194,7 @@ struct sysent linux_sysent[] = { { 0, (sy_call_t *)linux_rt_sigpending }, /* 176 = linux_rt_sigpending */ { 0, (sy_call_t *)linux_rt_sigtimedwait }, /* 177 = linux_rt_sigtimedwait */ { 0, (sy_call_t *)linux_rt_sigqueueinfo }, /* 178 = linux_rt_sigqueueinfo */ - { 0, (sy_call_t *)linux_rt_sigsuspend }, /* 179 = linux_rt_sigsuspend */ + { 2, (sy_call_t *)linux_rt_sigsuspend }, /* 179 = linux_rt_sigsuspend */ { 0, (sy_call_t *)linux_pread }, /* 180 = linux_pread */ { 0, (sy_call_t *)linux_pwrite }, /* 181 = linux_pwrite */ { 3, (sy_call_t *)linux_chown }, /* 182 = linux_chown */ diff --git a/sys/i386/linux/linux_sysvec.c b/sys/i386/linux/linux_sysvec.c index 871ccfb..ecaa359 100644 --- a/sys/i386/linux/linux_sysvec.c +++ b/sys/i386/linux/linux_sysvec.c @@ -64,7 +64,7 @@ static int elf_linux_fixup __P((long **stack_base, struct image_params *iparams)); static void linux_prepsyscall __P((struct trapframe *tf, int *args, u_int *code, caddr_t *params)); -static void linux_sendsig __P((sig_t catcher, int sig, int mask, +static void linux_sendsig __P((sig_t catcher, int sig, sigset_t *mask, u_long code)); /* @@ -82,22 +82,26 @@ static int bsd_to_linux_errno[ELAST + 1] = { -6, -6, -43, -42, -75, -6, -84 }; -int bsd_to_linux_signal[NSIG] = { - 0, LINUX_SIGHUP, LINUX_SIGINT, LINUX_SIGQUIT, - LINUX_SIGILL, LINUX_SIGTRAP, LINUX_SIGABRT, 0, - LINUX_SIGFPE, LINUX_SIGKILL, LINUX_SIGBUS, LINUX_SIGSEGV, - 0, LINUX_SIGPIPE, LINUX_SIGALRM, LINUX_SIGTERM, - LINUX_SIGURG, LINUX_SIGSTOP, LINUX_SIGTSTP, LINUX_SIGCONT, - LINUX_SIGCHLD, LINUX_SIGTTIN, LINUX_SIGTTOU, LINUX_SIGIO, - LINUX_SIGXCPU, LINUX_SIGXFSZ, LINUX_SIGVTALRM, LINUX_SIGPROF, - LINUX_SIGWINCH, 0, LINUX_SIGUSR1, LINUX_SIGUSR2 +int bsd_to_linux_signal[LINUX_SIGTBLSZ] = { + LINUX_SIGHUP, LINUX_SIGINT, LINUX_SIGQUIT, LINUX_SIGILL, + LINUX_SIGTRAP, LINUX_SIGABRT, 0, LINUX_SIGFPE, + LINUX_SIGKILL, LINUX_SIGBUS, LINUX_SIGSEGV, 0, + LINUX_SIGPIPE, LINUX_SIGALRM, LINUX_SIGTERM, LINUX_SIGURG, + LINUX_SIGSTOP, LINUX_SIGTSTP, LINUX_SIGCONT, LINUX_SIGCHLD, + LINUX_SIGTTIN, LINUX_SIGTTOU, LINUX_SIGIO, LINUX_SIGXCPU, + LINUX_SIGXFSZ, LINUX_SIGVTALRM, LINUX_SIGPROF, LINUX_SIGWINCH, + 0, LINUX_SIGUSR1, LINUX_SIGUSR2 }; -int linux_to_bsd_signal[LINUX_NSIG] = { - 0, SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGTRAP, SIGABRT, SIGBUS, - SIGFPE, SIGKILL, SIGUSR1, SIGSEGV, SIGUSR2, SIGPIPE, SIGALRM, SIGTERM, - SIGBUS, SIGCHLD, SIGCONT, SIGSTOP, SIGTSTP, SIGTTIN, SIGTTOU, SIGURG, - SIGXCPU, SIGXFSZ, SIGVTALRM, SIGPROF, SIGWINCH, SIGIO, SIGURG, 0 +int linux_to_bsd_signal[LINUX_SIGTBLSZ] = { + SIGHUP, SIGINT, SIGQUIT, SIGILL, + SIGTRAP, SIGABRT, SIGBUS, SIGFPE, + SIGKILL, SIGUSR1, SIGSEGV, SIGUSR2, + SIGPIPE, SIGALRM, SIGTERM, SIGBUS, + SIGCHLD, SIGCONT, SIGSTOP, SIGTSTP, + SIGTTIN, SIGTTOU, SIGURG, SIGXCPU, + SIGXFSZ, SIGVTALRM, SIGPROF, SIGWINCH, + SIGIO, SIGURG, 0 }; /* @@ -185,7 +189,7 @@ extern int _ucodesel, _udatasel; */ static void -linux_sendsig(sig_t catcher, int sig, int mask, u_long code) +linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) { register struct proc *p = curproc; register struct trapframe *regs; @@ -197,14 +201,14 @@ linux_sendsig(sig_t catcher, int sig, int mask, u_long code) oonstack = psp->ps_sigstk.ss_flags & SS_ONSTACK; #ifdef DEBUG - printf("Linux-emul(%ld): linux_sendsig(%p, %d, %d, %lu)\n", - (long)p->p_pid, catcher, sig, mask, code); + printf("Linux-emul(%ld): linux_sendsig(%p, %d, %p, %lu)\n", + (long)p->p_pid, catcher, sig, (void*)mask, code); #endif /* * Allocate space for the signal handler context. */ if ((psp->ps_flags & SAS_ALTSTACK) && !oonstack && - (psp->ps_sigonstack & sigmask(sig))) { + SIGISMEMBER(psp->ps_sigonstack, sig)) { fp = (struct linux_sigframe *)(psp->ps_sigstk.ss_sp + psp->ps_sigstk.ss_size - sizeof(struct linux_sigframe)); psp->ps_sigstk.ss_flags |= SS_ONSTACK; @@ -224,10 +228,9 @@ linux_sendsig(sig_t catcher, int sig, int mask, u_long code) * instruction to halt it in its tracks. */ SIGACTION(p, SIGILL) = SIG_DFL; - sig = sigmask(SIGILL); - p->p_sigignore &= ~sig; - p->p_sigcatch &= ~sig; - p->p_sigmask &= ~sig; + SIGDELSET(p->p_sigignore, SIGILL); + SIGDELSET(p->p_sigcatch, SIGILL); + SIGDELSET(p->p_sigmask, SIGILL); psignal(p, SIGILL); return; } @@ -235,12 +238,9 @@ linux_sendsig(sig_t catcher, int sig, int mask, u_long code) /* * Build the argument list for the signal handler. */ - if (p->p_sysent->sv_sigtbl) { - if (sig < p->p_sysent->sv_sigsize) - sig = p->p_sysent->sv_sigtbl[sig]; - else - sig = p->p_sysent->sv_sigsize + 1; - } + if (p->p_sysent->sv_sigtbl) + if (sig <= p->p_sysent->sv_sigsize) + sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)]; frame.sf_handler = catcher; frame.sf_sig = sig; @@ -248,7 +248,7 @@ linux_sendsig(sig_t catcher, int sig, int mask, u_long code) /* * Build the signal context to be used by sigreturn. */ - frame.sf_sc.sc_mask = mask; + frame.sf_sc.sc_mask = mask->__bits[0]; frame.sf_sc.sc_gs = rgs(); frame.sf_sc.sc_fs = regs->tf_fs; frame.sf_sc.sc_es = regs->tf_es; @@ -355,8 +355,12 @@ linux_sigreturn(p, args) } p->p_sigacts->ps_sigstk.ss_flags &= ~SS_ONSTACK; - p->p_sigmask = context.sc_mask &~ - (sigmask(SIGKILL)|sigmask(SIGCONT)|sigmask(SIGSTOP)); + SIGEMPTYSET(p->p_sigmask); + p->p_sigmask.__bits[0] = context.sc_mask; + SIGDELSET(p->p_sigmask, SIGKILL); + SIGDELSET(p->p_sigmask, SIGCONT); + SIGDELSET(p->p_sigmask, SIGSTOP); + /* * Restore signal context. */ @@ -395,7 +399,7 @@ struct sysentvec linux_sysvec = { LINUX_SYS_MAXSYSCALL, linux_sysent, 0xff, - NSIG, + LINUX_SIGTBLSZ, bsd_to_linux_signal, ELAST + 1, bsd_to_linux_errno, @@ -410,19 +414,19 @@ struct sysentvec linux_sysvec = { }; struct sysentvec elf_linux_sysvec = { - LINUX_SYS_MAXSYSCALL, - linux_sysent, - 0xff, - NSIG, - bsd_to_linux_signal, - ELAST + 1, - bsd_to_linux_errno, - translate_traps, - elf_linux_fixup, - linux_sendsig, - linux_sigcode, - &linux_szsigcode, - linux_prepsyscall, + LINUX_SYS_MAXSYSCALL, + linux_sysent, + 0xff, + LINUX_SIGTBLSZ, + bsd_to_linux_signal, + ELAST + 1, + bsd_to_linux_errno, + translate_traps, + elf_linux_fixup, + linux_sendsig, + linux_sigcode, + &linux_szsigcode, + linux_prepsyscall, "Linux ELF", elf_coredump }; diff --git a/sys/i386/linux/syscalls.master b/sys/i386/linux/syscalls.master index ab7c209..e8766a9 100644 --- a/sys/i386/linux/syscalls.master +++ b/sys/i386/linux/syscalls.master @@ -102,15 +102,16 @@ 65 NOPROTO LINUX { int getpgrp(void); } 66 NOPROTO LINUX { int setsid(void); } 67 STD LINUX { int linux_sigaction(int sig, \ - struct linux_sigaction *nsa, \ - struct linux_sigaction *osa); } + linux_osigaction_t *nsa, \ + linux_osigaction_t *osa); } 68 STD LINUX { int linux_siggetmask(void); } -69 STD LINUX { int linux_sigsetmask(linux_sigset_t mask); } +69 STD LINUX { int linux_sigsetmask(linux_osigset_t mask); } 70 NOPROTO LINUX { int setreuid(int ruid, int euid); } 71 NOPROTO LINUX { int setregid(int rgid, int egid); } 72 STD LINUX { int linux_sigsuspend(int restart, \ - linux_sigset_t oldmask, linux_sigset_t mask); } -73 STD LINUX { int linux_sigpending(linux_sigset_t *mask); } + linux_osigset_t oldmask, \ + linux_osigset_t mask); } +73 STD LINUX { int linux_sigpending(linux_osigset_t *mask); } 74 NOPROTO LINUX { int osethostname(char *hostname, u_int len); } 75 STD LINUX { int linux_setrlimit(u_int resource, \ struct ogetrlimit *rlim); } @@ -186,7 +187,8 @@ 124 STD LINUX { int linux_adjtimex(void); } 125 NOPROTO LINUX { int mprotect(caddr_t addr, int len, int prot); } 126 STD LINUX { int linux_sigprocmask(int how, \ - linux_sigset_t *mask, linux_sigset_t *omask); } + linux_osigset_t *mask, \ + linux_osigset_t *omask); } 127 STD LINUX { int linux_create_module(void); } 128 STD LINUX { int linux_init_module(void); } 129 STD LINUX { int linux_delete_module(void); } @@ -251,17 +253,17 @@ 172 STD LINUX { int linux_prctl(void); } 173 STD LINUX { int linux_rt_sigreturn(void); } 174 STD LINUX { int linux_rt_sigaction(int sig, \ - struct linux_new_sigaction *act, \ - struct linux_new_sigaction *oact, \ + linux_sigaction_t *act, \ + linux_sigaction_t *oact, \ size_t sigsetsize); } 175 STD LINUX { int linux_rt_sigprocmask(int how, \ - struct linux_new_sigset *mask, \ - struct linux_new_sigset *omask, \ + linux_sigset_t *mask, linux_sigset_t *omask, \ size_t sigsetsize); } 176 STD LINUX { int linux_rt_sigpending(void); } 177 STD LINUX { int linux_rt_sigtimedwait(void); } 178 STD LINUX { int linux_rt_sigqueueinfo(void); } -179 STD LINUX { int linux_rt_sigsuspend(void); } +179 STD LINUX { int linux_rt_sigsuspend(linux_sigset_t *newset, \ + size_t sigsetsize); } 180 STD LINUX { int linux_pread(void); } 181 STD LINUX { int linux_pwrite(void); } 182 STD LINUX { int linux_chown(char *path, int uid, int gid); } |
