[BACK]Return to kern_sig.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / kern

Annotation of src/sys/kern/kern_sig.c, Revision 1.280

1.280   ! martin      1: /*     $NetBSD: kern_sig.c,v 1.279 2008/04/25 11:24:11 ad Exp $        */
1.243     ad          2:
                      3: /*-
1.277     ad          4:  * Copyright (c) 2006, 2007, 2008 The NetBSD Foundation, Inc.
1.243     ad          5:  * All rights reserved.
                      6:  *
                      7:  * This code is derived from software contributed to The NetBSD Foundation
                      8:  * by Andrew Doran.
                      9:  *
                     10:  * Redistribution and use in source and binary forms, with or without
                     11:  * modification, are permitted provided that the following conditions
                     12:  * are met:
                     13:  * 1. Redistributions of source code must retain the above copyright
                     14:  *    notice, this list of conditions and the following disclaimer.
                     15:  * 2. Redistributions in binary form must reproduce the above copyright
                     16:  *    notice, this list of conditions and the following disclaimer in the
                     17:  *    documentation and/or other materials provided with the distribution.
                     18:  *
                     19:  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
                     20:  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
                     21:  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
                     22:  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
                     23:  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
                     24:  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
                     25:  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
                     26:  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
                     27:  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
                     28:  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
                     29:  * POSSIBILITY OF SUCH DAMAGE.
                     30:  */
1.29      cgd        31:
                     32: /*
                     33:  * Copyright (c) 1982, 1986, 1989, 1991, 1993
                     34:  *     The Regents of the University of California.  All rights reserved.
                     35:  * (c) UNIX System Laboratories, Inc.
                     36:  * All or some portions of this file are derived from material licensed
                     37:  * to the University of California by American Telephone and Telegraph
                     38:  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
                     39:  * the permission of UNIX System Laboratories, Inc.
                     40:  *
                     41:  * Redistribution and use in source and binary forms, with or without
                     42:  * modification, are permitted provided that the following conditions
                     43:  * are met:
                     44:  * 1. Redistributions of source code must retain the above copyright
                     45:  *    notice, this list of conditions and the following disclaimer.
                     46:  * 2. Redistributions in binary form must reproduce the above copyright
                     47:  *    notice, this list of conditions and the following disclaimer in the
                     48:  *    documentation and/or other materials provided with the distribution.
1.146     agc        49:  * 3. Neither the name of the University nor the names of its contributors
1.29      cgd        50:  *    may be used to endorse or promote products derived from this software
                     51:  *    without specific prior written permission.
                     52:  *
                     53:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
                     54:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     55:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     56:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     57:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     58:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     59:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     60:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     61:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     62:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     63:  * SUCH DAMAGE.
                     64:  *
1.71      fvdl       65:  *     @(#)kern_sig.c  8.14 (Berkeley) 5/14/95
1.29      cgd        66:  */
1.116     lukem      67:
                     68: #include <sys/cdefs.h>
1.280   ! martin     69: __KERNEL_RCSID(0, "$NetBSD: kern_sig.c,v 1.279 2008/04/25 11:24:11 ad Exp $");
1.70      mrg        70:
1.227     matt       71: #include "opt_ptrace.h"
1.222     rjs        72: #include "opt_multiprocessor.h"
1.74      thorpej    73: #include "opt_compat_sunos.h"
1.158     christos   74: #include "opt_compat_netbsd.h"
1.202     perry      75: #include "opt_compat_netbsd32.h"
1.240     elad       76: #include "opt_pax.h"
1.29      cgd        77:
                     78: #define        SIGPROP         /* include signal properties table */
                     79: #include <sys/param.h>
                     80: #include <sys/signalvar.h>
                     81: #include <sys/proc.h>
                     82: #include <sys/systm.h>
                     83: #include <sys/wait.h>
                     84: #include <sys/ktrace.h>
                     85: #include <sys/syslog.h>
1.59      cgd        86: #include <sys/filedesc.h>
1.243     ad         87: #include <sys/file.h>
1.89      thorpej    88: #include <sys/malloc.h>
                     89: #include <sys/pool.h>
1.130     thorpej    90: #include <sys/ucontext.h>
1.118     thorpej    91: #include <sys/exec.h>
1.220     elad       92: #include <sys/kauth.h>
1.243     ad         93: #include <sys/acct.h>
                     94: #include <sys/callout.h>
1.260     ad         95: #include <sys/atomic.h>
1.258     ad         96: #include <sys/cpu.h>
1.29      cgd        97:
1.240     elad       98: #ifdef PAX_SEGVGUARD
                     99: #include <sys/pax.h>
                    100: #endif /* PAX_SEGVGUARD */
                    101:
1.196     skrll     102: #include <uvm/uvm.h>
1.69      mrg       103: #include <uvm/uvm_extern.h>
                    104:
1.243     ad        105: static void    ksiginfo_exechook(struct proc *, void *);
                    106: static void    proc_stop_callout(void *);
                    107:
                    108: int    sigunwait(struct proc *, const ksiginfo_t *);
                    109: void   sigput(sigpend_t *, struct proc *, ksiginfo_t *);
                    110: int    sigpost(struct lwp *, sig_t, int, int);
                    111: int    sigchecktrace(sigpend_t **);
1.248     thorpej   112: void   sigswitch(bool, int, int);
1.243     ad        113: void   sigrealloc(ksiginfo_t *);
1.152     christos  114:
1.198     jdolecek  115: sigset_t       contsigmask, stopsigmask, sigcantmask;
1.279     ad        116: static pool_cache_t sigacts_cache; /* memory pool for sigacts structures */
1.243     ad        117: static void    sigacts_poolpage_free(struct pool *, void *);
                    118: static void    *sigacts_poolpage_alloc(struct pool *, int);
1.254     ad        119: static callout_t proc_stop_ch;
1.196     skrll     120:
                    121: static struct pool_allocator sigactspool_allocator = {
1.228     christos  122:         .pa_alloc = sigacts_poolpage_alloc,
                    123:        .pa_free = sigacts_poolpage_free,
1.196     skrll     124: };
                    125:
1.243     ad        126: #ifdef DEBUG
                    127: int    kern_logsigexit = 1;
                    128: #else
                    129: int    kern_logsigexit = 0;
                    130: #endif
1.89      thorpej   131:
1.243     ad        132: static const char logcoredump[] =
                    133:     "pid %d (%s), uid %d: exited on signal %d (core dumped)\n";
                    134: static const char lognocoredump[] =
                    135:     "pid %d (%s), uid %d: exited on signal %d (core not dumped, err = %d)\n";
1.237     yamt      136:
1.243     ad        137: POOL_INIT(siginfo_pool, sizeof(siginfo_t), 0, 0, 0, "siginfo",
1.252     ad        138:     &pool_allocator_nointr, IPL_NONE);
                    139: POOL_INIT(ksiginfo_pool, sizeof(ksiginfo_t), 0, 0, 0, "ksiginfo",
1.257     ad        140:     NULL, IPL_VM);
1.237     yamt      141:
1.29      cgd       142: /*
1.243     ad        143:  * signal_init:
                    144:  *
                    145:  *     Initialize global signal-related data structures.
1.152     christos  146:  */
1.243     ad        147: void
                    148: signal_init(void)
1.152     christos  149: {
                    150:
1.243     ad        151:        sigactspool_allocator.pa_pagesz = (PAGE_SIZE)*2;
1.152     christos  152:
1.279     ad        153:        sigacts_cache = pool_cache_init(sizeof(struct sigacts), 0, 0, 0,
                    154:            "sigacts", sizeof(struct sigacts) > PAGE_SIZE ?
                    155:            &sigactspool_allocator : NULL, IPL_NONE, NULL, NULL, NULL);
1.152     christos  156:
1.243     ad        157:        exechook_establish(ksiginfo_exechook, NULL);
1.152     christos  158:
1.265     ad        159:        callout_init(&proc_stop_ch, CALLOUT_MPSAFE);
1.243     ad        160:        callout_setfunc(&proc_stop_ch, proc_stop_callout, NULL);
1.152     christos  161: }
                    162:
                    163: /*
1.243     ad        164:  * sigacts_poolpage_alloc:
                    165:  *
                    166:  *      Allocate a page for the sigacts memory pool.
1.152     christos  167:  */
1.243     ad        168: static void *
                    169: sigacts_poolpage_alloc(struct pool *pp, int flags)
1.152     christos  170: {
                    171:
1.243     ad        172:        return (void *)uvm_km_alloc(kernel_map,
                    173:            (PAGE_SIZE)*2, (PAGE_SIZE)*2,
                    174:            ((flags & PR_WAITOK) ? 0 : UVM_KMF_NOWAIT | UVM_KMF_TRYLOCK)
                    175:            | UVM_KMF_WIRED);
1.152     christos  176: }
                    177:
                    178: /*
1.243     ad        179:  * sigacts_poolpage_free:
                    180:  *
                    181:  *      Free a page on behalf of the sigacts memory pool.
1.89      thorpej   182:  */
1.243     ad        183: static void
                    184: sigacts_poolpage_free(struct pool *pp, void *v)
1.89      thorpej   185: {
1.279     ad        186:
1.243     ad        187:         uvm_km_free(kernel_map, (vaddr_t)v, (PAGE_SIZE)*2, UVM_KMF_WIRED);
1.89      thorpej   188: }
                    189:
                    190: /*
1.243     ad        191:  * sigactsinit:
                    192:  *
                    193:  *      Create an initial sigctx structure, using the same signal state as
                    194:  *      p.  If 'share' is set, share the sigctx_proc part, otherwise just
                    195:  *      copy it from parent.
1.89      thorpej   196:  */
1.243     ad        197: struct sigacts *
                    198: sigactsinit(struct proc *pp, int share)
1.89      thorpej   199: {
1.259     ad        200:        struct sigacts *ps, *ps2;
1.89      thorpej   201:
1.259     ad        202:        ps = pp->p_sigacts;
1.243     ad        203:
1.109     jdolecek  204:        if (share) {
1.279     ad        205:                atomic_inc_uint(&ps->sa_refcnt);
1.259     ad        206:                ps2 = ps;
1.109     jdolecek  207:        } else {
1.279     ad        208:                ps2 = pool_cache_get(sigacts_cache, PR_WAITOK);
1.277     ad        209:                /* XXXAD get rid of this */
1.262     ad        210:                mutex_init(&ps2->sa_mutex, MUTEX_DEFAULT, IPL_SCHED);
1.259     ad        211:                mutex_enter(&ps->sa_mutex);
                    212:                memcpy(&ps2->sa_sigdesc, ps->sa_sigdesc,
                    213:                    sizeof(ps2->sa_sigdesc));
                    214:                mutex_exit(&ps->sa_mutex);
                    215:                ps2->sa_refcnt = 1;
1.109     jdolecek  216:        }
1.243     ad        217:
1.259     ad        218:        return ps2;
1.89      thorpej   219: }
                    220:
                    221: /*
1.243     ad        222:  * sigactsunshare:
                    223:  *
                    224:  *     Make this process not share its sigctx, maintaining all
                    225:  *     signal state.
1.89      thorpej   226:  */
                    227: void
1.112     lukem     228: sigactsunshare(struct proc *p)
1.89      thorpej   229: {
1.243     ad        230:        struct sigacts *ps, *oldps;
                    231:
                    232:        oldps = p->p_sigacts;
1.259     ad        233:        if (oldps->sa_refcnt == 1)
1.89      thorpej   234:                return;
1.279     ad        235:        ps = pool_cache_get(sigacts_cache, PR_WAITOK);
1.277     ad        236:        /* XXXAD get rid of this */
1.262     ad        237:        mutex_init(&ps->sa_mutex, MUTEX_DEFAULT, IPL_SCHED);
1.259     ad        238:        memset(&ps->sa_sigdesc, 0, sizeof(ps->sa_sigdesc));
1.243     ad        239:        p->p_sigacts = ps;
                    240:        sigactsfree(oldps);
1.89      thorpej   241: }
                    242:
                    243: /*
1.243     ad        244:  * sigactsfree;
                    245:  *
                    246:  *     Release a sigctx structure.
1.89      thorpej   247:  */
                    248: void
1.195     pk        249: sigactsfree(struct sigacts *ps)
1.89      thorpej   250: {
                    251:
1.279     ad        252:        if (atomic_dec_uint_nv(&ps->sa_refcnt) == 0) {
1.243     ad        253:                mutex_destroy(&ps->sa_mutex);
1.279     ad        254:                pool_cache_put(sigacts_cache, ps);
1.29      cgd       255:        }
                    256: }
                    257:
                    258: /*
1.243     ad        259:  * siginit:
                    260:  *
                    261:  *     Initialize signal state for process 0; set to ignore signals that
                    262:  *     are ignored by default and disable the signal stack.  Locking not
                    263:  *     required as the system is still cold.
1.29      cgd       264:  */
                    265: void
