Back our kernel support for reliable signal queues.
Requested by: rwatson, phk, and many others
This commit is contained in:
parent
689cd8eeb8
commit
1d9c56964d
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=104306
@ -46,7 +46,6 @@
|
||||
#include <sys/buf.h>
|
||||
#include <sys/bus.h>
|
||||
#include <sys/mbuf.h>
|
||||
#include <sys/ksiginfo.h>
|
||||
#include <sys/vmmeter.h>
|
||||
#include <sys/msgbuf.h>
|
||||
#include <sys/exec.h>
|
||||
@ -524,7 +523,7 @@ osf1_sigpending(td, uap)
|
||||
|
||||
p = td->td_proc;
|
||||
PROC_LOCK(p);
|
||||
ksiginfo_to_sigset_t(p, &bss);
|
||||
bss = p->p_siglist;
|
||||
SIGSETAND(bss, p->p_sigmask);
|
||||
PROC_UNLOCK(p);
|
||||
bsd_to_osf1_sigset(&bss, &oss);
|
||||
|
@ -63,7 +63,6 @@ extern int coda_nc_initialized; /* Set if cache has been initialized */
|
||||
#include <sys/lock.h>
|
||||
#include <sys/malloc.h>
|
||||
#include <sys/file.h> /* must come after sys/malloc.h */
|
||||
#include <sys/ksiginfo.h>
|
||||
#include <sys/mount.h>
|
||||
#include <sys/mutex.h>
|
||||
#include <sys/poll.h>
|
||||
@ -492,7 +491,6 @@ coda_call(mntinfo, inSize, outSize, buffer)
|
||||
#ifdef CTL_C
|
||||
struct thread *td = curthread;
|
||||
struct proc *p = td->td_proc;
|
||||
sigset_t pending_set;
|
||||
sigset_t psig_omask;
|
||||
sigset_t tempset;
|
||||
int i;
|
||||
@ -563,20 +561,18 @@ coda_call(mntinfo, inSize, outSize, buffer)
|
||||
#endif
|
||||
}
|
||||
else {
|
||||
ksiginfo_to_sigset_t(p, &pending_set);
|
||||
SIGEMPTYSET(tempset);
|
||||
SIGADDSET(tempset, SIGIO);
|
||||
if (SIGSETEQ(pending_set, tempset)) {
|
||||
if (SIGSETEQ(p->p_siglist, tempset)) {
|
||||
SIGADDSET(p->p_sigmask, SIGIO);
|
||||
#ifdef CODA_VERBOSE
|
||||
printf("coda_call: tsleep returns %d SIGIO, cnt %d\n",
|
||||
error, i);
|
||||
#endif
|
||||
} else {
|
||||
ksiginfo_to_sigset_t(p, &pending_set);
|
||||
SIGDELSET(tempset, SIGIO);
|
||||
SIGADDSET(tempset, SIGALRM);
|
||||
if (SIGSETEQ(pending_set, tempset)) {
|
||||
if (SIGSETEQ(p->p_siglist, tempset)) {
|
||||
SIGADDSET(p->p_sigmask, SIGALRM);
|
||||
#ifdef CODA_VERBOSE
|
||||
printf("coda_call: tsleep returns %d SIGALRM, cnt %d\n",
|
||||
@ -588,17 +584,17 @@ coda_call(mntinfo, inSize, outSize, buffer)
|
||||
error, i);
|
||||
|
||||
#if notyet
|
||||
tempset = pending_set;
|
||||
tempset = p->p_siglist;
|
||||
SIGSETNAND(tempset, p->p_sigmask);
|
||||
printf("coda_call: siglist = %p, sigmask = %p, mask %p\n",
|
||||
pending_set, p->p_sigmask,
|
||||
p->p_siglist, p->p_sigmask,
|
||||
tempset);
|
||||
break;
|
||||
SIGSETOR(p->p_sigmask, pending_set);
|
||||
tempset = pending_set;
|
||||
SIGSETOR(p->p_sigmask, p->p_siglist);
|
||||
tempset = p->p_siglist;
|
||||
SIGSETNAND(tempset, p->p_sigmask);
|
||||
printf("coda_call: new mask, siglist = %p, sigmask = %p, mask %p\n",
|
||||
pending_set, p->p_sigmask,
|
||||
p->p_siglist, p->p_sigmask,
|
||||
tempset);
|
||||
#endif
|
||||
}
|
||||
|
@ -651,7 +651,7 @@ linprocfs_doprocstatus(PFS_FILL_ARGS)
|
||||
* running on anything but i386, so ignore that for now.
|
||||
*/
|
||||
PROC_LOCK(p);
|
||||
sbuf_printf(sb, "SigPnd:\t%08x\n", 0); /* XXX */
|
||||
sbuf_printf(sb, "SigPnd:\t%08x\n", p->p_siglist.__bits[0]);
|
||||
/*
|
||||
* I can't seem to find out where the signal mask is in
|
||||
* relation to struct proc, so SigBlk is left unimplemented.
|
||||
|
@ -36,7 +36,6 @@
|
||||
#include <sys/imgact_aout.h>
|
||||
#include <sys/jail.h>
|
||||
#include <sys/kernel.h>
|
||||
#include <sys/ksiginfo.h>
|
||||
#include <sys/lock.h>
|
||||
#include <sys/mac.h>
|
||||
#include <sys/malloc.h>
|
||||
@ -833,7 +832,7 @@ linux_wait4(struct thread *td, struct linux_wait4_args *args)
|
||||
if ((error = wait4(td, &tmp)) != 0)
|
||||
return error;
|
||||
|
||||
signal_delete(td->td_proc, NULL, SIGCHLD);
|
||||
SIGDELSET(td->td_proc->p_siglist, SIGCHLD);
|
||||
|
||||
if (args->status) {
|
||||
if ((error = copyin((caddr_t)args->status, &tmpstat,
|
||||
|
@ -34,7 +34,6 @@
|
||||
#include <sys/mutex.h>
|
||||
#include <sys/proc.h>
|
||||
#include <sys/signalvar.h>
|
||||
#include <sys/ksiginfo.h>
|
||||
#include <sys/syscallsubr.h>
|
||||
#include <sys/sysproto.h>
|
||||
|
||||
@ -391,7 +390,7 @@ linux_sigpending(struct thread *td, struct linux_sigpending_args *args)
|
||||
#endif
|
||||
|
||||
PROC_LOCK(p);
|
||||
ksiginfo_to_sigset_t(p, &bset);
|
||||
bset = p->p_siglist;
|
||||
SIGSETAND(bset, p->p_sigmask);
|
||||
bsd_to_linux_sigset(&bset, &lset);
|
||||
PROC_UNLOCK(p);
|
||||
|
@ -39,7 +39,6 @@
|
||||
#include <sys/poll.h>
|
||||
#include <sys/malloc.h>
|
||||
#include <sys/mutex.h>
|
||||
#include <sys/ksiginfo.h>
|
||||
|
||||
#include <sys/sysproto.h>
|
||||
|
||||
@ -136,9 +135,7 @@ svr4_sys_read(td, uap)
|
||||
DPRINTF(("sigmask = 0x%x\n", td->td_proc->p_sigmask));
|
||||
DPRINTF(("sigignore = 0x%x\n", td->td_proc->p_sigignore));
|
||||
DPRINTF(("sigcaught = 0x%x\n", td->td_proc->p_sigcatch));
|
||||
#if 0 /* XXX - use ksiginfo_to_sigset_t ? */
|
||||
DPRINTF(("siglist = 0x%x\n", td->td_proc->p_siglist));
|
||||
#endif
|
||||
}
|
||||
|
||||
#if defined(GROTTY_READ_HACK)
|
||||
|
@ -565,7 +565,7 @@ svr4_sys_sigpending(td, uap)
|
||||
if (SCARG(uap, mask) == NULL)
|
||||
return 0;
|
||||
PROC_LOCK(td->td_proc);
|
||||
ksiginfo_to_sigset_t(td->td_proc, &bss);
|
||||
bss = td->td_proc->p_siglist;
|
||||
SIGSETAND(bss, td->td_proc->p_sigmask);
|
||||
PROC_UNLOCK(td->td_proc);
|
||||
bsd_to_svr4_sigset(&bss, &sss);
|
||||
|
@ -963,7 +963,6 @@ kern/subr_prof.c standard
|
||||
kern/subr_rman.c standard
|
||||
kern/subr_sbuf.c standard
|
||||
kern/subr_scanf.c standard
|
||||
kern/subr_sigq.c standard
|
||||
kern/subr_smp.c optional smp
|
||||
kern/subr_taskqueue.c standard
|
||||
kern/subr_trap.c standard
|
||||
|
@ -63,7 +63,6 @@ extern int coda_nc_initialized; /* Set if cache has been initialized */
|
||||
#include <sys/lock.h>
|
||||
#include <sys/malloc.h>
|
||||
#include <sys/file.h> /* must come after sys/malloc.h */
|
||||
#include <sys/ksiginfo.h>
|
||||
#include <sys/mount.h>
|
||||
#include <sys/mutex.h>
|
||||
#include <sys/poll.h>
|
||||
@ -492,7 +491,6 @@ coda_call(mntinfo, inSize, outSize, buffer)
|
||||
#ifdef CTL_C
|
||||
struct thread *td = curthread;
|
||||
struct proc *p = td->td_proc;
|
||||
sigset_t pending_set;
|
||||
sigset_t psig_omask;
|
||||
sigset_t tempset;
|
||||
int i;
|
||||
@ -563,20 +561,18 @@ coda_call(mntinfo, inSize, outSize, buffer)
|
||||
#endif
|
||||
}
|
||||
else {
|
||||
ksiginfo_to_sigset_t(p, &pending_set);
|
||||
SIGEMPTYSET(tempset);
|
||||
SIGADDSET(tempset, SIGIO);
|
||||
if (SIGSETEQ(pending_set, tempset)) {
|
||||
if (SIGSETEQ(p->p_siglist, tempset)) {
|
||||
SIGADDSET(p->p_sigmask, SIGIO);
|
||||
#ifdef CODA_VERBOSE
|
||||
printf("coda_call: tsleep returns %d SIGIO, cnt %d\n",
|
||||
error, i);
|
||||
#endif
|
||||
} else {
|
||||
ksiginfo_to_sigset_t(p, &pending_set);
|
||||
SIGDELSET(tempset, SIGIO);
|
||||
SIGADDSET(tempset, SIGALRM);
|
||||
if (SIGSETEQ(pending_set, tempset)) {
|
||||
if (SIGSETEQ(p->p_siglist, tempset)) {
|
||||
SIGADDSET(p->p_sigmask, SIGALRM);
|
||||
#ifdef CODA_VERBOSE
|
||||
printf("coda_call: tsleep returns %d SIGALRM, cnt %d\n",
|
||||
@ -588,17 +584,17 @@ coda_call(mntinfo, inSize, outSize, buffer)
|
||||
error, i);
|
||||
|
||||
#if notyet
|
||||
tempset = pending_set;
|
||||
tempset = p->p_siglist;
|
||||
SIGSETNAND(tempset, p->p_sigmask);
|
||||
printf("coda_call: siglist = %p, sigmask = %p, mask %p\n",
|
||||
pending_set, p->p_sigmask,
|
||||
p->p_siglist, p->p_sigmask,
|
||||
tempset);
|
||||
break;
|
||||
SIGSETOR(p->p_sigmask, pending_set);
|
||||
tempset = pending_set;
|
||||
SIGSETOR(p->p_sigmask, p->p_siglist);
|
||||
tempset = p->p_siglist;
|
||||
SIGSETNAND(tempset, p->p_sigmask);
|
||||
printf("coda_call: new mask, siglist = %p, sigmask = %p, mask %p\n",
|
||||
pending_set, p->p_sigmask,
|
||||
p->p_siglist, p->p_sigmask,
|
||||
tempset);
|
||||
#endif
|
||||
}
|
||||
|
@ -51,7 +51,6 @@
|
||||
#include <sys/signalvar.h>
|
||||
#include <sys/sx.h>
|
||||
#include <sys/uio.h>
|
||||
#include <sys/ksiginfo.h>
|
||||
|
||||
#include <fs/pseudofs/pseudofs.h>
|
||||
#include <fs/procfs/procfs.h>
|
||||
@ -222,7 +221,7 @@ procfs_control(struct thread *td, struct proc *p, int op)
|
||||
p->p_flag &= ~P_TRACED;
|
||||
|
||||
/* remove pending SIGTRAP, else the process will die */
|
||||
signal_delete(p, NULL, SIGTRAP);
|
||||
SIGDELSET(p->p_siglist, SIGTRAP);
|
||||
PROC_UNLOCK(p);
|
||||
|
||||
/* give process back to original parent */
|
||||
|
@ -30,7 +30,6 @@
|
||||
|
||||
#include <sys/param.h>
|
||||
#include <sys/systm.h>
|
||||
#include <sys/ksiginfo.h>
|
||||
#include <sys/lock.h>
|
||||
#include <sys/mutex.h>
|
||||
#include <sys/signalvar.h>
|
||||
@ -457,7 +456,7 @@ ibcs2_sigpending(td, uap)
|
||||
ibcs2_sigset_t iss;
|
||||
|
||||
PROC_LOCK(p);
|
||||
ksiginfo_to_sigset_t(p, &bss);
|
||||
bss = p->p_siglist;
|
||||
SIGSETAND(bss, p->p_sigmask);
|
||||
PROC_UNLOCK(p);
|
||||
bsd_to_ibcs2_sigset(&bss, &iss);
|
||||
|
@ -348,8 +348,6 @@ proc0_init(void *dummy __unused)
|
||||
LIST_INIT(&pgrp0.pg_members);
|
||||
LIST_INSERT_HEAD(&pgrp0.pg_members, p, p_pglist);
|
||||
|
||||
TAILQ_INIT(&p->p_sigq);
|
||||
|
||||
pgrp0.pg_session = &session0;
|
||||
mtx_init(&session0.s_mtx, "session", NULL, MTX_DEF);
|
||||
session0.s_count = 1;
|
||||
|
@ -67,7 +67,6 @@
|
||||
#ifdef KTRACE
|
||||
#include <sys/ktrace.h>
|
||||
#endif
|
||||
#include <sys/ksiginfo.h>
|
||||
|
||||
#include <vm/vm.h>
|
||||
#include <vm/vm_extern.h>
|
||||
@ -245,7 +244,7 @@ exit1(td, rv)
|
||||
*/
|
||||
PROC_LOCK(p);
|
||||
p->p_flag &= ~(P_TRACED | P_PPWAIT);
|
||||
signal_delete(p, NULL, 0);
|
||||
SIGEMPTYSET(p->p_siglist);
|
||||
PROC_UNLOCK(p);
|
||||
if (timevalisset(&p->p_realtimer.it_value))
|
||||
callout_stop(&p->p_itcallout);
|
||||
@ -474,12 +473,6 @@ exit1(td, rv)
|
||||
*/
|
||||
if (p->p_flag & P_KTHREAD)
|
||||
wakeup(p);
|
||||
|
||||
/*
|
||||
* And now, kill off its signals...
|
||||
*/
|
||||
signal_delete(p, NULL, 0);
|
||||
|
||||
PROC_UNLOCK(p);
|
||||
|
||||
/*
|
||||
|
@ -605,7 +605,6 @@ fork1(td, flags, procp)
|
||||
LIST_INSERT_AFTER(p1, p2, p_pglist);
|
||||
PGRP_UNLOCK(p1->p_pgrp);
|
||||
LIST_INIT(&p2->p_children);
|
||||
TAILQ_INIT(&p2->p_sigq);
|
||||
|
||||
callout_init(&p2->p_itcallout, 0);
|
||||
|
||||
|
@ -37,7 +37,6 @@
|
||||
#include <sys/sx.h>
|
||||
#include <sys/unistd.h>
|
||||
#include <sys/wait.h>
|
||||
#include <sys/ksiginfo.h>
|
||||
|
||||
#include <machine/stdarg.h>
|
||||
|
||||
@ -145,16 +144,16 @@ kthread_suspend(struct proc *p, int timo)
|
||||
{
|
||||
/*
|
||||
* Make sure this is indeed a system process and we can safely
|
||||
* use the signal queue.
|
||||
* use the p_siglist field.
|
||||
*/
|
||||
PROC_LOCK(p);
|
||||
if ((p->p_flag & P_KTHREAD) == 0) {
|
||||
PROC_UNLOCK(p);
|
||||
return (EINVAL);
|
||||
}
|
||||
signal_add(p, NULL, SIGSTOP);
|
||||
SIGADDSET(p->p_siglist, SIGSTOP);
|
||||
wakeup(p);
|
||||
return msleep(&p->p_sigq, &p->p_mtx, PPAUSE | PDROP, "suspkt", timo);
|
||||
return msleep(&p->p_siglist, &p->p_mtx, PPAUSE | PDROP, "suspkt", timo);
|
||||
}
|
||||
|
||||
int
|
||||
@ -169,9 +168,9 @@ kthread_resume(struct proc *p)
|
||||
PROC_UNLOCK(p);
|
||||
return (EINVAL);
|
||||
}
|
||||
signal_delete(p, NULL, SIGSTOP);
|
||||
SIGDELSET(p->p_siglist, SIGSTOP);
|
||||
PROC_UNLOCK(p);
|
||||
wakeup(&p->p_sigq);
|
||||
wakeup(&p->p_siglist);
|
||||
return (0);
|
||||
}
|
||||
|
||||
@ -179,9 +178,9 @@ void
|
||||
kthread_suspend_check(struct proc *p)
|
||||
{
|
||||
PROC_LOCK(p);
|
||||
while (signal_queued(p, SIGSTOP)) {
|
||||
wakeup(&p->p_sigq);
|
||||
msleep(&p->p_sigq, &p->p_mtx, PPAUSE, "ktsusp", 0);
|
||||
while (SIGISMEMBER(p->p_siglist, SIGSTOP)) {
|
||||
wakeup(&p->p_siglist);
|
||||
msleep(&p->p_siglist, &p->p_mtx, PPAUSE, "ktsusp", 0);
|
||||
}
|
||||
PROC_UNLOCK(p);
|
||||
}
|
||||
|
@ -58,7 +58,6 @@
|
||||
#include <sys/uio.h>
|
||||
#include <sys/ktrace.h>
|
||||
#endif
|
||||
#include <sys/ksiginfo.h>
|
||||
|
||||
#include <vm/vm.h>
|
||||
#include <vm/vm_extern.h>
|
||||
@ -409,7 +408,7 @@ kse_create(struct thread *td, struct kse_create_args *uap)
|
||||
RANGEOF(struct kse, ke_startcopy, ke_endcopy));
|
||||
#endif
|
||||
PROC_LOCK(p);
|
||||
if (signal_pending(p))
|
||||
if (SIGPENDING(p))
|
||||
newke->ke_flags |= KEF_ASTPENDING;
|
||||
PROC_UNLOCK(p);
|
||||
mtx_lock_spin(&sched_lock);
|
||||
@ -1015,7 +1014,7 @@ fill_kinfo_proc(p, kp)
|
||||
strncpy(kp->ki_comm, p->p_comm, sizeof(kp->ki_comm) - 1);
|
||||
strncpy(kp->ki_ocomm, p->p_comm, sizeof(kp->ki_ocomm) - 1);
|
||||
}
|
||||
ksiginfo_to_sigset_t(p, &kp->ki_siglist);
|
||||
kp->ki_siglist = p->p_siglist;
|
||||
kp->ki_sigmask = p->p_sigmask;
|
||||
kp->ki_xstat = p->p_xstat;
|
||||
kp->ki_acflag = p->p_acflag;
|
||||
|
@ -1,6 +1,4 @@
|
||||
/*
|
||||
* Copyright (c) 2002 New Gold Technoloy. All rights reserved.
|
||||
* Copyright (c) 2002 Juli Mallett. All rights reserved.
|
||||
* Copyright (c) 1982, 1986, 1989, 1991, 1993
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
* (c) UNIX System Laboratories, Inc.
|
||||
@ -72,7 +70,6 @@
|
||||
#include <sys/sysctl.h>
|
||||
#include <sys/malloc.h>
|
||||
#include <sys/unistd.h>
|
||||
#include <sys/ksiginfo.h>
|
||||
|
||||
#include <machine/cpu.h>
|
||||
|
||||
@ -119,9 +116,6 @@ static int do_coredump = 1;
|
||||
SYSCTL_INT(_kern, OID_AUTO, coredump, CTLFLAG_RW,
|
||||
&do_coredump, 0, "Enable/Disable coredumps");
|
||||
|
||||
static int stopmask =
|
||||
sigmask(SIGSTOP) | sigmask(SIGTSTP) | sigmask(SIGTTIN) | sigmask(SIGTTOU);
|
||||
|
||||
/*
|
||||
* Signal properties and actions.
|
||||
* The array below categorizes the signals and their default actions
|
||||
@ -184,12 +178,12 @@ cursig(struct thread *td)
|
||||
|
||||
PROC_LOCK_ASSERT(p, MA_OWNED);
|
||||
mtx_assert(&sched_lock, MA_NOTOWNED);
|
||||
return (signal_pending(p) ? issignal(td) : 0);
|
||||
return (SIGPENDING(p) ? issignal(td) : 0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Arrange for ast() to handle unmasked pending signals on return to user
|
||||
* mode. This must be called whenever a signal is added to p_sigq or
|
||||
* mode. This must be called whenever a signal is added to p_siglist or
|
||||
* unmasked in p_sigmask.
|
||||
*/
|
||||
void
|
||||
@ -200,7 +194,7 @@ signotify(struct proc *p)
|
||||
|
||||
PROC_LOCK_ASSERT(p, MA_OWNED);
|
||||
mtx_lock_spin(&sched_lock);
|
||||
if (signal_pending(p)) {
|
||||
if (SIGPENDING(p)) {
|
||||
p->p_sflag |= PS_NEEDSIGCHK;
|
||||
/* XXXKSE for now punish all KSEs */
|
||||
FOREACH_KSEGRP_IN_PROC(p, kg) {
|
||||
@ -347,7 +341,7 @@ kern_sigaction(td, sig, act, oact, old)
|
||||
(sigprop(sig) & SA_IGNORE &&
|
||||
ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL)) {
|
||||
/* never to be seen again */
|
||||
signal_delete(p, NULL, sig);
|
||||
SIGDELSET(p->p_siglist, sig);
|
||||
if (sig != SIGCONT)
|
||||
/* easier in psignal */
|
||||
SIGADDSET(p->p_sigignore, sig);
|
||||
@ -500,7 +494,7 @@ execsigs(p)
|
||||
if (sigprop(sig) & SA_IGNORE) {
|
||||
if (sig != SIGCONT)
|
||||
SIGADDSET(p->p_sigignore, sig);
|
||||
signal_delete(p, NULL, sig);
|
||||
SIGDELSET(p->p_siglist, sig);
|
||||
}
|
||||
ps->ps_sigact[_SIG_IDX(sig)] = SIG_DFL;
|
||||
}
|
||||
@ -647,7 +641,7 @@ sigpending(td, uap)
|
||||
|
||||
mtx_lock(&Giant);
|
||||
PROC_LOCK(p);
|
||||
ksiginfo_to_sigset_t(p, &siglist);
|
||||
siglist = p->p_siglist;
|
||||
PROC_UNLOCK(p);
|
||||
mtx_unlock(&Giant);
|
||||
error = copyout(&siglist, uap->set, sizeof(sigset_t));
|
||||
@ -670,12 +664,10 @@ osigpending(td, uap)
|
||||
struct osigpending_args *uap;
|
||||
{
|
||||
struct proc *p = td->td_proc;
|
||||
sigset_t siglist;
|
||||
|
||||
mtx_lock(&Giant);
|
||||
PROC_LOCK(p);
|
||||
ksiginfo_to_sigset_t(p, &siglist);
|
||||
SIG2OSIG(siglist, td->td_retval[0]);
|
||||
SIG2OSIG(p->p_siglist, td->td_retval[0]);
|
||||
PROC_UNLOCK(p);
|
||||
mtx_unlock(&Giant);
|
||||
return (0);
|
||||
@ -1316,7 +1308,7 @@ psignal(p, sig)
|
||||
}
|
||||
|
||||
if (prop & SA_CONT)
|
||||
signal_delete_mask(p, stopmask);
|
||||
SIG_STOPSIGMASK(p->p_siglist);
|
||||
|
||||
if (prop & SA_STOP) {
|
||||
/*
|
||||
@ -1329,10 +1321,10 @@ psignal(p, sig)
|
||||
(p->p_pgrp->pg_jobc == 0) &&
|
||||
(action == SIG_DFL))
|
||||
return;
|
||||
signal_delete_mask(p, sigmask(SIGCONT));
|
||||
SIG_CONTSIGMASK(p->p_siglist);
|
||||
p->p_flag &= ~P_CONTINUED;
|
||||
}
|
||||
signal_add(p, NULL, sig);
|
||||
SIGADDSET(p->p_siglist, sig);
|
||||
signotify(p); /* uses schedlock */
|
||||
|
||||
/*
|
||||
@ -1370,10 +1362,10 @@ psignal(p, sig)
|
||||
if (prop & SA_CONT) {
|
||||
/*
|
||||
* If SIGCONT is default (or ignored), we continue the
|
||||
* process but don't leave the signal in p_sigq as it
|
||||
* has no further action. If SIGCONT is held, we
|
||||
* process but don't leave the signal in p_siglist as
|
||||
* it has no further action. If SIGCONT is held, we
|
||||
* continue the process and leave the signal in
|
||||
* p_sigq. If the process catches SIGCONT, let it
|
||||
* p_siglist. If the process catches SIGCONT, let it
|
||||
* handle the signal itself. If it isn't waiting on
|
||||
* an event, it goes back to run state.
|
||||
* Otherwise, process goes back to sleep state.
|
||||
@ -1381,7 +1373,7 @@ psignal(p, sig)
|
||||
p->p_flag &= ~P_STOPPED_SIG;
|
||||
p->p_flag |= P_CONTINUED;
|
||||
if (action == SIG_DFL) {
|
||||
signal_delete(p, NULL, sig);
|
||||
SIGDELSET(p->p_siglist, sig);
|
||||
} else if (action == SIG_CATCH) {
|
||||
/*
|
||||
* The process wants to catch it so it needs
|
||||
@ -1411,7 +1403,7 @@ psignal(p, sig)
|
||||
* Just make sure the signal STOP bit set.
|
||||
*/
|
||||
p->p_flag |= P_STOPPED_SIG;
|
||||
signal_delete(p, NULL, sig);
|
||||
SIGDELSET(p->p_siglist, sig);
|
||||
goto out;
|
||||
}
|
||||
|
||||
@ -1445,7 +1437,7 @@ psignal(p, sig)
|
||||
/*
|
||||
* Already active, don't need to start again.
|
||||
*/
|
||||
signal_delete(p, NULL, sig);
|
||||
SIGDELSET(p->p_siglist, sig);
|
||||
goto out;
|
||||
}
|
||||
if ((p->p_flag & P_TRACED) || (action != SIG_DFL) ||
|
||||
@ -1469,7 +1461,7 @@ psignal(p, sig)
|
||||
mtx_unlock_spin(&sched_lock);
|
||||
stop(p);
|
||||
p->p_xstat = sig;
|
||||
signal_delete(p, NULL, sig);
|
||||
SIGDELSET(p->p_siglist, sig);
|
||||
PROC_LOCK(p->p_pptr);
|
||||
if ((p->p_pptr->p_procsig->ps_flag &
|
||||
PS_NOCLDSTOP) == 0) {
|
||||
@ -1486,7 +1478,7 @@ psignal(p, sig)
|
||||
/* NOTREACHED */
|
||||
} else {
|
||||
/* Not in "NORMAL" state. discard the signal. */
|
||||
signal_delete(p, NULL, sig);
|
||||
SIGDELSET(p->p_siglist, sig);
|
||||
goto out;
|
||||
}
|
||||
|
||||
@ -1561,7 +1553,7 @@ tdsignal(struct thread *td, int sig, sig_t action)
|
||||
* be awakened.
|
||||
*/
|
||||
if ((prop & SA_CONT) && action == SIG_DFL) {
|
||||
signal_delete(p, NULL, sig);
|
||||
SIGDELSET(p->p_siglist, sig);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -1617,13 +1609,13 @@ issignal(td)
|
||||
for (;;) {
|
||||
int traced = (p->p_flag & P_TRACED) || (p->p_stops & S_SIG);
|
||||
|
||||
ksiginfo_to_sigset_t(p, &mask);
|
||||
mask = p->p_siglist;
|
||||
SIGSETNAND(mask, p->p_sigmask);
|
||||
if (p->p_flag & P_PPWAIT)
|
||||
SIG_STOPSIGMASK(mask);
|
||||
if (SIGISEMPTY(mask)) /* no signal to send */
|
||||
return (0);
|
||||
sig = signal_queued_mask(p, mask);
|
||||
sig = sig_ffs(&mask);
|
||||
prop = sigprop(sig);
|
||||
|
||||
_STOPEVENT(p, S_SIG, sig);
|
||||
@ -1633,7 +1625,7 @@ issignal(td)
|
||||
* only if P_TRACED was on when they were posted.
|
||||
*/
|
||||
if (SIGISMEMBER(p->p_sigignore, sig) && (traced == 0)) {
|
||||
signal_delete(p, NULL, sig);
|
||||
SIGDELSET(p->p_siglist, sig);
|
||||
continue;
|
||||
}
|
||||
if (p->p_flag & P_TRACED && (p->p_flag & P_PPWAIT) == 0) {
|
||||
@ -1668,16 +1660,16 @@ issignal(td)
|
||||
* then it will leave it in p->p_xstat;
|
||||
* otherwise we just look for signals again.
|
||||
*/
|
||||
signal_delete(p, NULL, sig); /* clear old signal */
|
||||
SIGDELSET(p->p_siglist, sig); /* clear old signal */
|
||||
sig = p->p_xstat;
|
||||
if (sig == 0)
|
||||
continue;
|
||||
|
||||
/*
|
||||
* Put the new signal into p_sigq. If the signal
|
||||
* is being masked, look for other signals.
|
||||
* Put the new signal into p_siglist. If the
|
||||
* signal is being masked, look for other signals.
|
||||
*/
|
||||
psignal(p, sig);
|
||||
SIGADDSET(p->p_siglist, sig);
|
||||
if (SIGISMEMBER(p->p_sigmask, sig))
|
||||
continue;
|
||||
signotify(p);
|
||||
@ -1767,7 +1759,7 @@ issignal(td)
|
||||
*/
|
||||
return (sig);
|
||||
}
|
||||
signal_delete(p, NULL, sig); /* take the signal! */
|
||||
SIGDELSET(p->p_siglist, sig); /* take the signal! */
|
||||
}
|
||||
/* NOTREACHED */
|
||||
}
|
||||
@ -1808,7 +1800,7 @@ postsig(sig)
|
||||
|
||||
PROC_LOCK_ASSERT(p, MA_OWNED);
|
||||
ps = p->p_sigacts;
|
||||
signal_delete(p, NULL, sig);
|
||||
SIGDELSET(p->p_siglist, sig);
|
||||
action = ps->ps_sigact[_SIG_IDX(sig)];
|
||||
#ifdef KTRACE
|
||||
if (KTRPOINT(td, KTR_PSIG))
|
||||
|
@ -1,301 +0,0 @@
|
||||
/*-
|
||||
* Copyright (c) 2002 New Gold Technology. All rights reserved.
|
||||
* Copyright (c) 2002 Juli Mallett. All rights reserved.
|
||||
*
|
||||
* This software was written by Juli Mallett <jmallett@FreeBSD.org> for the
|
||||
* FreeBSD project. Redistribution and use in source and binary forms, with
|
||||
* or without modification, are permitted provided that the following
|
||||
* conditions are met:
|
||||
*
|
||||
* 1. Redistribution of source code must retain the above copyright notice,
|
||||
* this list of conditions and the following disclaimer.
|
||||
* 2. Redistribution in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
|
||||
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
|
||||
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
#include <sys/param.h>
|
||||
#include <sys/kernel.h>
|
||||
#include <sys/systm.h>
|
||||
#include <sys/signalvar.h>
|
||||
#include <sys/proc.h>
|
||||
#include <sys/errno.h>
|
||||
#include <sys/lock.h>
|
||||
#include <sys/malloc.h>
|
||||
#include <sys/mutex.h>
|
||||
#include <sys/signal.h>
|
||||
#include <sys/ksiginfo.h>
|
||||
|
||||
MALLOC_DEFINE(M_KSIGINFO, "ksiginfos", "Kernel signal info structures");
|
||||
|
||||
int
|
||||
ksiginfo_alloc(struct ksiginfo **ksip, int signo)
|
||||
{
|
||||
int error;
|
||||
struct ksiginfo *ksi;
|
||||
|
||||
error = 0;
|
||||
|
||||
ksi = malloc(sizeof *ksi, M_KSIGINFO, M_ZERO | M_NOWAIT);
|
||||
if (ksi == NULL) {
|
||||
panic("Unable to allocate kernel signal info structure.");
|
||||
error = ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
ksi->ksi_signo = signo;
|
||||
if (curproc != NULL) {
|
||||
ksi->ksi_pid = curproc->p_pid;
|
||||
ksi->ksi_ruid = curproc->p_ucred->cr_uid;
|
||||
}
|
||||
out:
|
||||
*ksip = ksi;
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
ksiginfo_dequeue(struct ksiginfo **ksip, struct proc *p, int signo)
|
||||
{
|
||||
int error;
|
||||
struct ksiginfo *ksi;
|
||||
|
||||
error = 0;
|
||||
ksi = NULL;
|
||||
|
||||
PROC_LOCK_ASSERT(p, MA_OWNED);
|
||||
if (TAILQ_EMPTY(&p->p_sigq)) {
|
||||
error = EDOOFUS;
|
||||
goto out;
|
||||
}
|
||||
if (!signo) {
|
||||
ksi = TAILQ_FIRST(&p->p_sigq);
|
||||
goto out;
|
||||
}
|
||||
TAILQ_FOREACH(ksi, &p->p_sigq, ksi_queue) {
|
||||
if (ksi->ksi_signo == signo)
|
||||
goto out;
|
||||
}
|
||||
error = ESRCH;
|
||||
ksi = NULL;
|
||||
out:
|
||||
if (ksi != NULL)
|
||||
TAILQ_REMOVE(&p->p_sigq, ksi, ksi_queue);
|
||||
*ksip = ksi;
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
ksiginfo_destroy(struct ksiginfo **ksip)
|
||||
{
|
||||
int error;
|
||||
struct ksiginfo *ksi;
|
||||
|
||||
error = 0;
|
||||
|
||||
ksi = *ksip;
|
||||
if (ksi == NULL) {
|
||||
error = EDOOFUS;
|
||||
goto out;
|
||||
}
|
||||
free(ksi, M_KSIGINFO);
|
||||
ksi = NULL;
|
||||
out:
|
||||
*ksip = ksi;
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
ksiginfo_to_sigset_t(struct proc *p, sigset_t *setp)
|
||||
{
|
||||
int error;
|
||||
sigset_t set;
|
||||
struct ksiginfo *ksi;
|
||||
|
||||
error = 0;
|
||||
SIGEMPTYSET(set);
|
||||
|
||||
PROC_LOCK_ASSERT(p, MA_OWNED);
|
||||
/*
|
||||
* We could set EDOOFUS here, however if there are no queued
|
||||
* signals, then an empty signal set _is_ valid.
|
||||
*/
|
||||
if (TAILQ_EMPTY(&p->p_sigq))
|
||||
goto out;
|
||||
TAILQ_FOREACH(ksi, &p->p_sigq, ksi_queue)
|
||||
SIGADDSET(set, ksi->ksi_signo);
|
||||
out:
|
||||
*setp = set;
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
signal_add(struct proc *p, struct ksiginfo *ksi, int signo)
|
||||
{
|
||||
int error;
|
||||
|
||||
error = 0;
|
||||
|
||||
PROC_LOCK_ASSERT(p, MA_OWNED);
|
||||
if (ksi == NULL) {
|
||||
PROC_UNLOCK(p);
|
||||
error = ksiginfo_alloc(&ksi, signo);
|
||||
PROC_LOCK(p);
|
||||
if (error)
|
||||
goto out;
|
||||
}
|
||||
TAILQ_INSERT_HEAD(&p->p_sigq, ksi, ksi_queue);
|
||||
out:
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
signal_delete(struct proc *p, struct ksiginfo *ksi, int signo)
|
||||
{
|
||||
int error;
|
||||
|
||||
error = 0;
|
||||
|
||||
PROC_LOCK_ASSERT(p, MA_OWNED);
|
||||
if (ksi == NULL) {
|
||||
while (signal_queued(p, signo)) {
|
||||
error = ksiginfo_dequeue(&ksi, p, signo);
|
||||
if (error)
|
||||
goto out;
|
||||
error = ksiginfo_destroy(&ksi);
|
||||
if (error)
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
out:
|
||||
if (ksi != NULL) {
|
||||
TAILQ_REMOVE(&p->p_sigq, ksi, ksi_queue);
|
||||
ksiginfo_destroy(&ksi);
|
||||
}
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
signal_delete_mask(struct proc *p, int mask)
|
||||
{
|
||||
int error;
|
||||
struct ksiginfo *ksi, *prev;
|
||||
|
||||
error = 0;
|
||||
ksi = prev = NULL;
|
||||
|
||||
PROC_LOCK_ASSERT(p, MA_OWNED);
|
||||
if (TAILQ_EMPTY(&p->p_sigq))
|
||||
goto out;
|
||||
TAILQ_FOREACH(ksi, &p->p_sigq, ksi_queue) {
|
||||
if (prev != NULL) {
|
||||
TAILQ_REMOVE(&p->p_sigq, prev, ksi_queue);
|
||||
error = ksiginfo_destroy(&prev);
|
||||
if (error)
|
||||
goto out;
|
||||
}
|
||||
if (sigmask(ksi->ksi_signo) & mask)
|
||||
prev = ksi;
|
||||
}
|
||||
if (prev != NULL) {
|
||||
TAILQ_REMOVE(&p->p_sigq, prev, ksi_queue);
|
||||
error = ksiginfo_destroy(&prev);
|
||||
/*
|
||||
* XXX - Could just fall off the bottom...
|
||||
*/
|
||||
if (error)
|
||||
goto out;
|
||||
}
|
||||
out:
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
signal_pending(struct proc *p)
|
||||
{
|
||||
int error, pending;
|
||||
sigset_t set;
|
||||
|
||||
error = 0;
|
||||
pending = 0;
|
||||
|
||||
PROC_LOCK_ASSERT(p, MA_OWNED);
|
||||
if (TAILQ_EMPTY(&p->p_sigq))
|
||||
goto out;
|
||||
if (p->p_flag & P_TRACED) {
|
||||
pending = 1;
|
||||
goto out;
|
||||
}
|
||||
error = ksiginfo_to_sigset_t(p, &set);
|
||||
if (error)
|
||||
goto out;
|
||||
pending = !sigsetmasked(&set, &p->p_sigmask);
|
||||
if (pending)
|
||||
goto out;
|
||||
out:
|
||||
return (pending);
|
||||
}
|
||||
|
||||
int
|
||||
signal_queued(struct proc *p, int signo)
|
||||
{
|
||||
int error, pending;
|
||||
struct ksiginfo *ksi;
|
||||
|
||||
error = 0;
|
||||
pending = 0;
|
||||
ksi = NULL;
|
||||
|
||||
PROC_LOCK_ASSERT(p, MA_OWNED);
|
||||
if (TAILQ_EMPTY(&p->p_sigq))
|
||||
goto out;
|
||||
/*
|
||||
* Since we know the queue is not empty, we can just do
|
||||
* pending = TAILQ_FIRST(&p->p_sigq)->ksi_signo, if the
|
||||
* signo is 0, however since we have to use at least one
|
||||
* more TailQ manipulation macro either way, might as well
|
||||
* just do it like this, as I think it optimises better,
|
||||
* even if the failure case is more expensive.
|
||||
*/
|
||||
TAILQ_FOREACH(ksi, &p->p_sigq, ksi_queue) {
|
||||
pending = !signo || ksi->ksi_signo == signo;
|
||||
if (pending)
|
||||
goto out;
|
||||
}
|
||||
out:
|
||||
return (pending);
|
||||
}
|
||||
|
||||
int
|
||||
signal_queued_mask(struct proc *p, sigset_t mask)
|
||||
{
|
||||
int pending;
|
||||
struct ksiginfo *ksi;
|
||||
|
||||
pending = 0;
|
||||
ksi = NULL;
|
||||
|
||||
PROC_LOCK_ASSERT(p, MA_OWNED);
|
||||
if (TAILQ_EMPTY(&p->p_sigq))
|
||||
goto out;
|
||||
TAILQ_FOREACH(ksi, &p->p_sigq, ksi_queue) {
|
||||
if (SIGISMEMBER(mask, ksi->ksi_signo)) {
|
||||
pending = ksi->ksi_signo;
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
out:
|
||||
return (pending);
|
||||
}
|
@ -54,8 +54,6 @@
|
||||
#include <sys/signalvar.h>
|
||||
#include <sys/systm.h>
|
||||
#include <sys/vmmeter.h>
|
||||
#include <sys/malloc.h>
|
||||
#include <sys/ksiginfo.h>
|
||||
#include <machine/cpu.h>
|
||||
#include <machine/pcb.h>
|
||||
|
||||
@ -82,7 +80,7 @@ userret(td, frame, oticks)
|
||||
mtx_lock(&Giant);
|
||||
PROC_LOCK(p);
|
||||
mtx_lock_spin(&sched_lock);
|
||||
if (signal_pending(p) && ((p->p_sflag & PS_NEEDSIGCHK) == 0 ||
|
||||
if (SIGPENDING(p) && ((p->p_sflag & PS_NEEDSIGCHK) == 0 ||
|
||||
(td->td_kse->ke_flags & KEF_ASTPENDING) == 0))
|
||||
printf("failed to set signal flags properly for ast()\n");
|
||||
mtx_unlock_spin(&sched_lock);
|
||||
|
@ -102,7 +102,6 @@
|
||||
#include <sys/malloc.h>
|
||||
#include <sys/filedesc.h>
|
||||
#include <sys/sysctl.h>
|
||||
#include <sys/ksiginfo.h>
|
||||
|
||||
#include <vm/vm.h>
|
||||
#include <vm/pmap.h>
|
||||
@ -1842,24 +1841,21 @@ int
|
||||
ttycheckoutq(struct tty *tp, int wait)
|
||||
{
|
||||
int hiwat, s;
|
||||
sigset_t oldmask, newmask;
|
||||
sigset_t oldmask;
|
||||
|
||||
hiwat = tp->t_ohiwat;
|
||||
SIGEMPTYSET(oldmask);
|
||||
s = spltty();
|
||||
if (wait)
|
||||
ksiginfo_to_sigset_t(curproc, &oldmask);
|
||||
oldmask = curproc->p_siglist;
|
||||
if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100)
|
||||
while (tp->t_outq.c_cc > hiwat) {
|
||||
ttstart(tp);
|
||||
if (tp->t_outq.c_cc <= hiwat)
|
||||
break;
|
||||
if (!wait) {
|
||||
ksiginfo_to_sigset_t(curproc, &newmask);
|
||||
if (SIGSETEQ(newmask, oldmask)) {
|
||||
splx(s);
|
||||
return (0);
|
||||
}
|
||||
if (!(wait && SIGSETEQ(curproc->p_siglist, oldmask))) {
|
||||
splx(s);
|
||||
return (0);
|
||||
}
|
||||
SET(tp->t_state, TS_SO_OLOWAT);
|
||||
tsleep(TSA_OLOWAT(tp), PZERO - 1, "ttoutq", hz);
|
||||
|
@ -42,7 +42,6 @@
|
||||
#include <sys/sysctl.h>
|
||||
#include <sys/mbuf.h>
|
||||
#include <sys/uio.h>
|
||||
#include <sys/ksiginfo.h>
|
||||
|
||||
#include <netipx/ipx.h>
|
||||
#include <netipx/ipx_var.h>
|
||||
@ -81,10 +80,10 @@ ncp_chkintr(struct ncp_conn *conn, struct proc *p)
|
||||
|
||||
if (p == NULL)
|
||||
return 0;
|
||||
ksiginfo_to_sigset_t(p, &tmpset);
|
||||
tmpset = p->p_siglist;
|
||||
SIGSETNAND(tmpset, p->p_sigmask);
|
||||
SIGSETNAND(tmpset, p->p_sigignore);
|
||||
if (signal_queued(p, 0) && NCP_SIGMASK(tmpset))
|
||||
if (SIGNOTEMPTY(p->p_siglist) && NCP_SIGMASK(tmpset))
|
||||
return EINTR;
|
||||
return 0;
|
||||
}
|
||||
|
@ -42,7 +42,6 @@
|
||||
#include <sys/socket.h>
|
||||
#include <sys/signalvar.h>
|
||||
#include <sys/mbuf.h>
|
||||
#include <sys/ksiginfo.h>
|
||||
|
||||
#include <sys/iconv.h>
|
||||
|
||||
@ -76,10 +75,10 @@ smb_proc_intr(struct proc *p)
|
||||
|
||||
if (p == NULL)
|
||||
return 0;
|
||||
ksiginfo_to_sigset_t(p, &tmpset);
|
||||
tmpset = p->p_siglist;
|
||||
SIGSETNAND(tmpset, p->p_sigmask);
|
||||
SIGSETNAND(tmpset, p->p_sigignore);
|
||||
if (signal_queued(p, 0) && SMB_SIGMASK(tmpset))
|
||||
if (SIGNOTEMPTY(p->p_siglist) && SMB_SIGMASK(tmpset))
|
||||
return EINTR;
|
||||
return 0;
|
||||
}
|
||||
|
@ -61,7 +61,6 @@ __FBSDID("$FreeBSD$");
|
||||
#include <sys/sysctl.h>
|
||||
#include <sys/syslog.h>
|
||||
#include <sys/vnode.h>
|
||||
#include <sys/ksiginfo.h>
|
||||
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/tcp.h>
|
||||
@ -1240,15 +1239,11 @@ nfs_sigintr(struct nfsmount *nmp, struct nfsreq *rep, struct thread *td)
|
||||
return (0);
|
||||
|
||||
p = td->td_proc;
|
||||
PROC_LOCK(p);
|
||||
ksiginfo_to_sigset_t(p, &tmpset);
|
||||
tmpset = p->p_siglist;
|
||||
SIGSETNAND(tmpset, p->p_sigmask);
|
||||
SIGSETNAND(tmpset, p->p_sigignore);
|
||||
if (signal_queued(p, 0) && NFSINT_SIGMASK(tmpset)) {
|
||||
PROC_UNLOCK(p);
|
||||
if (SIGNOTEMPTY(p->p_siglist) && NFSINT_SIGMASK(tmpset))
|
||||
return (EINTR);
|
||||
}
|
||||
PROC_UNLOCK(p);
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
@ -1,78 +0,0 @@
|
||||
/*-
|
||||
* Copyright (c) 2002 New Gold Technology. All rights reserved.
|
||||
* Copyright (c) 2002 Juli Mallett. All rights reserved.
|
||||
*
|
||||
* This software was written by Juli Mallett <jmallett@FreeBSD.org> for the
|
||||
* FreeBSD project. Redistribution and use in source and binary forms, with
|
||||
* or without modification, are permitted provided that the following
|
||||
* conditions are met:
|
||||
*
|
||||
* 1. Redistribution of source code must retain the above copyright notice,
|
||||
* this list of conditions and the following disclaimer.
|
||||
* 2. Redistribution in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
|
||||
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
|
||||
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
#ifndef _SYS_KSIGINFO_H_
|
||||
#define _SYS_KSIGINFO_H_
|
||||
|
||||
#ifndef _KERNEL
|
||||
#error "no user-serviceable parts inside"
|
||||
#endif
|
||||
|
||||
#include <sys/malloc.h>
|
||||
|
||||
/*
|
||||
* Structures and prototypes for working with the in-kernel representation
|
||||
* of pending signals, and all the information we have about them.
|
||||
*/
|
||||
|
||||
MALLOC_DECLARE(M_KSIGINFO);
|
||||
|
||||
/*
|
||||
* This is pushed to userland in the form of a siginfo_t, which is POSIX
|
||||
* defined. This is for in-kernel representations only, and has no ABI
|
||||
* consumers.
|
||||
*/
|
||||
struct ksiginfo {
|
||||
TAILQ_ENTRY(ksiginfo) ksi_queue; /* Entry in the signal queue. */
|
||||
void *ksi_addr; /* [Fault] address. */
|
||||
int ksi_code; /* [Trap] code. */
|
||||
int ksi_errno; /* Error number. */
|
||||
int ksi_signo; /* Signal number. */
|
||||
int ksi_status; /* Exit status (SIGCHLD). */
|
||||
uid_t ksi_ruid; /* Real UID of sender. */
|
||||
pid_t ksi_pid; /* PID of sender. */
|
||||
};
|
||||
|
||||
struct proc;
|
||||
|
||||
__BEGIN_DECLS;
|
||||
int ksiginfo_alloc(struct ksiginfo **, int);
|
||||
int ksiginfo_dequeue(struct ksiginfo **, struct proc *, int);
|
||||
int ksiginfo_destroy(struct ksiginfo **);
|
||||
int ksiginfo_to_sigset_t(struct proc *, sigset_t *);
|
||||
int signal_add(struct proc *, struct ksiginfo *, int);
|
||||
int signal_delete(struct proc *, struct ksiginfo *, int);
|
||||
int signal_delete_mask(struct proc *, int);
|
||||
int signal_pending(struct proc *);
|
||||
int signal_queued(struct proc *, int);
|
||||
int signal_queued_mask(struct proc *, sigset_t);
|
||||
__END_DECLS;
|
||||
|
||||
#endif /* !_SYS_KSIGINFO_H_ */
|
@ -497,7 +497,6 @@ struct proc {
|
||||
TAILQ_HEAD(, ksegrp) p_ksegrps; /* (kg_ksegrp) All KSEGs. */
|
||||
TAILQ_HEAD(, thread) p_threads; /* (td_plist) Threads. (shortcut) */
|
||||
TAILQ_HEAD(, thread) p_suspended; /* (td_runq) suspended threads */
|
||||
TAILQ_HEAD(, ksiginfo) p_sigq; /* (c) Queued signals. */
|
||||
struct ucred *p_ucred; /* (c) Process owner's identity. */
|
||||
struct filedesc *p_fd; /* (b) Ptr to open files structure. */
|
||||
/* Accumulated stats for all KSEs? */
|
||||
@ -538,6 +537,7 @@ struct proc {
|
||||
struct bintime p_runtime; /* (j) Real time. */
|
||||
int p_traceflag; /* (o) Kernel trace points. */
|
||||
struct vnode *p_tracep; /* (c + o) Trace to vnode. */
|
||||
sigset_t p_siglist; /* (c) Sigs arrived, not delivered. */
|
||||
struct vnode *p_textvp; /* (b) Vnode of executable. */
|
||||
char p_lock; /* (c) Proclock (prevent swap) count. */
|
||||
struct klist p_klist; /* (c) Knotes attached to this proc. */
|
||||
|
Loading…
Reference in New Issue
Block a user