int
waitsys32(idtype_t idtype, id_t id, siginfo_t *infop, int options)
{
int error;
k_siginfo_t info;
siginfo32_t info32;
if (error = waitid(idtype, id, &info, options))
return (set_errno(error));
siginfo_kto32(&info, &info32);
if (copyout(&info32, infop, sizeof (info32)))
return (set_errno(EFAULT));
return (0);
}
int
sendsig32(int sig, k_siginfo_t *sip, void (*hdlr)())
{
volatile int minstacksz;
int newstack;
label_t ljb;
volatile caddr_t sp;
caddr_t fp;
volatile struct regs *rp;
volatile greg_t upc;
volatile proc_t *p = ttoproc(curthread);
klwp_t *lwp = ttolwp(curthread);
ucontext32_t *volatile tuc = NULL;
ucontext32_t *uc;
siginfo32_t *sip_addr;
volatile int watched;
rp = lwptoregs(lwp);
upc = rp->r_pc;
minstacksz = SA32(sizeof (struct sigframe32)) + SA32(sizeof (*uc));
if (sip != NULL)
minstacksz += SA32(sizeof (siginfo32_t));
ASSERT((minstacksz & (STACK_ALIGN32 - 1)) == 0);
/*
* Figure out whether we will be handling this signal on
* an alternate stack specified by the user. Then allocate
* and validate the stack requirements for the signal handler
* context. on_fault will catch any faults.
*/
newstack = sigismember(&PTOU(curproc)->u_sigonstack, sig) &&
!(lwp->lwp_sigaltstack.ss_flags & (SS_ONSTACK|SS_DISABLE));
if (newstack) {
fp = (caddr_t)(SA32((uintptr_t)lwp->lwp_sigaltstack.ss_sp) +
SA32(lwp->lwp_sigaltstack.ss_size) - STACK_ALIGN32);
} else if ((rp->r_ss & 0xffff) != UDS_SEL) {
user_desc_t *ldt;
/*
* If the stack segment selector is -not- pointing at
* the UDS_SEL descriptor and we have an LDT entry for
* it instead, add the base address to find the effective va.
*/
if ((ldt = p->p_ldt) != NULL)
fp = (caddr_t)rp->r_sp +
USEGD_GETBASE(&ldt[SELTOIDX(rp->r_ss)]);
else
fp = (caddr_t)rp->r_sp;
} else
fp = (caddr_t)rp->r_sp;
/*
* Force proper stack pointer alignment, even in the face of a
* misaligned stack pointer from user-level before the signal.
* Don't use the SA32() macro because that rounds up, not down.
*/
fp = (caddr_t)((uintptr_t)fp & ~(STACK_ALIGN32 - 1));
sp = fp - minstacksz;
/*
* Make sure lwp hasn't trashed its stack
*/
if (sp >= (caddr_t)(uintptr_t)USERLIMIT32 ||
fp >= (caddr_t)(uintptr_t)USERLIMIT32) {
#ifdef DEBUG
printf("sendsig32: bad signal stack cmd=%s, pid=%d, sig=%d\n",
PTOU(p)->u_comm, p->p_pid, sig);
printf("sigsp = 0x%p, action = 0x%p, upc = 0x%lx\n",
(void *)sp, (void *)hdlr, (uintptr_t)upc);
printf("sp above USERLIMIT\n");
#endif
return (0);
}
watched = watch_disable_addr((caddr_t)sp, minstacksz, S_WRITE);
if (on_fault(&ljb))
goto badstack;
if (sip != NULL) {
siginfo32_t si32;
zoneid_t zoneid;
siginfo_kto32(sip, &si32);
if (SI_FROMUSER(sip) &&
(zoneid = p->p_zone->zone_id) != GLOBAL_ZONEID &&
zoneid != sip->si_zoneid) {
si32.si_pid = p->p_zone->zone_zsched->p_pid;
si32.si_uid = 0;
si32.si_ctid = -1;
si32.si_zoneid = zoneid;
}
fp -= SA32(sizeof (si32));
uzero(fp, sizeof (si32));
copyout_noerr(&si32, fp, sizeof (si32));
sip_addr = (siginfo32_t *)fp;
if (sig == SIGPROF &&
curthread->t_rprof != NULL &&
curthread->t_rprof->rp_anystate) {
/*
* We stand on our head to deal with
* the real-time profiling signal.
* Fill in the stuff that doesn't fit
* in a normal k_siginfo structure.
*/
int i = sip->si_nsysarg;
while (--i >= 0)
suword32_noerr(&(sip_addr->si_sysarg[i]),
(uint32_t)lwp->lwp_arg[i]);
copyout_noerr(curthread->t_rprof->rp_state,
sip_addr->si_mstate,
sizeof (curthread->t_rprof->rp_state));
}
} else
sip_addr = NULL;
/* save the current context on the user stack */
fp -= SA32(sizeof (*tuc));
uc = (ucontext32_t *)fp;
tuc = kmem_alloc(sizeof (*tuc), KM_SLEEP);
no_fault();
savecontext32(tuc, &lwp->lwp_sigoldmask);
if (on_fault(&ljb))
goto badstack;
copyout_noerr(tuc, uc, sizeof (*tuc));
kmem_free(tuc, sizeof (*tuc));
tuc = NULL;
lwp->lwp_oldcontext = (uintptr_t)uc;
if (newstack) {
lwp->lwp_sigaltstack.ss_flags |= SS_ONSTACK;
if (lwp->lwp_ustack) {
stack32_t stk32;
stk32.ss_sp = (caddr32_t)(uintptr_t)
lwp->lwp_sigaltstack.ss_sp;
stk32.ss_size = (size32_t)
lwp->lwp_sigaltstack.ss_size;
stk32.ss_flags = (int32_t)
lwp->lwp_sigaltstack.ss_flags;
copyout_noerr(&stk32,
(stack32_t *)lwp->lwp_ustack, sizeof (stk32));
}
}
/*
* Set up signal handler arguments
*/
{
struct sigframe32 frame32;
frame32.sip = (caddr32_t)(uintptr_t)sip_addr;
frame32.ucp = (caddr32_t)(uintptr_t)uc;
frame32.signo = sig;
frame32.retaddr = 0xffffffff; /* never return! */
copyout_noerr(&frame32, sp, sizeof (frame32));
}
no_fault();
if (watched)
watch_enable_addr((caddr_t)sp, minstacksz, S_WRITE);
rp->r_sp = (greg_t)(uintptr_t)sp;
rp->r_pc = (greg_t)(uintptr_t)hdlr;
rp->r_ps = PSL_USER | (rp->r_ps & PS_IOPL);
if ((rp->r_cs & 0xffff) != U32CS_SEL ||
(rp->r_ss & 0xffff) != UDS_SEL) {
/*
* Try our best to deliver the signal.
*/
rp->r_cs = U32CS_SEL;
rp->r_ss = UDS_SEL;
}
/*
* Don't set lwp_eosys here. sendsig() is called via psig() after
* lwp_eosys is handled, so setting it here would affect the next
* system call.
*/
return (1);
badstack:
no_fault();
if (watched)
watch_enable_addr((caddr_t)sp, minstacksz, S_WRITE);
if (tuc)
kmem_free(tuc, sizeof (*tuc));
#ifdef DEBUG
printf("sendsig32: bad signal stack cmd=%s pid=%d, sig=%d\n",
PTOU(p)->u_comm, p->p_pid, sig);
printf("on fault, sigsp = 0x%p, action = 0x%p, upc = 0x%lx\n",
(void *)sp, (void *)hdlr, (uintptr_t)upc);
#endif
return (0);
}