1.112     lukem     266: siginit(struct proc *p)
1.29      cgd       267: {
1.243     ad        268:        struct lwp *l;
                    269:        struct sigacts *ps;
                    270:        int signo, prop;
1.79      mycroft   271:
1.112     lukem     272:        ps = p->p_sigacts;
1.79      mycroft   273:        sigemptyset(&contsigmask);
                    274:        sigemptyset(&stopsigmask);
                    275:        sigemptyset(&sigcantmask);
1.243     ad        276:        for (signo = 1; signo < NSIG; signo++) {
                    277:                prop = sigprop[signo];
1.79      mycroft   278:                if (prop & SA_CONT)
1.243     ad        279:                        sigaddset(&contsigmask, signo);
1.79      mycroft   280:                if (prop & SA_STOP)
1.243     ad        281:                        sigaddset(&stopsigmask, signo);
1.79      mycroft   282:                if (prop & SA_CANTMASK)
1.243     ad        283:                        sigaddset(&sigcantmask, signo);
                    284:                if (prop & SA_IGNORE && signo != SIGCONT)
                    285:                        sigaddset(&p->p_sigctx.ps_sigignore, signo);
                    286:                sigemptyset(&SIGACTION_PS(ps, signo).sa_mask);
                    287:                SIGACTION_PS(ps, signo).sa_flags = SA_RESTART;
1.79      mycroft   288:        }
1.109     jdolecek  289:        sigemptyset(&p->p_sigctx.ps_sigcatch);
1.243     ad        290:        p->p_sflag &= ~PS_NOCLDSTOP;
                    291:
                    292:        ksiginfo_queue_init(&p->p_sigpend.sp_info);
                    293:        sigemptyset(&p->p_sigpend.sp_set);
1.29      cgd       294:
1.79      mycroft   295:        /*
1.243     ad        296:         * Reset per LWP state.
1.79      mycroft   297:         */
1.243     ad        298:        l = LIST_FIRST(&p->p_lwps);
                    299:        l->l_sigwaited = NULL;
                    300:        l->l_sigstk.ss_flags = SS_DISABLE;
                    301:        l->l_sigstk.ss_size = 0;
                    302:        l->l_sigstk.ss_sp = 0;
                    303:        ksiginfo_queue_init(&l->l_sigpend.sp_info);
                    304:        sigemptyset(&l->l_sigpend.sp_set);
1.89      thorpej   305:
                    306:        /* One reference. */
1.109     jdolecek  307:        ps->sa_refcnt = 1;
1.29      cgd       308: }
                    309:
                    310: /*
1.243     ad        311:  * execsigs:
                    312:  *
                    313:  *     Reset signals for an exec of the specified process.
1.29      cgd       314:  */
                    315: void
1.112     lukem     316: execsigs(struct proc *p)
1.29      cgd       317: {
1.243     ad        318:        struct sigacts *ps;
                    319:        struct lwp *l;
                    320:        int signo, prop;
                    321:        sigset_t tset;
                    322:        ksiginfoq_t kq;
                    323:
                    324:        KASSERT(p->p_nlwps == 1);
                    325:
1.115     thorpej   326:        sigactsunshare(p);
1.112     lukem     327:        ps = p->p_sigacts;
1.115     thorpej   328:
1.29      cgd       329:        /*
1.243     ad        330:         * Reset caught signals.  Held signals remain held through
                    331:         * l->l_sigmask (unless they were caught, and are now ignored
                    332:         * by default).
1.259     ad        333:         *
                    334:         * No need to lock yet, the process has only one LWP and
                    335:         * at this point the sigacts are private to the process.
1.243     ad        336:         */
                    337:        sigemptyset(&tset);
                    338:        for (signo = 1; signo < NSIG; signo++) {
                    339:                if (sigismember(&p->p_sigctx.ps_sigcatch, signo)) {
                    340:                        prop = sigprop[signo];
1.79      mycroft   341:                        if (prop & SA_IGNORE) {
                    342:                                if ((prop & SA_CONT) == 0)
1.112     lukem     343:                                        sigaddset(&p->p_sigctx.ps_sigignore,
1.243     ad        344:                                            signo);
                    345:                                sigaddset(&tset, signo);
1.79      mycroft   346:                        }
1.243     ad        347:                        SIGACTION_PS(ps, signo).sa_handler = SIG_DFL;
1.29      cgd       348:                }
1.243     ad        349:                sigemptyset(&SIGACTION_PS(ps, signo).sa_mask);
                    350:                SIGACTION_PS(ps, signo).sa_flags = SA_RESTART;
1.29      cgd       351:        }
1.243     ad        352:        ksiginfo_queue_init(&kq);
1.259     ad        353:
1.277     ad        354:        mutex_enter(p->p_lock);
1.243     ad        355:        sigclearall(p, &tset, &kq);
1.109     jdolecek  356:        sigemptyset(&p->p_sigctx.ps_sigcatch);
1.205     christos  357:
                    358:        /*
                    359:         * Reset no zombies if child dies flag as Solaris does.
                    360:         */
1.246     pavel     361:        p->p_flag &= ~(PK_NOCLDWAIT | PK_CLDSIGIGN);
1.205     christos  362:        if (SIGACTION_PS(ps, SIGCHLD).sa_handler == SIG_IGN)
                    363:                SIGACTION_PS(ps, SIGCHLD).sa_handler = SIG_DFL;
1.79      mycroft   364:
1.29      cgd       365:        /*
1.243     ad        366:         * Reset per-LWP state.
1.29      cgd       367:         */
1.243     ad        368:        l = LIST_FIRST(&p->p_lwps);
                    369:        l->l_sigwaited = NULL;
                    370:        l->l_sigstk.ss_flags = SS_DISABLE;
                    371:        l->l_sigstk.ss_size = 0;
                    372:        l->l_sigstk.ss_sp = 0;
                    373:        ksiginfo_queue_init(&l->l_sigpend.sp_info);
                    374:        sigemptyset(&l->l_sigpend.sp_set);
1.277     ad        375:        mutex_exit(p->p_lock);
1.243     ad        376:
                    377:        ksiginfo_queue_drain(&kq);
1.29      cgd       378: }
                    379:
1.243     ad        380: /*
                    381:  * ksiginfo_exechook:
                    382:  *
                    383:  *     Free all pending ksiginfo entries from a process on exec.
                    384:  *     Additionally, drain any unused ksiginfo structures in the
                    385:  *     system back to the pool.
                    386:  *
                    387:  *     XXX This should not be a hook, every process has signals.
                    388:  */
                    389: static void
                    390: ksiginfo_exechook(struct proc *p, void *v)
1.79      mycroft   391: {
1.243     ad        392:        ksiginfoq_t kq;
1.79      mycroft   393:
1.243     ad        394:        ksiginfo_queue_init(&kq);
1.79      mycroft   395:
1.277     ad        396:        mutex_enter(p->p_lock);
1.243     ad        397:        sigclearall(p, NULL, &kq);
1.277     ad        398:        mutex_exit(p->p_lock);
1.79      mycroft   399:
1.243     ad        400:        ksiginfo_queue_drain(&kq);
1.79      mycroft   401: }
1.202     perry     402:
1.29      cgd       403: /*
1.243     ad        404:  * ksiginfo_alloc:
                    405:  *
                    406:  *     Allocate a new ksiginfo structure from the pool, and optionally copy
                    407:  *     an existing one.  If the existing ksiginfo_t is from the pool, and
                    408:  *     has not been queued somewhere, then just return it.  Additionally,
                    409:  *     if the existing ksiginfo_t does not contain any information beyond
                    410:  *     the signal number, then just return it.
1.29      cgd       411:  */
1.243     ad        412: ksiginfo_t *
                    413: ksiginfo_alloc(struct proc *p, ksiginfo_t *ok, int flags)
1.48      thorpej   414: {
1.243     ad        415:        ksiginfo_t *kp;
1.29      cgd       416:
1.243     ad        417:        if (ok != NULL) {
                    418:                if ((ok->ksi_flags & (KSI_QUEUED | KSI_FROMPOOL)) ==
                    419:                    KSI_FROMPOOL)
                    420:                        return ok;
                    421:                if (KSI_EMPTY_P(ok))
                    422:                        return ok;
1.79      mycroft   423:        }
1.243     ad        424:
                    425:        kp = pool_get(&ksiginfo_pool, flags);
                    426:        if (kp == NULL) {
                    427: #ifdef DIAGNOSTIC
                    428:                printf("Out of memory allocating ksiginfo for pid %d\n",
                    429:                    p->p_pid);
                    430: #endif
                    431:                return NULL;
1.79      mycroft   432:        }
1.243     ad        433:
                    434:        if (ok != NULL) {
                    435:                memcpy(kp, ok, sizeof(*kp));
                    436:                kp->ksi_flags &= ~KSI_QUEUED;
                    437:        } else
                    438:                KSI_INIT_EMPTY(kp);
                    439:
                    440:        kp->ksi_flags |= KSI_FROMPOOL;
                    441:
                    442:        return kp;
1.79      mycroft   443: }
                    444:
1.243     ad        445: /*
                    446:  * ksiginfo_free:
                    447:  *
                    448:  *     If the given ksiginfo_t is from the pool and has not been queued,
                    449:  *     then free it.
                    450:  */
1.79      mycroft   451: void
1.243     ad        452: ksiginfo_free(ksiginfo_t *kp)
1.79      mycroft   453: {
1.29      cgd       454:
1.243     ad        455:        if ((kp->ksi_flags & (KSI_QUEUED | KSI_FROMPOOL)) != KSI_FROMPOOL)
                    456:                return;
                    457:        pool_put(&ksiginfo_pool, kp);
1.29      cgd       458: }
                    459:
1.243     ad        460: /*
                    461:  * ksiginfo_queue_drain:
                    462:  *
                    463:  *     Drain a non-empty ksiginfo_t queue.
                    464:  */
                    465: void
                    466: ksiginfo_queue_drain0(ksiginfoq_t *kq)
1.29      cgd       467: {
1.243     ad        468:        ksiginfo_t *ksi;
1.79      mycroft   469:
1.243     ad        470:        KASSERT(!CIRCLEQ_EMPTY(kq));
                    471:
                    472:        while (!CIRCLEQ_EMPTY(kq)) {
                    473:                ksi = CIRCLEQ_FIRST(kq);
                    474:                CIRCLEQ_REMOVE(kq, ksi, ksi_list);
                    475:                pool_put(&ksiginfo_pool, ksi);
                    476:        }
1.79      mycroft   477: }
                    478:
1.243     ad        479: /*
                    480:  * sigget:
                    481:  *
                    482:  *     Fetch the first pending signal from a set.  Optionally, also fetch
                    483:  *     or manufacture a ksiginfo element.  Returns the number of the first
                    484:  *     pending signal, or zero.
                    485:  */
                    486: int
1.270     yamt      487: sigget(sigpend_t *sp, ksiginfo_t *out, int signo, const sigset_t *mask)
1.243     ad        488: {
                    489:         ksiginfo_t *ksi;
                    490:        sigset_t tset;
                    491:
                    492:        /* If there's no pending set, the signal is from the debugger. */
                    493:        if (sp == NULL) {
                    494:                if (out != NULL) {
                    495:                        KSI_INIT(out);
                    496:                        out->ksi_info._signo = signo;
                    497:                        out->ksi_info._code = SI_USER;
                    498:                }
                    499:                return signo;
                    500:        }
                    501:
                    502:        /* Construct mask from signo, and 'mask'. */
                    503:        if (signo == 0) {
                    504:                if (mask != NULL) {
                    505:                        tset = *mask;
                    506:                        __sigandset(&sp->sp_set, &tset);
                    507:                } else
                    508:                        tset = sp->sp_set;
                    509:
                    510:                /* If there are no signals pending, that's it. */
                    511:                if ((signo = firstsig(&tset)) == 0)
                    512:                        return 0;
                    513:        } else {
                    514:                KASSERT(sigismember(&sp->sp_set, signo));
                    515:        }
                    516:
                    517:        sigdelset(&sp->sp_set, signo);
1.29      cgd       518:
1.243     ad        519:        /* Find siginfo and copy it out. */
                    520:        CIRCLEQ_FOREACH(ksi, &sp->sp_info, ksi_list) {
                    521:                if (ksi->ksi_signo == signo) {
                    522:                        CIRCLEQ_REMOVE(&sp->sp_info, ksi, ksi_list);
                    523:                        KASSERT((ksi->ksi_flags & KSI_FROMPOOL) != 0);
                    524:                        KASSERT((ksi->ksi_flags & KSI_QUEUED) != 0);
                    525:                        ksi->ksi_flags &= ~KSI_QUEUED;
                    526:                        if (out != NULL) {
                    527:                                memcpy(out, ksi, sizeof(*out));
                    528:                                out->ksi_flags &= ~(KSI_FROMPOOL | KSI_QUEUED);
                    529:                        }
                    530:                        ksiginfo_free(ksi);
                    531:                        return signo;
                    532:                }
1.79      mycroft   533:        }
                    534:
1.243     ad        535:        /* If there's no siginfo, then manufacture it. */
                    536:        if (out != NULL) {
                    537:                KSI_INIT(out);
                    538:                out->ksi_info._signo = signo;
                    539:                out->ksi_info._code = SI_USER;
                    540:        }
1.202     perry     541:
1.243     ad        542:        return signo;
1.29      cgd       543: }
                    544:
                    545: /*
1.243     ad        546:  * sigput:
                    547:  *
                    548:  *     Append a new ksiginfo element to the list of pending ksiginfo's, if
                    549:  *     we need to (e.g. SA_SIGINFO was requested).
1.29      cgd       550:  */
1.243     ad        551: void
                    552: sigput(sigpend_t *sp, struct proc *p, ksiginfo_t *ksi)
1.48      thorpej   553: {
1.243     ad        554:        ksiginfo_t *kp;
                    555:        struct sigaction *sa = &SIGACTION_PS(p->p_sigacts, ksi->ksi_signo);
                    556:
1.277     ad        557:        KASSERT(mutex_owned(p->p_lock));
1.243     ad        558:        KASSERT((ksi->ksi_flags & KSI_QUEUED) == 0);
                    559:
                    560:        sigaddset(&sp->sp_set, ksi->ksi_signo);
                    561:
                    562:        /*
                    563:         * If siginfo is not required, or there is none, then just mark the
                    564:         * signal as pending.
                    565:         */
                    566:        if ((sa->sa_flags & SA_SIGINFO) == 0 || KSI_EMPTY_P(ksi))
                    567:                return;
                    568:
                    569:        KASSERT((ksi->ksi_flags & KSI_FROMPOOL) != 0);
1.79      mycroft   570:
1.243     ad        571: #ifdef notyet  /* XXX: QUEUING */
                    572:        if (ksi->ksi_signo < SIGRTMIN)
                    573: #endif
                    574:        {
                    575:                CIRCLEQ_FOREACH(kp, &sp->sp_info, ksi_list) {
                    576:                        if (kp->ksi_signo == ksi->ksi_signo) {
                    577:                                KSI_COPY(ksi, kp);
                    578:                                kp->ksi_flags |= KSI_QUEUED;
                    579:                                return;
                    580:                        }
                    581:                }
1.79      mycroft   582:        }
                    583:
1.243     ad        584:        ksi->ksi_flags |= KSI_QUEUED;
                    585:        CIRCLEQ_INSERT_TAIL(&sp->sp_info, ksi, ksi_list);
1.79      mycroft   586: }
                    587:
1.243     ad        588: /*
                    589:  * sigclear:
                    590:  *
                    591:  *     Clear all pending signals in the specified set.
                    592:  */
                    593: void
1.270     yamt      594: sigclear(sigpend_t *sp, const sigset_t *mask, ksiginfoq_t *kq)
1.79      mycroft   595: {
1.243     ad        596:        ksiginfo_t *ksi, *next;
1.112     lukem     597:
1.243     ad        598:        if (mask == NULL)
                    599:                sigemptyset(&sp->sp_set);
                    600:        else
                    601:                sigminusset(mask, &sp->sp_set);
1.79      mycroft   602:
1.243     ad        603:        ksi = CIRCLEQ_FIRST(&sp->sp_info);
                    604:        for (; ksi != (void *)&sp->sp_info; ksi = next) {
                    605:                next = CIRCLEQ_NEXT(ksi, ksi_list);
                    606:                if (mask == NULL || sigismember(mask, ksi->ksi_signo)) {
                    607:                        CIRCLEQ_REMOVE(&sp->sp_info, ksi, ksi_list);
                    608:                        KASSERT((ksi->ksi_flags & KSI_FROMPOOL) != 0);
                    609:                        KASSERT((ksi->ksi_flags & KSI_QUEUED) != 0);
                    610:                        CIRCLEQ_INSERT_TAIL(kq, ksi, ksi_list);
1.79      mycroft   611:                }
                    612:        }
1.243     ad        613: }
                    614:
                    615: /*
                    616:  * sigclearall:
                    617:  *
                    618:  *     Clear all pending signals in the specified set from a process and
                    619:  *     its LWPs.
                    620:  */
                    621: void
1.270     yamt      622: sigclearall(struct proc *p, const sigset_t *mask, ksiginfoq_t *kq)
1.243     ad        623: {
                    624:        struct lwp *l;
                    625:
1.277     ad        626:        KASSERT(mutex_owned(p->p_lock));
1.79      mycroft   627:
1.243     ad        628:        sigclear(&p->p_sigpend, mask, kq);
                    629:
                    630:        LIST_FOREACH(l, &p->p_lwps, l_sibling) {
                    631:                sigclear(&l->l_sigpend, mask, kq);
                    632:        }
1.29      cgd       633: }
                    634:
1.243     ad        635: /*
                    636:  * sigispending:
                    637:  *
                    638:  *     Return true if there are pending signals for the current LWP.  May
1.269     yamt      639:  *     be called unlocked provided that LW_PENDSIG is set, and that the
                    640:  *     signal has been posted to the appopriate queue before LW_PENDSIG is
1.243     ad        641:  *     set.
                    642:  */
1.52      christos  643: int
1.243     ad        644: sigispending(struct lwp *l, int signo)
1.48      thorpej   645: {
1.243     ad        646:        struct proc *p = l->l_proc;
                    647:        sigset_t tset;
                    648:
1.260     ad        649:        membar_consumer();
1.243     ad        650:
                    651:        tset = l->l_sigpend.sp_set;
                    652:        sigplusset(&p->p_sigpend.sp_set, &tset);
                    653:        sigminusset(&p->p_sigctx.ps_sigignore, &tset);
                    654:        sigminusset(&l->l_sigmask, &tset);
                    655:
                    656:        if (signo == 0) {
                    657:                if (firstsig(&tset) != 0)
                    658:                        return EINTR;
                    659:        } else if (sigismember(&tset, signo))
                    660:                return EINTR;
                    661:
                    662:        return 0;
                    663: }
                    664:
                    665: /*
                    666:  * siginfo_alloc:
                    667:  *
                    668:  *      Allocate a new siginfo_t structure from the pool.
                    669:  */
                    670: siginfo_t *
                    671: siginfo_alloc(int flags)
                    672: {
                    673:
                    674:        return pool_get(&siginfo_pool, flags);
                    675: }
                    676:
                    677: /*
                    678:  * siginfo_free:
                    679:  *
                    680:  *      Return a siginfo_t structure to the pool.
                    681:  */
                    682: void
                    683: siginfo_free(void *arg)
                    684: {
                    685:
                    686:        pool_put(&siginfo_pool, arg);
                    687: }
                    688:
                    689: void
                    690: getucontext(struct lwp *l, ucontext_t *ucp)
                    691: {
                    692:        struct proc *p = l->l_proc;
                    693:
1.277     ad        694:        KASSERT(mutex_owned(p->p_lock));
1.243     ad        695:
                    696:        ucp->uc_flags = 0;
                    697:        ucp->uc_link = l->l_ctxlink;
                    698:
                    699:        ucp->uc_sigmask = l->l_sigmask;
                    700:        ucp->uc_flags |= _UC_SIGMASK;
                    701:
                    702:        /*
                    703:         * The (unsupplied) definition of the `current execution stack'
                    704:         * in the System V Interface Definition appears to allow returning
                    705:         * the main context stack.
                    706:         */
                    707:        if ((l->l_sigstk.ss_flags & SS_ONSTACK) == 0) {
1.263     christos  708:                ucp->uc_stack.ss_sp = (void *)l->l_proc->p_stackbase;
1.243     ad        709:                ucp->uc_stack.ss_size = ctob(l->l_proc->p_vmspace->vm_ssize);
                    710:                ucp->uc_stack.ss_flags = 0;     /* XXX, def. is Very Fishy */
                    711:        } else {
                    712:                /* Simply copy alternate signal execution stack. */
                    713:                ucp->uc_stack = l->l_sigstk;
1.79      mycroft   714:        }
1.243     ad        715:        ucp->uc_flags |= _UC_STACK;
1.277     ad        716:        mutex_exit(p->p_lock);
1.243     ad        717:        cpu_getmcontext(l, &ucp->uc_mcontext, &ucp->uc_flags);
1.277     ad        718:        mutex_enter(p->p_lock);
1.29      cgd       719: }
                    720:
                    721: int
1.243     ad        722: setucontext(struct lwp *l, const ucontext_t *ucp)
1.48      thorpej   723: {
1.243     ad        724:        struct proc *p = l->l_proc;
1.223     yamt      725:        int error;
1.29      cgd       726:
1.277     ad        727:        KASSERT(mutex_owned(p->p_lock));
1.243     ad        728:
                    729:        if ((ucp->uc_flags & _UC_SIGMASK) != 0) {
                    730:                error = sigprocmask1(l, SIG_SETMASK, &ucp->uc_sigmask, NULL);
                    731:                if (error != 0)
1.223     yamt      732:                        return error;
1.29      cgd       733:        }
1.243     ad        734:
1.277     ad        735:        mutex_exit(p->p_lock);
1.243     ad        736:        error = cpu_setmcontext(l, &ucp->uc_mcontext, ucp->uc_flags);
1.277     ad        737:        mutex_enter(p->p_lock);
1.243     ad        738:        if (error != 0)
                    739:                return (error);
                    740:
                    741:        l->l_ctxlink = ucp->uc_link;
                    742:
                    743:        /*
                    744:         * If there was stack information, update whether or not we are
                    745:         * still running on an alternate signal stack.
                    746:         */
                    747:        if ((ucp->uc_flags & _UC_STACK) != 0) {
                    748:                if (ucp->uc_stack.ss_flags & SS_ONSTACK)
                    749:                        l->l_sigstk.ss_flags |= SS_ONSTACK;
                    750:                else
                    751:                        l->l_sigstk.ss_flags &= ~SS_ONSTACK;
                    752:        }
                    753:
                    754:        return 0;
1.29      cgd       755: }
                    756:
                    757: /*
1.243     ad        758:  * Common code for kill process group/broadcast kill.  cp is calling
                    759:  * process.
1.29      cgd       760:  */
1.52      christos  761: int
1.224     ad        762: killpg1(struct lwp *l, ksiginfo_t *ksi, int pgid, int all)
1.29      cgd       763: {
1.224     ad        764:        struct proc     *p, *cp;
1.220     elad      765:        kauth_cred_t    pc;
1.112     lukem     766:        struct pgrp     *pgrp;
                    767:        int             nfound;
1.243     ad        768:        int             signo = ksi->ksi_signo;
1.202     perry     769:
1.224     ad        770:        cp = l->l_proc;
                    771:        pc = l->l_cred;
1.112     lukem     772:        nfound = 0;
1.243     ad        773:
1.276     ad        774:        mutex_enter(proc_lock);
1.91      thorpej   775:        if (all) {
1.202     perry     776:                /*
                    777:                 * broadcast
1.29      cgd       778:                 */
1.199     yamt      779:                PROCLIST_FOREACH(p, &allproc) {
1.246     pavel     780:                        if (p->p_pid <= 1 || p->p_flag & PK_SYSTEM || p == cp)
1.29      cgd       781:                                continue;
1.277     ad        782:                        mutex_enter(p->p_lock);
1.243     ad        783:                        if (kauth_authorize_process(pc,
1.264     elad      784:                            KAUTH_PROCESS_SIGNAL, p, KAUTH_ARG(signo), NULL,
                    785:                            NULL) == 0) {
1.243     ad        786:                                nfound++;
1.277     ad        787:                                if (signo)
1.243     ad        788:                                        kpsignal2(p, ksi);
                    789:                        }
1.277     ad        790:                        mutex_exit(p->p_lock);
1.29      cgd       791:                }
1.91      thorpej   792:        } else {
1.202     perry     793:                if (pgid == 0)
                    794:                        /*
1.29      cgd       795:                         * zero pgid means send to my process group.
                    796:                         */
                    797:                        pgrp = cp->p_pgrp;
                    798:                else {
1.243     ad        799:                        pgrp = pg_find(pgid, PFIND_LOCKED);
1.29      cgd       800:                        if (pgrp == NULL)
1.243     ad        801:                                goto out;
1.29      cgd       802:                }
1.124     matt      803:                LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
1.246     pavel     804:                        if (p->p_pid <= 1 || p->p_flag & PK_SYSTEM)
1.29      cgd       805:                                continue;
1.277     ad        806:                        mutex_enter(p->p_lock);
1.264     elad      807:                        if (kauth_authorize_process(pc, KAUTH_PROCESS_SIGNAL,
                    808:                            p, KAUTH_ARG(signo), NULL, NULL) == 0) {
1.243     ad        809:                                nfound++;
1.277     ad        810:                                if (signo && P_ZOMBIE(p) == 0)
                    811:                                        kpsignal2(p, ksi);
1.243     ad        812:                        }
1.277     ad        813:                        mutex_exit(p->p_lock);
1.29      cgd       814:                }
                    815:        }
1.243     ad        816:   out:
1.276     ad        817:        mutex_exit(proc_lock);
1.29      cgd       818:        return (nfound ? 0 : ESRCH);
                    819: }
                    820:
                    821: /*
1.243     ad        822:  * Send a signal to a process group. If checktty is 1, limit to members
                    823:  * which have a controlling terminal.
1.29      cgd       824:  */
                    825: void
1.243     ad        826: pgsignal(struct pgrp *pgrp, int sig, int checkctty)
1.29      cgd       827: {
1.148     christos  828:        ksiginfo_t ksi;
                    829:
1.276     ad        830:        KASSERT(!cpu_intr_p());
                    831:        KASSERT(mutex_owned(proc_lock));
1.29      cgd       832:
1.192     matt      833:        KSI_INIT_EMPTY(&ksi);
1.148     christos  834:        ksi.ksi_signo = sig;
                    835:        kpgsignal(pgrp, &ksi, NULL, checkctty);
                    836: }
                    837:
                    838: void
                    839: kpgsignal(struct pgrp *pgrp, ksiginfo_t *ksi, void *data, int checkctty)
1.29      cgd       840: {
1.98      augustss  841:        struct proc *p;
1.29      cgd       842:
1.276     ad        843:        KASSERT(!cpu_intr_p());
                    844:        KASSERT(mutex_owned(proc_lock));
1.243     ad        845:
1.29      cgd       846:        if (pgrp)
1.124     matt      847:                LIST_FOREACH(p, &pgrp->pg_members, p_pglist)
1.243     ad        848:                        if (checkctty == 0 || p->p_lflag & PL_CONTROLT)
1.148     christos  849:                                kpsignal(p, ksi, data);
1.29      cgd       850: }
                    851:
                    852: /*
1.243     ad        853:  * Send a signal caused by a trap to the current LWP.  If it will be caught
                    854:  * immediately, deliver it with correct code.  Otherwise, post it normally.
1.29      cgd       855:  */
1.148     christos  856: void
1.243     ad        857: trapsignal(struct lwp *l, ksiginfo_t *ksi)
1.148     christos  858: {
1.130     thorpej   859:        struct proc     *p;
                    860:        struct sigacts  *ps;
1.243     ad        861:        int signo = ksi->ksi_signo;
1.29      cgd       862:
1.166     thorpej   863:        KASSERT(KSI_TRAP_P(ksi));
                    864:
1.243     ad        865:        ksi->ksi_lid = l->l_lid;
1.130     thorpej   866:        p = l->l_proc;
1.243     ad        867:
1.276     ad        868:        KASSERT(!cpu_intr_p());
                    869:        mutex_enter(proc_lock);
1.277     ad        870:        mutex_enter(p->p_lock);
1.112     lukem     871:        ps = p->p_sigacts;
1.243     ad        872:        if ((p->p_slflag & PSL_TRACED) == 0 &&
                    873:            sigismember(&p->p_sigctx.ps_sigcatch, signo) &&
                    874:            !sigismember(&l->l_sigmask, signo)) {
1.276     ad        875:                mutex_exit(proc_lock);
1.275     ad        876:                l->l_ru.ru_nsignals++;
1.243     ad        877:                kpsendsig(l, ksi, &l->l_sigmask);
1.277     ad        878:                mutex_exit(p->p_lock);
1.255     ad        879:                ktrpsig(signo, SIGACTION_PS(ps, signo).sa_handler,
                    880:                    &l->l_sigmask, ksi);
1.29      cgd       881:        } else {
1.243     ad        882:                /* XXX for core dump/debugger */
1.152     christos  883:                p->p_sigctx.ps_lwp = l->l_lid;
                    884:                p->p_sigctx.ps_signo = ksi->ksi_signo;
                    885:                p->p_sigctx.ps_code = ksi->ksi_trap;
1.234     yamt      886:                kpsignal2(p, ksi);
1.277     ad        887:                mutex_exit(p->p_lock);
1.276     ad        888:                mutex_exit(proc_lock);
1.29      cgd       889:        }
                    890: }
                    891:
                    892: /*
1.151     christos  893:  * Fill in signal information and signal the parent for a child status change.
                    894:  */
1.216     christos  895: void
1.243     ad        896: child_psignal(struct proc *p, int mask)
1.151     christos  897: {
                    898:        ksiginfo_t ksi;
1.243     ad        899:        struct proc *q;
                    900:        int xstat;
                    901:
1.276     ad        902:        KASSERT(mutex_owned(proc_lock));
1.277     ad        903:        KASSERT(mutex_owned(p->p_lock));
1.243     ad        904:
                    905:        xstat = p->p_xstat;
1.151     christos  906:
1.191     matt      907:        KSI_INIT(&ksi);
1.151     christos  908:        ksi.ksi_signo = SIGCHLD;
1.243     ad        909:        ksi.ksi_code = (xstat == SIGCONT ? CLD_CONTINUED : CLD_STOPPED);
1.151     christos  910:        ksi.ksi_pid = p->p_pid;
1.220     elad      911:        ksi.ksi_uid = kauth_cred_geteuid(p->p_cred);
1.243     ad        912:        ksi.ksi_status = xstat;
1.151     christos  913:        ksi.ksi_utime = p->p_stats->p_ru.ru_utime.tv_sec;
                    914:        ksi.ksi_stime = p->p_stats->p_ru.ru_stime.tv_sec;
1.243     ad        915:
                    916:        q = p->p_pptr;
                    917:
1.277     ad        918:        mutex_exit(p->p_lock);
                    919:        mutex_enter(q->p_lock);
1.243     ad        920:
                    921:        if ((q->p_sflag & mask) == 0)
                    922:                kpsignal2(q, &ksi);
                    923:
1.277     ad        924:        mutex_exit(q->p_lock);
                    925:        mutex_enter(p->p_lock);
1.151     christos  926: }
                    927:
1.29      cgd       928: void
1.243     ad        929: psignal(struct proc *p, int signo)
1.148     christos  930: {
1.165     thorpej   931:        ksiginfo_t ksi;
                    932:
1.276     ad        933:        KASSERT(!cpu_intr_p());
                    934:        KASSERT(mutex_owned(proc_lock));
1.243     ad        935:
1.192     matt      936:        KSI_INIT_EMPTY(&ksi);
1.243     ad        937:        ksi.ksi_signo = signo;
1.277     ad        938:        mutex_enter(p->p_lock);
1.234     yamt      939:        kpsignal2(p, &ksi);
1.277     ad        940:        mutex_exit(p->p_lock);
1.148     christos  941: }
                    942:
                    943: void
1.234     yamt      944: kpsignal(struct proc *p, ksiginfo_t *ksi, void *data)
1.160     christos  945: {
1.274     ad        946:        fdfile_t *ff;
                    947:        file_t *fp;
1.165     thorpej   948:
1.276     ad        949:        KASSERT(!cpu_intr_p());
                    950:        KASSERT(mutex_owned(proc_lock));
1.243     ad        951:
                    952:        if ((p->p_sflag & PS_WEXIT) == 0 && data) {
1.160     christos  953:                size_t fd;
1.274     ad        954:                filedesc_t *fdp = p->p_fd;
1.165     thorpej   955:
1.274     ad        956:                /* XXXSMP locking */
1.160     christos  957:                ksi->ksi_fd = -1;
                    958:                for (fd = 0; fd < fdp->fd_nfiles; fd++) {
1.274     ad        959:                        if ((ff = fdp->fd_ofiles[fd]) == NULL)
                    960:                                continue;
                    961:                        if ((fp = ff->ff_file) == NULL)
                    962:                                continue;
                    963:                        if (fp->f_data == data) {
1.160     christos  964:                                ksi->ksi_fd = fd;
                    965:                                break;
                    966:                        }
                    967:                }
                    968:        }
1.277     ad        969:        mutex_enter(p->p_lock);
1.234     yamt      970:        kpsignal2(p, ksi);
1.277     ad        971:        mutex_exit(p->p_lock);
1.160     christos  972: }
                    973:
1.243     ad        974: /*
                    975:  * sigismasked:
                    976:  *
                    977:  *      Returns true if signal is ignored or masked for the specified LWP.
                    978:  */
                    979: int
                    980: sigismasked(struct lwp *l, int sig)
1.29      cgd       981: {
1.243     ad        982:        struct proc *p = l->l_proc;
                    983:
                    984:        return (sigismember(&p->p_sigctx.ps_sigignore, sig) ||
                    985:            sigismember(&l->l_sigmask, sig));
                    986: }
1.29      cgd       987:
1.243     ad        988: /*
                    989:  * sigpost:
                    990:  *
                    991:  *      Post a pending signal to an LWP.  Returns non-zero if the LWP was
                    992:  *      able to take the signal.
                    993:  */
                    994: int
                    995: sigpost(struct lwp *l, sig_t action, int prop, int sig)
                    996: {
                    997:        int rv, masked;
1.148     christos  998:
1.277     ad        999:        KASSERT(mutex_owned(l->l_proc->p_lock));
1.148     christos 1000:
1.183     fvdl     1001:        /*
1.243     ad       1002:         * If the LWP is on the way out, sigclear() will be busy draining all
                   1003:         * pending signals.  Don't give it more.
1.126     jdolecek 1004:         */
1.243     ad       1005:        if (l->l_refcnt == 0)
                   1006:                return 0;
                   1007:
                   1008:        lwp_lock(l);
1.126     jdolecek 1009:
1.243     ad       1010:        /*
                   1011:         * Have the LWP check for signals.  This ensures that even if no LWP
                   1012:         * is found to take the signal immediately, it should be taken soon.
                   1013:         */
1.246     pavel    1014:        l->l_flag |= LW_PENDSIG;
1.29      cgd      1015:
                   1016:        /*
1.243     ad       1017:         * SIGCONT can be masked, but must always restart stopped LWPs.
1.29      cgd      1018:         */
1.243     ad       1019:        masked = sigismember(&l->l_sigmask, sig);
                   1020:        if (masked && ((prop & SA_CONT) == 0 || l->l_stat != LSSTOP)) {
                   1021:                lwp_unlock(l);
                   1022:                return 0;
                   1023:        }
1.198     jdolecek 1024:
1.243     ad       1025:        /*
1.247     ad       1026:         * If killing the process, make it run fast.
                   1027:         */
                   1028:        if (__predict_false((prop & SA_KILL) != 0) &&
1.266     rmind    1029:            action == SIG_DFL && l->l_priority < MAXPRI_USER) {
                   1030:                KASSERT(l->l_class == SCHED_OTHER);
                   1031:                lwp_changepri(l, MAXPRI_USER);
                   1032:        }
1.247     ad       1033:
                   1034:        /*
1.243     ad       1035:         * If the LWP is running or on a run queue, then we win.  If it's
                   1036:         * sleeping interruptably, wake it and make it take the signal.  If
                   1037:         * the sleep isn't interruptable, then the chances are it will get
                   1038:         * to see the signal soon anyhow.  If suspended, it can't take the
                   1039:         * signal right now.  If it's LWP private or for all LWPs, save it
                   1040:         * for later; otherwise punt.
                   1041:         */
                   1042:        rv = 0;
                   1043:
                   1044:        switch (l->l_stat) {
                   1045:        case LSRUN:
                   1046:        case LSONPROC:
                   1047:                lwp_need_userret(l);
                   1048:                rv = 1;
                   1049:                break;
                   1050:
                   1051:        case LSSLEEP:
1.246     pavel    1052:                if ((l->l_flag & LW_SINTR) != 0) {
1.243     ad       1053:                        /* setrunnable() will release the lock. */
                   1054:                        setrunnable(l);
                   1055:                        return 1;
1.232     mrg      1056:                }
1.243     ad       1057:                break;
                   1058:
                   1059:        case LSSUSPENDED:
                   1060:                if ((prop & SA_KILL) != 0) {
                   1061:                        /* lwp_continue() will release the lock. */
                   1062:                        lwp_continue(l);
                   1063:                        return 1;
1.190     matt     1064:                }
1.243     ad       1065:                break;
                   1066:
                   1067:        case LSSTOP:
                   1068:                if ((prop & SA_STOP) != 0)
                   1069:                        break;
1.198     jdolecek 1070:
                   1071:                /*
1.243     ad       1072:                 * If the LWP is stopped and we are sending a continue
                   1073:                 * signal, then start it again.
1.198     jdolecek 1074:                 */
1.243     ad       1075:                if ((prop & SA_CONT) != 0) {
                   1076:                        if (l->l_wchan != NULL) {
                   1077:                                l->l_stat = LSSLEEP;
                   1078:                                l->l_proc->p_nrlwps++;
                   1079:                                rv = 1;
                   1080:                                break;
                   1081:                        }
                   1082:                        /* setrunnable() will release the lock. */
                   1083:                        setrunnable(l);
                   1084:                        return 1;
1.246     pavel    1085:                } else if (l->l_wchan == NULL || (l->l_flag & LW_SINTR) != 0) {
1.243     ad       1086:                        /* setrunnable() will release the lock. */
                   1087:                        setrunnable(l);
                   1088:                        return 1;
                   1089:                }
                   1090:                break;
1.198     jdolecek 1091:
1.243     ad       1092:        default:
                   1093:                break;
                   1094:        }
1.44      mycroft  1095:
1.243     ad       1096:        lwp_unlock(l);
                   1097:        return rv;
                   1098: }
1.29      cgd      1099:
1.243     ad       1100: /*
                   1101:  * Notify an LWP that it has a pending signal.
                   1102:  */
                   1103: void
                   1104: signotify(struct lwp *l)
                   1105: {
1.250     ad       1106:        KASSERT(lwp_locked(l, NULL));
1.29      cgd      1107:
1.246     pavel    1108:        l->l_flag |= LW_PENDSIG;
1.243     ad       1109:        lwp_need_userret(l);
                   1110: }
1.44      mycroft  1111:
1.243     ad       1112: /*
                   1113:  * Find an LWP within process p that is waiting on signal ksi, and hand
                   1114:  * it on.
                   1115:  */
                   1116: int
                   1117: sigunwait(struct proc *p, const ksiginfo_t *ksi)
                   1118: {
                   1119:        struct lwp *l;
                   1120:        int signo;
1.135     jdolecek 1121:
1.277     ad       1122:        KASSERT(mutex_owned(p->p_lock));
1.171     jdolecek 1123:
1.243     ad       1124:        signo = ksi->ksi_signo;
                   1125:
                   1126:        if (ksi->ksi_lid != 0) {
                   1127:                /*
                   1128:                 * Signal came via _lwp_kill().  Find the LWP and see if
                   1129:                 * it's interested.
                   1130:                 */
                   1131:                if ((l = lwp_find(p, ksi->ksi_lid)) == NULL)
                   1132:                        return 0;
                   1133:                if (l->l_sigwaited == NULL ||
                   1134:                    !sigismember(&l->l_sigwaitset, signo))
                   1135:                        return 0;
                   1136:        } else {
                   1137:                /*
                   1138:                 * Look for any LWP that may be interested.
                   1139:                 */
                   1140:                LIST_FOREACH(l, &p->p_sigwaiters, l_sigwaiter) {
                   1141:                        KASSERT(l->l_sigwaited != NULL);
                   1142:                        if (sigismember(&l->l_sigwaitset, signo))
                   1143:                                break;
                   1144:                }
                   1145:        }
                   1146:
                   1147:        if (l != NULL) {
                   1148:                l->l_sigwaited->ksi_info = ksi->ksi_info;
                   1149:                l->l_sigwaited = NULL;
                   1150:                LIST_REMOVE(l, l_sigwaiter);
                   1151:                cv_signal(&l->l_sigcv);
                   1152:                return 1;
                   1153:        }
                   1154:
                   1155:        return 0;
                   1156: }
                   1157:
                   1158: /*
                   1159:  * Send the signal to the process.  If the signal has an action, the action
                   1160:  * is usually performed by the target process rather than the caller; we add
                   1161:  * the signal to the set of pending signals for the process.
                   1162:  *
                   1163:  * Exceptions:
                   1164:  *   o When a stop signal is sent to a sleeping process that takes the
                   1165:  *     default action, the process is stopped without awakening it.
                   1166:  *   o SIGCONT restarts stopped processes (or puts them back to sleep)
                   1167:  *     regardless of the signal action (eg, blocked or ignored).
                   1168:  *
                   1169:  * Other ignored signals are discarded immediately.
                   1170:  */
                   1171: void
                   1172: kpsignal2(struct proc *p, ksiginfo_t *ksi)
                   1173: {
                   1174:        int prop, lid, toall, signo = ksi->ksi_signo;
1.259     ad       1175:        struct sigacts *sa;
1.243     ad       1176:        struct lwp *l;
                   1177:        ksiginfo_t *kp;
                   1178:        ksiginfoq_t kq;
                   1179:        sig_t action;
                   1180:
1.276     ad       1181:        KASSERT(!cpu_intr_p());
                   1182:        KASSERT(mutex_owned(proc_lock));
1.277     ad       1183:        KASSERT(mutex_owned(p->p_lock));
1.243     ad       1184:        KASSERT((ksi->ksi_flags & KSI_QUEUED) == 0);
                   1185:        KASSERT(signo > 0 && signo < NSIG);
1.171     jdolecek 1186:
1.135     jdolecek 1187:        /*
1.243     ad       1188:         * If the process is being created by fork, is a zombie or is
                   1189:         * exiting, then just drop the signal here and bail out.
1.29      cgd      1190:         */
1.243     ad       1191:        if (p->p_stat != SACTIVE && p->p_stat != SSTOP)
1.231     mrg      1192:                return;
                   1193:
                   1194:        /*
1.243     ad       1195:         * Notify any interested parties of the signal.
                   1196:         */
                   1197:        KNOTE(&p->p_klist, NOTE_SIGNAL | signo);
                   1198:
                   1199:        /*
                   1200:         * Some signals including SIGKILL must act on the entire process.
1.231     mrg      1201:         */
1.243     ad       1202:        kp = NULL;
                   1203:        prop = sigprop[signo];
                   1204:        toall = ((prop & SA_TOALL) != 0);
                   1205:
                   1206:        if (toall)
                   1207:                lid = 0;
                   1208:        else
                   1209:                lid = ksi->ksi_lid;
1.231     mrg      1210:
1.243     ad       1211:        /*
                   1212:         * If proc is traced, always give parent a chance.
                   1213:         */
                   1214:        if (p->p_slflag & PSL_TRACED) {
                   1215:                action = SIG_DFL;
1.104     thorpej  1216:
1.243     ad       1217:                if (lid == 0) {
                   1218:                        /*
                   1219:                         * If the process is being traced and the signal
                   1220:                         * is being caught, make sure to save any ksiginfo.
                   1221:                         */
                   1222:                        if ((kp = ksiginfo_alloc(p, ksi, PR_NOWAIT)) == NULL)
                   1223:                                return;
                   1224:                        sigput(&p->p_sigpend, p, kp);
                   1225:                }
                   1226:        } else {
                   1227:                /*
                   1228:                 * If the signal was the result of a trap and is not being
                   1229:                 * caught, then reset it to default action so that the
                   1230:                 * process dumps core immediately.
                   1231:                 */
                   1232:                if (KSI_TRAP_P(ksi)) {
1.259     ad       1233:                        sa = p->p_sigacts;
                   1234:                        mutex_enter(&sa->sa_mutex);
1.243     ad       1235:                        if (!sigismember(&p->p_sigctx.ps_sigcatch, signo)) {
                   1236:                                sigdelset(&p->p_sigctx.ps_sigignore, signo);
                   1237:                                SIGACTION(p, signo).sa_handler = SIG_DFL;
1.187     cl       1238:                        }
1.259     ad       1239:                        mutex_exit(&sa->sa_mutex);
1.175     cl       1240:                }
1.243     ad       1241:
1.29      cgd      1242:                /*
1.243     ad       1243:                 * If the signal is being ignored, then drop it.  Note: we
                   1244:                 * don't set SIGCONT in ps_sigignore, and if it is set to
                   1245:                 * SIG_IGN, action will be SIG_DFL here.
1.29      cgd      1246:                 */
1.243     ad       1247:                if (sigismember(&p->p_sigctx.ps_sigignore, signo))
                   1248:                        return;
                   1249:
                   1250:                else if (sigismember(&p->p_sigctx.ps_sigcatch, signo))
                   1251:                        action = SIG_CATCH;
                   1252:                else {
                   1253:                        action = SIG_DFL;
                   1254:
                   1255:                        /*
                   1256:                         * If sending a tty stop signal to a member of an
                   1257:                         * orphaned process group, discard the signal here if
                   1258:                         * the action is default; don't stop the process below
                   1259:                         * if sleeping, and don't clear any pending SIGCONT.
                   1260:                         */
1.276     ad       1261:                        if (prop & SA_TTYSTOP && p->p_pgrp->pg_jobc == 0)
1.243     ad       1262:                                return;
                   1263:
                   1264:                        if (prop & SA_KILL && p->p_nice > NZERO)
                   1265:                                p->p_nice = NZERO;
1.29      cgd      1266:                }
1.175     cl       1267:        }
                   1268:
1.243     ad       1269:        /*
                   1270:         * If stopping or continuing a process, discard any pending
                   1271:         * signals that would do the inverse.
                   1272:         */
                   1273:        if ((prop & (SA_CONT | SA_STOP)) != 0) {
                   1274:                ksiginfo_queue_init(&kq);
                   1275:                if ((prop & SA_CONT) != 0)
                   1276:                        sigclear(&p->p_sigpend, &stopsigmask, &kq);
                   1277:                if ((prop & SA_STOP) != 0)
                   1278:                        sigclear(&p->p_sigpend, &contsigmask, &kq);
                   1279:                ksiginfo_queue_drain(&kq);      /* XXXSMP */
                   1280:        }
                   1281:
                   1282:        /*
                   1283:         * If the signal doesn't have SA_CANTMASK (no override for SIGKILL,
                   1284:         * please!), check if any LWPs are waiting on it.  If yes, pass on
                   1285:         * the signal info.  The signal won't be processed further here.
                   1286:         */
                   1287:        if ((prop & SA_CANTMASK) == 0 && !LIST_EMPTY(&p->p_sigwaiters) &&
                   1288:            p->p_stat == SACTIVE && (p->p_sflag & PS_STOPPING) == 0 &&
                   1289:            sigunwait(p, ksi))
                   1290:                return;
                   1291:
                   1292:        /*
                   1293:         * XXXSMP Should be allocated by the caller, we're holding locks
                   1294:         * here.
                   1295:         */
                   1296:        if (kp == NULL && (kp = ksiginfo_alloc(p, ksi, PR_NOWAIT)) == NULL)
                   1297:                return;
                   1298:
                   1299:        /*
                   1300:         * LWP private signals are easy - just find the LWP and post
                   1301:         * the signal to it.
                   1302:         */
                   1303:        if (lid != 0) {
                   1304:                l = lwp_find(p, lid);
                   1305:                if (l != NULL) {
                   1306:                        sigput(&l->l_sigpend, p, kp);
1.260     ad       1307:                        membar_producer();
1.243     ad       1308:                        (void)sigpost(l, action, prop, kp->ksi_signo);
                   1309:                }
                   1310:                goto out;
                   1311:        }
1.130     thorpej  1312:
1.243     ad       1313:        /*
1.250     ad       1314:         * Some signals go to all LWPs, even if posted with _lwp_kill().
1.243     ad       1315:         */
                   1316:        if (p->p_stat == SACTIVE && (p->p_sflag & PS_STOPPING) == 0) {
                   1317:                if ((p->p_slflag & PSL_TRACED) != 0)
                   1318:                        goto deliver;
1.202     perry    1319:
1.176     cl       1320:                /*
                   1321:                 * If SIGCONT is default (or ignored) and process is
                   1322:                 * asleep, we are finished; the process should not
                   1323:                 * be awakened.
                   1324:                 */
1.243     ad       1325:                if ((prop & SA_CONT) != 0 && action == SIG_DFL)
                   1326:                        goto out;
1.176     cl       1327:
1.273     yamt     1328:                sigput(&p->p_sigpend, p, kp);
1.243     ad       1329:        } else {
1.176     cl       1330:                /*
1.250     ad       1331:                 * Process is stopped or stopping.  If traced, then no
                   1332:                 * further action is necessary.
1.176     cl       1333:                 */
1.243     ad       1334:                if ((p->p_slflag & PSL_TRACED) != 0 && signo != SIGKILL)
                   1335:                        goto out;
1.29      cgd      1336:
1.243     ad       1337:                if ((prop & (SA_CONT | SA_KILL)) != 0) {
                   1338:                        /*
                   1339:                         * Re-adjust p_nstopchild if the process wasn't
                   1340:                         * collected by its parent.
                   1341:                         */
                   1342:                        p->p_stat = SACTIVE;
                   1343:                        p->p_sflag &= ~PS_STOPPING;
                   1344:                        if (!p->p_waited)
                   1345:                                p->p_pptr->p_nstopchild--;
1.202     perry    1346:
1.29      cgd      1347:                        /*
1.243     ad       1348:                         * If SIGCONT is default (or ignored), we continue
                   1349:                         * the process but don't leave the signal in
                   1350:                         * ps_siglist, as it has no further action.  If
                   1351:                         * SIGCONT is held, we continue the process and
                   1352:                         * leave the signal in ps_siglist.  If the process
                   1353:                         * catches SIGCONT, let it handle the signal itself.
                   1354:                         * If it isn't waiting on an event, then it goes
                   1355:                         * back to run state.  Otherwise, process goes back
                   1356:                         * to sleep state.
1.29      cgd      1357:                         */
1.243     ad       1358:                        if ((prop & SA_CONT) == 0 || action != SIG_DFL)
                   1359:                                sigput(&p->p_sigpend, p, kp);
                   1360:                } else if ((prop & SA_STOP) != 0) {
1.29      cgd      1361:                        /*
1.176     cl       1362:                         * Already stopped, don't need to stop again.
                   1363:                         * (If we did the shell could get confused.)
1.29      cgd      1364:                         */
1.243     ad       1365:                        goto out;
                   1366:                } else
                   1367:                        sigput(&p->p_sigpend, p, kp);
                   1368:        }
1.176     cl       1369:
1.243     ad       1370:  deliver:
                   1371:        /*
1.271     yamt     1372:         * Before we set LW_PENDSIG on any LWP, ensure that the signal is
1.243     ad       1373:         * visible on the per process list (for sigispending()).  This
                   1374:         * is unlikely to be needed in practice, but...
                   1375:         */
1.260     ad       1376:        membar_producer();
1.29      cgd      1377:
                   1378:        /*
1.243     ad       1379:         * Try to find an LWP that can take the signal.
1.29      cgd      1380:         */
1.243     ad       1381:        LIST_FOREACH(l, &p->p_lwps, l_sibling)
                   1382:                if (sigpost(l, action, prop, kp->ksi_signo) && !toall)
                   1383:                        break;
1.202     perry    1384:
1.112     lukem    1385:  out:
1.243     ad       1386:        /*
1.250     ad       1387:         * If the ksiginfo wasn't used, then bin it.  XXXSMP freeing memory
                   1388:         * with locks held.  The caller should take care of this.
1.243     ad       1389:         */
                   1390:        ksiginfo_free(kp);
1.29      cgd      1391: }
                   1392:
1.243     ad       1393: void
                   1394: kpsendsig(struct lwp *l, const ksiginfo_t *ksi, const sigset_t *mask)
1.209     chs      1395: {
1.243     ad       1396:        struct proc *p = l->l_proc;
                   1397:
1.277     ad       1398:        KASSERT(mutex_owned(p->p_lock));
1.209     chs      1399:
1.243     ad       1400:        (*p->p_emul->e_sendsig)(ksi, mask);
1.209     chs      1401: }
                   1402:
1.243     ad       1403: /*
1.272     yamt     1404:  * Stop any LWPs sleeping interruptably.
                   1405:  */
                   1406: static void
                   1407: proc_stop_lwps(struct proc *p)
                   1408: {
                   1409:        struct lwp *l;
                   1410:
1.277     ad       1411:        KASSERT(mutex_owned(p->p_lock));
1.272     yamt     1412:        KASSERT((p->p_sflag & PS_STOPPING) != 0);
                   1413:
                   1414:        LIST_FOREACH(l, &p->p_lwps, l_sibling) {
                   1415:                lwp_lock(l);
                   1416:                if (l->l_stat == LSSLEEP && (l->l_flag & LW_SINTR) != 0) {
                   1417:                        l->l_stat = LSSTOP;
                   1418:                        p->p_nrlwps--;
                   1419:                }
                   1420:                lwp_unlock(l);
                   1421:        }
                   1422: }
                   1423:
                   1424: /*
                   1425:  * Finish stopping of a process.  Mark it stopped and notify the parent.
                   1426:  *
1.277     ad       1427:  * Drop p_lock briefly if PS_NOTIFYSTOP is set and ppsig is true.
1.272     yamt     1428:  */
                   1429: static void
                   1430: proc_stop_done(struct proc *p, bool ppsig, int ppmask)
                   1431: {
                   1432:
1.276     ad       1433:        KASSERT(mutex_owned(proc_lock));
1.277     ad       1434:        KASSERT(mutex_owned(p->p_lock));
1.272     yamt     1435:        KASSERT((p->p_sflag & PS_STOPPING) != 0);
                   1436:        KASSERT(p->p_nrlwps == 0 || (p->p_nrlwps == 1 && p == curproc));
                   1437:
                   1438:        p->p_sflag &= ~PS_STOPPING;
                   1439:        p->p_stat = SSTOP;
                   1440:        p->p_waited = 0;
                   1441:        p->p_pptr->p_nstopchild++;
                   1442:        if ((p->p_sflag & PS_NOTIFYSTOP) != 0) {
                   1443:                if (ppsig) {
1.277     ad       1444:                        /* child_psignal drops p_lock briefly. */
1.272     yamt     1445:                        child_psignal(p, ppmask);
                   1446:                }
                   1447:                cv_broadcast(&p->p_pptr->p_waitcv);
                   1448:        }
                   1449: }
                   1450:
                   1451: /*
1.243     ad       1452:  * Stop the current process and switch away when being stopped or traced.
                   1453:  */
1.209     chs      1454: void
1.248     thorpej  1455: sigswitch(bool ppsig, int ppmask, int signo)
1.209     chs      1456: {
1.272     yamt     1457:        struct lwp *l = curlwp;
1.243     ad       1458:        struct proc *p = l->l_proc;
1.245     ad       1459: #ifdef MULTIPROCESSOR
                   1460:        int biglocks;
                   1461: #endif
1.243     ad       1462:
1.277     ad       1463:        KASSERT(mutex_owned(p->p_lock));
1.250     ad       1464:        KASSERT(l->l_stat == LSONPROC);
                   1465:        KASSERT(p->p_nrlwps > 0);
1.243     ad       1466:
                   1467:        /*
                   1468:         * On entry we know that the process needs to stop.  If it's
                   1469:         * the result of a 'sideways' stop signal that has been sourced
                   1470:         * through issignal(), then stop other LWPs in the process too.
                   1471:         */
                   1472:        if (p->p_stat == SACTIVE && (p->p_sflag & PS_STOPPING) == 0) {
                   1473:                KASSERT(signo != 0);
1.272     yamt     1474:                proc_stop(p, 1, signo);
1.250     ad       1475:                KASSERT(p->p_nrlwps > 0);
1.243     ad       1476:        }
                   1477:
                   1478:        /*
                   1479:         * If we are the last live LWP, and the stop was a result of
                   1480:         * a new signal, then signal the parent.
                   1481:         */
                   1482:        if ((p->p_sflag & PS_STOPPING) != 0) {
1.276     ad       1483:                if (!mutex_tryenter(proc_lock)) {
1.277     ad       1484:                        mutex_exit(p->p_lock);
1.276     ad       1485:                        mutex_enter(proc_lock);
1.277     ad       1486:                        mutex_enter(p->p_lock);
1.243     ad       1487:                }
                   1488:
                   1489:                if (p->p_nrlwps == 1 && (p->p_sflag & PS_STOPPING) != 0) {
1.272     yamt     1490:                        /*
                   1491:                         * Note that proc_stop_done() can drop
1.277     ad       1492:                         * p->p_lock briefly.
1.272     yamt     1493:                         */
                   1494:                        proc_stop_done(p, ppsig, ppmask);
1.243     ad       1495:                }
                   1496:
1.276     ad       1497:                mutex_exit(proc_lock);
1.243     ad       1498:        }
                   1499:
                   1500:        /*
                   1501:         * Unlock and switch away.
                   1502:         */
1.245     ad       1503:        KERNEL_UNLOCK_ALL(l, &biglocks);
1.243     ad       1504:        if (p->p_stat == SSTOP || (p->p_sflag & PS_STOPPING) != 0) {
                   1505:                p->p_nrlwps--;
                   1506:                lwp_lock(l);
                   1507:                KASSERT(l->l_stat == LSONPROC || l->l_stat == LSSLEEP);
                   1508:                l->l_stat = LSSTOP;
                   1509:                lwp_unlock(l);
                   1510:        }
                   1511:
1.277     ad       1512:        mutex_exit(p->p_lock);
1.243     ad       1513:        lwp_lock(l);
1.253     yamt     1514:        mi_switch(l);
1.245     ad       1515:        KERNEL_LOCK(biglocks, l);
1.277     ad       1516:        mutex_enter(p->p_lock);
1.209     chs      1517: }
                   1518:
1.243     ad       1519: /*
                   1520:  * Check for a signal from the debugger.
                   1521:  */
                   1522: int
                   1523: sigchecktrace(sigpend_t **spp)
1.130     thorpej  1524: {
1.243     ad       1525:        struct lwp *l = curlwp;
1.130     thorpej  1526:        struct proc *p = l->l_proc;
1.243     ad       1527:        int signo;
                   1528:
1.277     ad       1529:        KASSERT(mutex_owned(p->p_lock));
1.130     thorpej  1530:
1.243     ad       1531:        /*
                   1532:         * If we are no longer being traced, or the parent didn't
                   1533:         * give us a signal, look for more signals.
                   1534:         */
                   1535:        if ((p->p_slflag & PSL_TRACED) == 0 || p->p_xstat == 0)
                   1536:                return 0;
1.130     thorpej  1537:
1.243     ad       1538:        /* If there's a pending SIGKILL, process it immediately. */
                   1539:        if (sigismember(&p->p_sigpend.sp_set, SIGKILL))
                   1540:                return 0;
1.79      mycroft  1541:
1.243     ad       1542:        /*
                   1543:         * If the new signal is being masked, look for other signals.
                   1544:         * `p->p_sigctx.ps_siglist |= mask' is done in setrunnable().
                   1545:         */
                   1546:        signo = p->p_xstat;
                   1547:        p->p_xstat = 0;
                   1548:        if ((sigprop[signo] & SA_TOLWP) != 0)
                   1549:                *spp = &l->l_sigpend;
                   1550:        else
                   1551:                *spp = &p->p_sigpend;
                   1552:        if (sigismember(&l->l_sigmask, signo))
                   1553:                signo = 0;
1.79      mycroft  1554:
1.243     ad       1555:        return signo;
1.79      mycroft  1556: }
                   1557:
1.29      cgd      1558: /*
                   1559:  * If the current process has received a signal (should be caught or cause
                   1560:  * termination, should interrupt current syscall), return the signal number.
1.243     ad       1561:  *
1.29      cgd      1562:  * Stop signals with default action are processed immediately, then cleared;
                   1563:  * they aren't returned.  This is checked after each entry to the system for
1.243     ad       1564:  * a syscall or trap.
                   1565:  *
                   1566:  * We will also return -1 if the process is exiting and the current LWP must
                   1567:  * follow suit.
1.29      cgd      1568:  *
1.243     ad       1569:  * Note that we may be called while on a sleep queue, so MUST NOT sleep.  We
                   1570:  * can switch away, though.
1.29      cgd      1571:  */
                   1572: int
1.130     thorpej  1573: issignal(struct lwp *l)
1.29      cgd      1574: {
1.243     ad       1575:        struct proc *p = l->l_proc;
                   1576:        int signo = 0, prop;
                   1577:        sigpend_t *sp = NULL;
                   1578:        sigset_t ss;
                   1579:
1.277     ad       1580:        KASSERT(mutex_owned(p->p_lock));
1.29      cgd      1581:
1.243     ad       1582:        for (;;) {
                   1583:                /* Discard any signals that we have decided not to take. */
                   1584:                if (signo != 0)
                   1585:                        (void)sigget(sp, NULL, signo, NULL);
1.144     fvdl     1586:
1.243     ad       1587:                /*
                   1588:                 * If the process is stopped/stopping, then stop ourselves
                   1589:                 * now that we're on the kernel/userspace boundary.  When
                   1590:                 * we awaken, check for a signal from the debugger.
                   1591:                 */
                   1592:                if (p->p_stat == SSTOP || (p->p_sflag & PS_STOPPING) != 0) {
1.249     thorpej  1593:                        sigswitch(true, PS_NOCLDSTOP, 0);
1.243     ad       1594:                        signo = sigchecktrace(&sp);
                   1595:                } else
                   1596:                        signo = 0;
1.238     ad       1597:
1.130     thorpej  1598:                /*
1.243     ad       1599:                 * If the debugger didn't provide a signal, find a pending
                   1600:                 * signal from our set.  Check per-LWP signals first, and
                   1601:                 * then per-process.
                   1602:                 */
                   1603:                if (signo == 0) {
                   1604:                        sp = &l->l_sigpend;
                   1605:                        ss = sp->sp_set;
                   1606:                        if ((p->p_sflag & PS_PPWAIT) != 0)
                   1607:                                sigminusset(&stopsigmask, &ss);
                   1608:                        sigminusset(&l->l_sigmask, &ss);
                   1609:
                   1610:                        if ((signo = firstsig(&ss)) == 0) {
                   1611:                                sp = &p->p_sigpend;
                   1612:                                ss = sp->sp_set;
                   1613:                                if ((p->p_sflag & PS_PPWAIT) != 0)
                   1614:                                        sigminusset(&stopsigmask, &ss);
                   1615:                                sigminusset(&l->l_sigmask, &ss);
                   1616:
                   1617:                                if ((signo = firstsig(&ss)) == 0) {
                   1618:                                        /*
                   1619:                                         * No signal pending - clear the
                   1620:                                         * indicator and bail out.
                   1621:                                         */
                   1622:                                        lwp_lock(l);
1.246     pavel    1623:                                        l->l_flag &= ~LW_PENDSIG;
1.243     ad       1624:                                        lwp_unlock(l);
                   1625:                                        sp = NULL;
                   1626:                                        break;
                   1627:                                }
                   1628:                        }
1.79      mycroft  1629:                }
1.42      mycroft  1630:
1.29      cgd      1631:                /*
1.243     ad       1632:                 * We should see pending but ignored signals only if
                   1633:                 * we are being traced.
1.29      cgd      1634:                 */
1.243     ad       1635:                if (sigismember(&p->p_sigctx.ps_sigignore, signo) &&
                   1636:                    (p->p_slflag & PSL_TRACED) == 0) {
                   1637:                        /* Discard the signal. */
1.29      cgd      1638:                        continue;
1.243     ad       1639:                }
1.42      mycroft  1640:
1.243     ad       1641:                /*
                   1642:                 * If traced, always stop, and stay stopped until released
                   1643:                 * by the debugger.  If the our parent process is waiting
                   1644:                 * for us, don't hang as we could deadlock.
                   1645:                 */
                   1646:                if ((p->p_slflag & PSL_TRACED) != 0 &&
                   1647:                    (p->p_sflag & PS_PPWAIT) == 0 && signo != SIGKILL) {
                   1648:                        /* Take the signal. */
                   1649:                        (void)sigget(sp, NULL, signo, NULL);
                   1650:                        p->p_xstat = signo;
1.184     manu     1651:
                   1652:                        /* Emulation-specific handling of signal trace */
1.243     ad       1653:                        if (p->p_emul->e_tracesig == NULL ||
                   1654:                            (*p->p_emul->e_tracesig)(p, signo) == 0)
                   1655:                                sigswitch(!(p->p_slflag & PSL_FSTRACE), 0,
                   1656:                                    signo);
1.29      cgd      1657:
1.243     ad       1658:                        /* Check for a signal from the debugger. */
                   1659:                        if ((signo = sigchecktrace(&sp)) == 0)
1.29      cgd      1660:                                continue;
                   1661:                }
                   1662:
1.243     ad       1663:                prop = sigprop[signo];
1.42      mycroft  1664:
1.29      cgd      1665:                /*
                   1666:                 * Decide whether the signal should be returned.
                   1667:                 */
1.243     ad       1668:                switch ((long)SIGACTION(p, signo).sa_handler) {
1.33      cgd      1669:                case (long)SIG_DFL:
1.29      cgd      1670:                        /*
                   1671:                         * Don't take default actions on system processes.
                   1672:                         */
                   1673:                        if (p->p_pid <= 1) {
                   1674: #ifdef DIAGNOSTIC
                   1675:                                /*
                   1676:                                 * Are you sure you want to ignore SIGSEGV
                   1677:                                 * in init? XXX
                   1678:                                 */
1.243     ad       1679:                                printf_nolog("Process (pid %d) got sig %d\n",
                   1680:                                    p->p_pid, signo);
1.29      cgd      1681: #endif
1.243     ad       1682:                                continue;
1.29      cgd      1683:                        }
1.243     ad       1684:
1.29      cgd      1685:                        /*
1.243     ad       1686:                         * If there is a pending stop signal to process with
                   1687:                         * default action, stop here, then clear the signal.
                   1688:                         * However, if process is member of an orphaned
1.29      cgd      1689:                         * process group, ignore tty stop signals.
                   1690:                         */
                   1691:                        if (prop & SA_STOP) {
1.276     ad       1692:                                /*
                   1693:                                 * XXX Don't hold proc_lock for p_lflag,
                   1694:                                 * but it's not a big deal.
                   1695:                                 */
1.243     ad       1696:                                if (p->p_slflag & PSL_TRACED ||
1.276     ad       1697:                                    ((p->p_lflag & PL_ORPHANPG) != 0 &&
1.243     ad       1698:                                    prop & SA_TTYSTOP)) {
                   1699:                                        /* Ignore the signal. */
                   1700:                                        continue;
                   1701:                                }
                   1702:                                /* Take the signal. */
                   1703:                                (void)sigget(sp, NULL, signo, NULL);
                   1704:                                p->p_xstat = signo;
                   1705:                                signo = 0;
1.249     thorpej  1706:                                sigswitch(true, PS_NOCLDSTOP, p->p_xstat);
1.29      cgd      1707:                        } else if (prop & SA_IGNORE) {
                   1708:                                /*
                   1709:                                 * Except for SIGCONT, shouldn't get here.
                   1710:                                 * Default action is to ignore; drop it.
                   1711:                                 */
1.243     ad       1712:                                continue;
                   1713:                        }
                   1714:                        break;
1.29      cgd      1715:
1.33      cgd      1716:                case (long)SIG_IGN:
1.243     ad       1717: #ifdef DEBUG_ISSIGNAL
1.29      cgd      1718:                        /*
                   1719:                         * Masking above should prevent us ever trying
                   1720:                         * to take action on an ignored signal other
                   1721:                         * than SIGCONT, unless process is traced.
                   1722:                         */
                   1723:                        if ((prop & SA_CONT) == 0 &&
1.243     ad       1724:                            (p->p_slflag & PSL_TRACED) == 0)
                   1725:                                printf_nolog("issignal\n");
1.128     jdolecek 1726: #endif
1.243     ad       1727:                        continue;
1.29      cgd      1728:
                   1729:                default:
                   1730:                        /*
1.243     ad       1731:                         * This signal has an action, let postsig() process
                   1732:                         * it.
1.29      cgd      1733:                         */
1.243     ad       1734:                        break;
1.29      cgd      1735:                }
1.243     ad       1736:
                   1737:                break;
1.29      cgd      1738:        }
1.42      mycroft  1739:
1.243     ad       1740:        l->l_sigpendset = sp;
                   1741:        return signo;
1.29      cgd      1742: }
                   1743:
                   1744: /*
1.243     ad       1745:  * Take the action for the specified signal
                   1746:  * from the current set of pending signals.
1.29      cgd      1747:  */
1.179     christos 1748: void
1.243     ad       1749: postsig(int signo)
1.29      cgd      1750: {
1.243     ad       1751:        struct lwp      *l;
                   1752:        struct proc     *p;
                   1753:        struct sigacts  *ps;
                   1754:        sig_t           action;
                   1755:        sigset_t        *returnmask;
                   1756:        ksiginfo_t      ksi;
                   1757:
                   1758:        l = curlwp;
                   1759:        p = l->l_proc;
                   1760:        ps = p->p_sigacts;
                   1761:
1.277     ad       1762:        KASSERT(mutex_owned(p->p_lock));
1.243     ad       1763:        KASSERT(signo > 0);
                   1764:
                   1765:        /*
                   1766:         * Set the new mask value and also defer further occurrences of this
                   1767:         * signal.
                   1768:         *
1.268     yamt     1769:         * Special case: user has done a sigsuspend.  Here the current mask is
                   1770:         * not of interest, but rather the mask from before the sigsuspen is
1.243     ad       1771:         * what we want restored after the signal processing is completed.
                   1772:         */
                   1773:        if (l->l_sigrestore) {
                   1774:                returnmask = &l->l_sigoldmask;
                   1775:                l->l_sigrestore = 0;
                   1776:        } else
                   1777:                returnmask = &l->l_sigmask;
1.29      cgd      1778:
1.243     ad       1779:        /*
                   1780:         * Commit to taking the signal before releasing the mutex.
                   1781:         */
                   1782:        action = SIGACTION_PS(ps, signo).sa_handler;
1.275     ad       1783:        l->l_ru.ru_nsignals++;
1.243     ad       1784:        sigget(l->l_sigpendset, &ksi, signo, NULL);
1.104     thorpej  1785:
1.255     ad       1786:        if (ktrpoint(KTR_PSIG)) {
1.277     ad       1787:                mutex_exit(p->p_lock);
1.255     ad       1788:                ktrpsig(signo, action, returnmask, NULL);
1.277     ad       1789:                mutex_enter(p->p_lock);
1.243     ad       1790:        }
1.130     thorpej  1791:
1.243     ad       1792:        if (action == SIG_DFL) {
1.175     cl       1793:                /*
1.243     ad       1794:                 * Default action, where the default is to kill
                   1795:                 * the process.  (Other cases were ignored above.)
1.175     cl       1796:                 */
1.243     ad       1797:                sigexit(l, signo);
                   1798:                return;
1.175     cl       1799:        }
                   1800:
1.202     perry    1801:        /*
1.243     ad       1802:         * If we get here, the signal must be caught.
1.130     thorpej  1803:         */
                   1804: #ifdef DIAGNOSTIC
1.243     ad       1805:        if (action == SIG_IGN || sigismember(&l->l_sigmask, signo))
                   1806:                panic("postsig action");
1.130     thorpej  1807: #endif
1.144     fvdl     1808:
1.243     ad       1809:        kpsendsig(l, &ksi, returnmask);
1.29      cgd      1810: }
                   1811:
1.133     nathanw  1812: /*
1.243     ad       1813:  * sendsig_reset:
1.133     nathanw  1814:  *
1.243     ad       1815:  *     Reset the signal action.  Called from emulation specific sendsig()
                   1816:  *     before unlocking to deliver the signal.
1.29      cgd      1817:  */
                   1818: void
1.243     ad       1819: sendsig_reset(struct lwp *l, int signo)
1.29      cgd      1820: {
1.243     ad       1821:        struct proc *p = l->l_proc;
                   1822:        struct sigacts *ps = p->p_sigacts;
1.29      cgd      1823:
1.277     ad       1824:        KASSERT(mutex_owned(p->p_lock));
1.106     thorpej  1825:
1.243     ad       1826:        p->p_sigctx.ps_lwp = 0;
                   1827:        p->p_sigctx.ps_code = 0;
                   1828:        p->p_sigctx.ps_signo = 0;
                   1829:
1.259     ad       1830:        mutex_enter(&ps->sa_mutex);
1.243     ad       1831:        sigplusset(&SIGACTION_PS(ps, signo).sa_mask, &l->l_sigmask);
                   1832:        if (SIGACTION_PS(ps, signo).sa_flags & SA_RESETHAND) {
                   1833:                sigdelset(&p->p_sigctx.ps_sigcatch, signo);
                   1834:                if (signo != SIGCONT && sigprop[signo] & SA_IGNORE)
                   1835:                        sigaddset(&p->p_sigctx.ps_sigignore, signo);
                   1836:                SIGACTION_PS(ps, signo).sa_handler = SIG_DFL;
1.29      cgd      1837:        }
1.259     ad       1838:        mutex_exit(&ps->sa_mutex);
1.29      cgd      1839: }
                   1840:
                   1841: /*
                   1842:  * Kill the current process for stated reason.
                   1843:  */
1.52      christos 1844: void
1.122     manu     1845: killproc(struct proc *p, const char *why)
1.29      cgd      1846: {
1.276     ad       1847:
                   1848:        KASSERT(mutex_owned(proc_lock));
                   1849:
1.29      cgd      1850:        log(LOG_ERR, "pid %d was killed: %s\n", p->p_pid, why);
1.243     ad       1851:        uprintf_locked("sorry, pid %d was killed: %s\n", p->p_pid, why);
1.29      cgd      1852:        psignal(p, SIGKILL);
                   1853: }
                   1854:
                   1855: /*
                   1856:  * Force the current process to exit with the specified signal, dumping core
1.243     ad       1857:  * if appropriate.  We bypass the normal tests for masked and caught
                   1858:  * signals, allowing unrecoverable failures to terminate the process without
                   1859:  * changing signal state.  Mark the accounting record with the signal
                   1860:  * termination.  If dumping core, save the signal number for the debugger.
                   1861:  * Calls exit and does not return.
1.29      cgd      1862:  */
1.243     ad       1863: void
                   1864: sigexit(struct lwp *l, int signo)
                   1865: {
                   1866:        int exitsig, error, docore;
                   1867:        struct proc *p;
                   1868:        struct lwp *t;
1.96      fair     1869:
1.243     ad       1870:        p = l->l_proc;
1.96      fair     1871:
1.277     ad       1872:        KASSERT(mutex_owned(p->p_lock));
1.243     ad       1873:        KERNEL_UNLOCK_ALL(l, NULL);
1.96      fair     1874:
1.243     ad       1875:        /*
                   1876:         * Don't permit coredump() multiple times in the same process.
                   1877:         * Call back into sigexit, where we will be suspended until
                   1878:         * the deed is done.  Note that this is a recursive call, but
1.246     pavel    1879:         * LW_WCORE will prevent us from coming back this way.
1.243     ad       1880:         */
                   1881:        if ((p->p_sflag & PS_WCORE) != 0) {
                   1882:                lwp_lock(l);
1.246     pavel    1883:                l->l_flag |= (LW_WCORE | LW_WEXIT | LW_WSUSPEND);
1.243     ad       1884:                lwp_unlock(l);
1.277     ad       1885:                mutex_exit(p->p_lock);
1.243     ad       1886:                lwp_userret(l);
                   1887: #ifdef DIAGNOSTIC
                   1888:                panic("sigexit");
                   1889: #endif
                   1890:                /* NOTREACHED */
                   1891:        }
1.130     thorpej  1892:
                   1893:        /*
1.243     ad       1894:         * Prepare all other LWPs for exit.  If dumping core, suspend them
                   1895:         * so that their registers are available long enough to be dumped.
                   1896:         */
                   1897:        if ((docore = (sigprop[signo] & SA_CORE)) != 0) {
                   1898:                p->p_sflag |= PS_WCORE;
                   1899:                for (;;) {
                   1900:                        LIST_FOREACH(t, &p->p_lwps, l_sibling) {
                   1901:                                lwp_lock(t);
                   1902:                                if (t == l) {
1.246     pavel    1903:                                        t->l_flag &= ~LW_WSUSPEND;
1.243     ad       1904:                                        lwp_unlock(t);
                   1905:                                        continue;
                   1906:                                }
1.246     pavel    1907:                                t->l_flag |= (LW_WCORE | LW_WEXIT);
1.243     ad       1908:                                lwp_suspend(l, t);
                   1909:                        }
1.130     thorpej  1910:
1.243     ad       1911:                        if (p->p_nrlwps == 1)
                   1912:                                break;
1.130     thorpej  1913:
1.243     ad       1914:                        /*
                   1915:                         * Kick any LWPs sitting in lwp_wait1(), and wait
                   1916:                         * for everyone else to stop before proceeding.
                   1917:                         */
                   1918:                        p->p_nlwpwait++;
                   1919:                        cv_broadcast(&p->p_lwpcv);
1.277     ad       1920:                        cv_wait(&p->p_lwpcv, p->p_lock);
1.243     ad       1921:                        p->p_nlwpwait--;
                   1922:                }
                   1923:        }
1.130     thorpej  1924:
1.243     ad       1925:        exitsig = signo;
                   1926:        p->p_acflag |= AXSIG;
                   1927:        p->p_sigctx.ps_signo = signo;
1.277     ad       1928:        mutex_exit(p->p_lock);
1.130     thorpej  1929:
1.243     ad       1930:        if (docore) {
1.201     christos 1931:                if ((error = coredump(l, NULL)) == 0)
1.102     sommerfe 1932:                        exitsig |= WCOREFLAG;
                   1933:
                   1934:                if (kern_logsigexit) {
1.224     ad       1935:                        int uid = l->l_cred ?
                   1936:                            (int)kauth_cred_geteuid(l->l_cred) : -1;
1.102     sommerfe 1937:
1.202     perry    1938:                        if (error)
1.102     sommerfe 1939:                                log(LOG_INFO, lognocoredump, p->p_pid,
1.243     ad       1940:                                    p->p_comm, uid, signo, error);
1.102     sommerfe 1941:                        else
                   1942:                                log(LOG_INFO, logcoredump, p->p_pid,
1.243     ad       1943:                                    p->p_comm, uid, signo);
1.96      fair     1944:                }
                   1945:
1.240     elad     1946: #ifdef PAX_SEGVGUARD
1.249     thorpej  1947:                pax_segvguard(l, p->p_textvp, p->p_comm, true);
1.240     elad     1948: #endif /* PAX_SEGVGUARD */
1.29      cgd      1949:        }
1.96      fair     1950:
1.243     ad       1951:        /* Acquire the sched state mutex.  exit1() will release it. */
1.277     ad       1952:        mutex_enter(p->p_lock);
1.243     ad       1953:
                   1954:        /* No longer dumping core. */
                   1955:        p->p_sflag &= ~PS_WCORE;
                   1956:
1.130     thorpej  1957:        exit1(l, W_EXITCODE(0, exitsig));
1.29      cgd      1958:        /* NOTREACHED */
                   1959: }
                   1960:
                   1961: /*
1.243     ad       1962:  * Put process 'p' into the stopped state and optionally, notify the parent.
1.29      cgd      1963:  */
1.243     ad       1964: void
                   1965: proc_stop(struct proc *p, int notify, int signo)
1.29      cgd      1966: {
1.243     ad       1967:        struct lwp *l;
1.112     lukem    1968:
1.277     ad       1969:        KASSERT(mutex_owned(p->p_lock));
1.29      cgd      1970:
1.59      cgd      1971:        /*
1.243     ad       1972:         * First off, set the stopping indicator and bring all sleeping
                   1973:         * LWPs to a halt so they are included in p->p_nrlwps.  We musn't
                   1974:         * unlock between here and the p->p_nrlwps check below.
1.59      cgd      1975:         */
1.243     ad       1976:        p->p_sflag |= PS_STOPPING;
1.272     yamt     1977:        if (notify)
                   1978:                p->p_sflag |= PS_NOTIFYSTOP;
                   1979:        else
                   1980:                p->p_sflag &= ~PS_NOTIFYSTOP;
1.260     ad       1981:        membar_producer();
1.59      cgd      1982:
1.272     yamt     1983:        proc_stop_lwps(p);
1.59      cgd      1984:
                   1985:        /*
1.243     ad       1986:         * If there are no LWPs available to take the signal, then we
                   1987:         * signal the parent process immediately.  Otherwise, the last
                   1988:         * LWP to stop will take care of it.
1.59      cgd      1989:         */
                   1990:
1.243     ad       1991:        if (p->p_nrlwps == 0) {
1.272     yamt     1992:                proc_stop_done(p, true, PS_NOCLDSTOP);
1.243     ad       1993:        } else {
                   1994:                /*
                   1995:                 * Have the remaining LWPs come to a halt, and trigger
                   1996:                 * proc_stop_callout() to ensure that they do.
                   1997:                 */
                   1998:                LIST_FOREACH(l, &p->p_lwps, l_sibling)
                   1999:                        sigpost(l, SIG_DFL, SA_STOP, signo);
                   2000:                callout_schedule(&proc_stop_ch, 1);
1.169     hannken  2001:        }
1.29      cgd      2002: }
                   2003:
                   2004: /*
1.243     ad       2005:  * When stopping a process, we do not immediatly set sleeping LWPs stopped,
                   2006:  * but wait for them to come to a halt at the kernel-user boundary.  This is
                   2007:  * to allow LWPs to release any locks that they may hold before stopping.
                   2008:  *
                   2009:  * Non-interruptable sleeps can be long, and there is the potential for an
                   2010:  * LWP to begin sleeping interruptably soon after the process has been set
                   2011:  * stopping (PS_STOPPING).  These LWPs will not notice that the process is
                   2012:  * stopping, and so complete halt of the process and the return of status
                   2013:  * information to the parent could be delayed indefinitely.
                   2014:  *
                   2015:  * To handle this race, proc_stop_callout() runs once per tick while there
1.256     ad       2016:  * are stopping processes in the system.  It sets LWPs that are sleeping
1.243     ad       2017:  * interruptably into the LSSTOP state.
                   2018:  *
                   2019:  * Note that we are not concerned about keeping all LWPs stopped while the
                   2020:  * process is stopped: stopped LWPs can awaken briefly to handle signals.
                   2021:  * What we do need to ensure is that all LWPs in a stopping process have
                   2022:  * stopped at least once, so that notification can be sent to the parent
                   2023:  * process.
1.29      cgd      2024:  */
1.243     ad       2025: static void
                   2026: proc_stop_callout(void *cookie)
1.29      cgd      2027: {
1.248     thorpej  2028:        bool more, restart;
1.243     ad       2029:        struct proc *p;
1.29      cgd      2030:
1.243     ad       2031:        (void)cookie;
1.94      bouyer   2032:
1.243     ad       2033:        do {
1.249     thorpej  2034:                restart = false;
                   2035:                more = false;
1.130     thorpej  2036:
1.276     ad       2037:                mutex_enter(proc_lock);
1.243     ad       2038:                PROCLIST_FOREACH(p, &allproc) {
1.277     ad       2039:                        mutex_enter(p->p_lock);
1.130     thorpej  2040:
1.243     ad       2041:                        if ((p->p_sflag & PS_STOPPING) == 0) {
1.277     ad       2042:                                mutex_exit(p->p_lock);
1.243     ad       2043:                                continue;
                   2044:                        }
1.130     thorpej  2045:
1.243     ad       2046:                        /* Stop any LWPs sleeping interruptably. */
1.272     yamt     2047:                        proc_stop_lwps(p);
1.243     ad       2048:                        if (p->p_nrlwps == 0) {
                   2049:                                /*
                   2050:                                 * We brought the process to a halt.
                   2051:                                 * Mark it as stopped and notify the
                   2052:                                 * parent.
                   2053:                                 */
                   2054:                                if ((p->p_sflag & PS_NOTIFYSTOP) != 0) {
                   2055:                                        /*
1.272     yamt     2056:                                         * Note that proc_stop_done() will
1.277     ad       2057:                                         * drop p->p_lock briefly.
1.243     ad       2058:                                         * Arrange to restart and check
                   2059:                                         * all processes again.
                   2060:                                         */
1.249     thorpej  2061:                                        restart = true;
1.243     ad       2062:                                }
1.272     yamt     2063:                                proc_stop_done(p, true, PS_NOCLDSTOP);
1.243     ad       2064:                        } else
1.249     thorpej  2065:                                more = true;
1.130     thorpej  2066:
1.277     ad       2067:                        mutex_exit(p->p_lock);
1.243     ad       2068:                        if (restart)
                   2069:                                break;
                   2070:                }
1.276     ad       2071:                mutex_exit(proc_lock);
1.243     ad       2072:        } while (restart);
1.185     matt     2073:
1.130     thorpej  2074:        /*
1.243     ad       2075:         * If we noted processes that are stopping but still have
                   2076:         * running LWPs, then arrange to check again in 1 tick.
1.130     thorpej  2077:         */
1.243     ad       2078:        if (more)
                   2079:                callout_schedule(&proc_stop_ch, 1);
1.108     jdolecek 2080: }
1.130     thorpej  2081:
1.135     jdolecek 2082: /*
1.243     ad       2083:  * Given a process in state SSTOP, set the state back to SACTIVE and
                   2084:  * move LSSTOP'd LWPs to LSSLEEP or make them runnable.
1.135     jdolecek 2085:  */
1.243     ad       2086: void
                   2087: proc_unstop(struct proc *p)
1.135     jdolecek 2088: {
1.243     ad       2089:        struct lwp *l;
                   2090:        int sig;
1.208     cube     2091:
1.276     ad       2092:        KASSERT(mutex_owned(proc_lock));
1.277     ad       2093:        KASSERT(mutex_owned(p->p_lock));
1.135     jdolecek 2094:
1.243     ad       2095:        p->p_stat = SACTIVE;
                   2096:        p->p_sflag &= ~PS_STOPPING;
                   2097:        sig = p->p_xstat;
1.219     mrg      2098:
1.243     ad       2099:        if (!p->p_waited)
                   2100:                p->p_pptr->p_nstopchild--;
1.173     jdolecek 2101:
1.243     ad       2102:        LIST_FOREACH(l, &p->p_lwps, l_sibling) {
                   2103:                lwp_lock(l);
                   2104:                if (l->l_stat != LSSTOP) {
                   2105:                        lwp_unlock(l);
                   2106:                        continue;
1.171     jdolecek 2107:                }
1.243     ad       2108:                if (l->l_wchan == NULL) {
                   2109:                        setrunnable(l);
                   2110:                        continue;
1.241     enami    2111:                }
1.246     pavel    2112:                if (sig && (l->l_flag & LW_SINTR) != 0) {
1.243     ad       2113:                        setrunnable(l);
                   2114:                        sig = 0;
1.250     ad       2115:                } else {
                   2116:                        l->l_stat = LSSLEEP;
                   2117:                        p->p_nrlwps++;
1.243     ad       2118:                        lwp_unlock(l);
1.250     ad       2119:                }
1.135     jdolecek 2120:        }
1.29      cgd      2121: }
1.126     jdolecek 2122:
                   2123: static int
                   2124: filt_sigattach(struct knote *kn)
                   2125: {
                   2126:        struct proc *p = curproc;
                   2127:
1.274     ad       2128:        kn->kn_obj = p;
1.126     jdolecek 2129:        kn->kn_flags |= EV_CLEAR;               /* automatically set */
                   2130:
1.277     ad       2131:        mutex_enter(p->p_lock);
1.126     jdolecek 2132:        SLIST_INSERT_HEAD(&p->p_klist, kn, kn_selnext);
1.277     ad       2133:        mutex_exit(p->p_lock);
1.126     jdolecek 2134:
                   2135:        return (0);
                   2136: }
                   2137:
                   2138: static void
                   2139: filt_sigdetach(struct knote *kn)
                   2140: {
1.274     ad       2141:        struct proc *p = kn->kn_obj;
1.126     jdolecek 2142:
1.277     ad       2143:        mutex_enter(p->p_lock);
1.126     jdolecek 2144:        SLIST_REMOVE(&p->p_klist, kn, knote, kn_selnext);
1.277     ad       2145:        mutex_exit(p->p_lock);
1.126     jdolecek 2146: }
                   2147:
                   2148: /*
                   2149:  * signal knotes are shared with proc knotes, so we apply a mask to
                   2150:  * the hint in order to differentiate them from process hints.  This
                   2151:  * could be avoided by using a signal-specific knote list, but probably
                   2152:  * isn't worth the trouble.
                   2153:  */
                   2154: static int
                   2155: filt_signal(struct knote *kn, long hint)
                   2156: {
                   2157:
                   2158:        if (hint & NOTE_SIGNAL) {
                   2159:                hint &= ~NOTE_SIGNAL;
                   2160:
                   2161:                if (kn->kn_id == hint)
                   2162:                        kn->kn_data++;
                   2163:        }
                   2164:        return (kn->kn_data != 0);
                   2165: }
                   2166:
                   2167: const struct filterops sig_filtops = {
                   2168:        0, filt_sigattach, filt_sigdetach, filt_signal
                   2169: };

CVSweb <webmaster@jp.NetBSD.org>