int
netbsd32_process_read_fpregs(struct lwp *l, struct fpreg32 *regs, size_t *sz)
{
struct fpreg regs64;
struct save87 *s87 = (struct save87 *)regs;
size_t fp_size;
int error, i;
union fp_addr {
uint64_t fa_64; /* Linear address for 64bit systems */
struct {
uint32_t fa_off; /* Linear address for 32 bit */
uint16_t fa_seg; /* Code/data (etc) segment */
uint16_t fa_pad;
} fa_32;
} fa;
/*
* NOTE: This 'struct fpreg32' is just char[108] and is shorter
* than 'struct save87'.
* If we write to the extra fields we trash the stack when writing
* process coredumps (see coredump_note() in core_elf32.c).
* This code must not set sv_env.en_tw or s87->sv_ex_sw.
*/
/*
* All that stuff makes no sense in i386 code :(
*/
fp_size = sizeof regs64;
error = process_read_fpregs(l, ®s64, &fp_size);
if (error)
return error;
s87->sv_env.en_cw = regs64.fxstate.fx_fcw;
s87->sv_env.en_sw = regs64.fxstate.fx_fsw;
fa.fa_64 = regs64.fxstate.fx_rip;
s87->sv_env.en_fip = fa.fa_32.fa_off;
s87->sv_env.en_fcs = fa.fa_32.fa_seg;
s87->sv_env.en_opcode = regs64.fxstate.fx_fop;
fa.fa_64 = regs64.fxstate.fx_rdp;
s87->sv_env.en_foo = fa.fa_32.fa_off;
s87->sv_env.en_fos = fa.fa_32.fa_seg;
s87->sv_env.en_tw = 0;
for (i = 0; i < 8; i++) {
s87->sv_env.en_tw |=
(xmm_to_s87_tag((uint8_t *)®s64.fxstate.fx_st[i][0], i,
regs64.fxstate.fx_ftw) << (i * 2));
memcpy(&s87->sv_ac[i].fp_bytes, ®s64.fxstate.fx_st[i][0],
sizeof(s87->sv_ac[i].fp_bytes));
}
return (0);
}
int
cpu_coredump(struct proc *p, struct vnode *vp, struct ucred *cred,
struct core *chdr)
{
int error;
struct {
struct reg regs;
struct fpreg fpregs;
} cpustate;
struct coreseg cseg;
CORE_SETMAGIC(*chdr, COREMAGIC, MID_MACHINE, 0);
chdr->c_hdrsize = ALIGN(sizeof(*chdr));
chdr->c_seghdrsize = ALIGN(sizeof(cseg));
chdr->c_cpusize = sizeof(cpustate);
/* Save integer registers. */
error = process_read_regs(p, &cpustate.regs);
if (error)
return error;
/* Save floating point registers. */
error = process_read_fpregs(p, &cpustate.fpregs);
if (error)
return error;
CORE_SETMAGIC(cseg, CORESEGMAGIC, MID_MACHINE, CORE_CPU);
cseg.c_addr = 0;
cseg.c_size = chdr->c_cpusize;
error = vn_rdwr(UIO_WRITE, vp, (caddr_t)&cseg, chdr->c_seghdrsize,
(off_t)chdr->c_hdrsize, UIO_SYSSPACE,
IO_NODELOCKED|IO_UNIT, cred, NULL, p);
if (error)
return error;
error = vn_rdwr(UIO_WRITE, vp, (caddr_t)&cpustate, sizeof(cpustate),
(off_t)(chdr->c_hdrsize + chdr->c_seghdrsize), UIO_SYSSPACE,
IO_NODELOCKED|IO_UNIT, cred, NULL, p);
if (error)
return error;
chdr->c_nseg++;
return error;
}
int
cpu_coredump(struct lwp *l, struct coredump_iostate *iocookie,
struct core *chdr)
{
struct md_core md_core;
struct coreseg cseg;
int error;
if (iocookie == NULL) {
CORE_SETMAGIC(*chdr, COREMAGIC, MID_MACHINE, 0);
chdr->c_hdrsize = ALIGN(sizeof(*chdr));
chdr->c_seghdrsize = ALIGN(sizeof(cseg));
chdr->c_cpusize = sizeof(md_core);
chdr->c_nseg++;
return 0;
}
/* Save integer registers. */
error = process_read_regs(l, &md_core.intreg);
if (error)
return error;
if (fputype) {
/* Save floating point registers. */
error = process_read_fpregs(l, &md_core.freg, NULL);
if (error)
return error;
} else {
/* Make sure these are clear. */
memset((void *)&md_core.freg, 0, sizeof(md_core.freg));
}
CORE_SETMAGIC(cseg, CORESEGMAGIC, MID_MACHINE, CORE_CPU);
cseg.c_addr = 0;
cseg.c_size = chdr->c_cpusize;
error = coredump_write(iocookie, UIO_SYSSPACE, &cseg,
chdr->c_seghdrsize);
if (error)
return error;
return coredump_write(iocookie, UIO_SYSSPACE, &md_core,
sizeof(md_core));
}
int
process_dofpregs(struct lwp *curl /*tracer*/,
struct lwp *l /*traced*/,
struct uio *uio)
{
#if defined(PT_GETFPREGS) || defined(PT_SETFPREGS)
int error;
struct fpreg r;
char *kv;
int kl;
if (uio->uio_offset < 0 || uio->uio_offset > (off_t)sizeof(r))
return EINVAL;
kl = sizeof(r);
kv = (char *)&r;
kv += uio->uio_offset;
kl -= uio->uio_offset;
if ((size_t)kl > uio->uio_resid)
kl = uio->uio_resid;
uvm_lwp_hold(l);
error = process_read_fpregs(l, &r);
if (error == 0)
error = uiomove(kv, kl, uio);
if (error == 0 && uio->uio_rw == UIO_WRITE) {
if (l->l_stat != LSSTOP)
error = EBUSY;
else
error = process_write_fpregs(l, &r);
}
uvm_lwp_rele(l);
uio->uio_offset = 0;
return (error);
#else
return (EINVAL);
#endif
}
/*
* Dump the machine specific segment at the start of a core dump.
*/
int
cpu_coredump(struct lwp *l, struct coredump_iostate *iocookie,
struct core *chdr)
{
int error;
struct {
struct reg regs;
struct fpreg fpregs;
} cpustate;
struct coreseg cseg;
if (iocookie == NULL) {
CORE_SETMAGIC(*chdr, COREMAGIC, MID_MACHINE, 0);
chdr->c_hdrsize = ALIGN(sizeof(*chdr));
chdr->c_seghdrsize = ALIGN(sizeof(cseg));
chdr->c_cpusize = sizeof(cpustate);
chdr->c_nseg++;
return 0;
}
/* Save integer registers. */
error = process_read_regs(l, &cpustate.regs);
if (error)
return error;
/* Save floating point registers. */
error = process_read_fpregs(l, &cpustate.fpregs, NULL);
if (error)
return error;
CORE_SETMAGIC(cseg, CORESEGMAGIC, MID_MACHINE, CORE_CPU);
cseg.c_addr = 0;
cseg.c_size = chdr->c_cpusize;
error = coredump_write(iocookie, UIO_SYSSPACE,
&cseg, chdr->c_seghdrsize);
if (error)
return error;
return coredump_write(iocookie, UIO_SYSSPACE,
&cpustate, sizeof(cpustate));
}
/*
* Dump the machine specific header information at the start of a core dump.
*/
int
cpu_coredump(struct proc *p, struct vnode *vp, struct ucred *cred,
struct core *core)
{
struct md_coredump md_core;
struct coreseg cseg;
off_t off;
int error;
CORE_SETMAGIC(*core, COREMAGIC, MID_HPPA, 0);
core->c_hdrsize = ALIGN(sizeof(*core));
core->c_seghdrsize = ALIGN(sizeof(cseg));
core->c_cpusize = sizeof(md_core);
process_read_regs(p, &md_core.md_reg);
process_read_fpregs(p, &md_core.md_fpreg);
CORE_SETMAGIC(cseg, CORESEGMAGIC, MID_HPPA, CORE_CPU);
cseg.c_addr = 0;
cseg.c_size = core->c_cpusize;
#define write(vp, addr, n) \
vn_rdwr(UIO_WRITE, (vp), (caddr_t)(addr), (n), off, \
UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT, cred, NULL, p)
off = core->c_hdrsize;
if ((error = write(vp, &cseg, core->c_seghdrsize)))
return error;
off += core->c_seghdrsize;
if ((error = write(vp, &md_core, sizeof md_core)))
return error;
#undef write
core->c_nseg++;
return error;
}
/*
* Process debugging system call.
*/
int
sys_ptrace(struct proc *p, void *v, register_t *retval)
{
struct sys_ptrace_args /* {
syscallarg(int) req;
syscallarg(pid_t) pid;
syscallarg(caddr_t) addr;
syscallarg(int) data;
} */ *uap = v;
struct proc *t; /* target thread */
struct process *tr; /* target process */
struct uio uio;
struct iovec iov;
struct ptrace_io_desc piod;
struct ptrace_event pe;
struct ptrace_thread_state pts;
struct reg *regs;
#if defined (PT_SETFPREGS) || defined (PT_GETFPREGS)
struct fpreg *fpregs;
#endif
#if defined (PT_SETXMMREGS) || defined (PT_GETXMMREGS)
struct xmmregs *xmmregs;
#endif
#ifdef PT_WCOOKIE
register_t wcookie;
#endif
int error, write;
int temp;
int req = SCARG(uap, req);
int s;
/* "A foolish consistency..." XXX */
switch (req) {
case PT_TRACE_ME:
t = p;
break;
/* calls that only operate on the PID */
case PT_READ_I:
case PT_READ_D:
case PT_WRITE_I:
case PT_WRITE_D:
case PT_KILL:
case PT_ATTACH:
case PT_IO:
case PT_SET_EVENT_MASK:
case PT_GET_EVENT_MASK:
case PT_GET_PROCESS_STATE:
case PT_GET_THREAD_FIRST:
case PT_GET_THREAD_NEXT:
default:
/* Find the process we're supposed to be operating on. */
if ((t = pfind(SCARG(uap, pid))) == NULL)
return (ESRCH);
if (t->p_flag & P_THREAD)
return (ESRCH);
break;
/* calls that accept a PID or a thread ID */
case PT_CONTINUE:
case PT_DETACH:
#ifdef PT_STEP
case PT_STEP:
#endif
case PT_GETREGS:
case PT_SETREGS:
#ifdef PT_GETFPREGS
case PT_GETFPREGS:
#endif
#ifdef PT_SETFPREGS
case PT_SETFPREGS:
#endif
#ifdef PT_GETXMMREGS
case PT_GETXMMREGS:
#endif
#ifdef PT_SETXMMREGS
case PT_SETXMMREGS:
#endif
if (SCARG(uap, pid) > THREAD_PID_OFFSET) {
t = pfind(SCARG(uap, pid) - THREAD_PID_OFFSET);
if (t == NULL)
return (ESRCH);
} else {
if ((t = pfind(SCARG(uap, pid))) == NULL)
return (ESRCH);
if (t->p_flag & P_THREAD)
return (ESRCH);
}
break;
}
tr = t->p_p;
if ((tr->ps_flags & PS_INEXEC) != 0)
return (EAGAIN);
/* Make sure we can operate on it. */
switch (req) {
case PT_TRACE_ME:
/* Saying that you're being traced is always legal. */
break;
case PT_ATTACH:
/*
* You can't attach to a process if:
* (1) it's the process that's doing the attaching,
*/
if (tr == p->p_p)
return (EINVAL);
/*
* (2) it's a system process
*/
if (ISSET(tr->ps_flags, PS_SYSTEM))
return (EPERM);
/*
* (3) it's already being traced, or
*/
if (ISSET(tr->ps_flags, PS_TRACED))
return (EBUSY);
/*
* (4) it's not owned by you, or the last exec
* gave us setuid/setgid privs (unless
* you're root), or...
*
* [Note: once PS_SUGID or PS_SUGIDEXEC gets set in
* execve(), they stay set until the process does
* another execve(). Hence this prevents a setuid
* process which revokes its special privileges using
* setuid() from being traced. This is good security.]
*/
if ((tr->ps_ucred->cr_ruid != p->p_ucred->cr_ruid ||
ISSET(tr->ps_flags, PS_SUGIDEXEC | PS_SUGID)) &&
(error = suser(p, 0)) != 0)
return (error);
/*
* (4.5) it's not a child of the tracing process.
*/
if (global_ptrace == 0 && !inferior(tr, p->p_p) &&
(error = suser(p, 0)) != 0)
return (error);
/*
* (5) ...it's init, which controls the security level
* of the entire system, and the system was not
* compiled with permanently insecure mode turned
* on.
*/
if ((tr->ps_pid == 1) && (securelevel > -1))
return (EPERM);
/*
* (6) it's an ancestor of the current process and
* not init (because that would create a loop in
* the process graph).
*/
if (tr->ps_pid != 1 && inferior(p->p_p, tr))
return (EINVAL);
break;
case PT_READ_I:
case PT_READ_D:
case PT_WRITE_I:
case PT_WRITE_D:
case PT_IO:
case PT_CONTINUE:
case PT_KILL:
case PT_DETACH:
#ifdef PT_STEP
case PT_STEP:
#endif
case PT_SET_EVENT_MASK:
case PT_GET_EVENT_MASK:
case PT_GET_PROCESS_STATE:
case PT_GETREGS:
case PT_SETREGS:
#ifdef PT_GETFPREGS
case PT_GETFPREGS:
#endif
#ifdef PT_SETFPREGS
case PT_SETFPREGS:
#endif
#ifdef PT_GETXMMREGS
case PT_GETXMMREGS:
#endif
#ifdef PT_SETXMMREGS
case PT_SETXMMREGS:
#endif
#ifdef PT_WCOOKIE
case PT_WCOOKIE:
#endif
/*
* You can't do what you want to the process if:
* (1) It's not being traced at all,
*/
if (!ISSET(tr->ps_flags, PS_TRACED))
return (EPERM);
/*
* (2) it's not being traced by _you_, or
*/
if (tr->ps_pptr != p->p_p)
return (EBUSY);
/*
* (3) it's not currently stopped.
*/
if (t->p_stat != SSTOP || !ISSET(tr->ps_flags, PS_WAITED))
return (EBUSY);
break;
case PT_GET_THREAD_FIRST:
case PT_GET_THREAD_NEXT:
/*
* You can't do what you want to the process if:
* (1) It's not being traced at all,
*/
if (!ISSET(tr->ps_flags, PS_TRACED))
return (EPERM);
/*
* (2) it's not being traced by _you_, or
*/
if (tr->ps_pptr != p->p_p)
return (EBUSY);
/*
* Do the work here because the request isn't actually
* associated with 't'
*/
if (SCARG(uap, data) != sizeof(pts))
return (EINVAL);
if (req == PT_GET_THREAD_NEXT) {
error = copyin(SCARG(uap, addr), &pts, sizeof(pts));
if (error)
return (error);
t = pfind(pts.pts_tid - THREAD_PID_OFFSET);
if (t == NULL || ISSET(t->p_flag, P_WEXIT))
return (ESRCH);
if (t->p_p != tr)
return (EINVAL);
t = TAILQ_NEXT(t, p_thr_link);
} else {
t = TAILQ_FIRST(&tr->ps_threads);
}
if (t == NULL)
pts.pts_tid = -1;
else
pts.pts_tid = t->p_pid + THREAD_PID_OFFSET;
return (copyout(&pts, SCARG(uap, addr), sizeof(pts)));
default: /* It was not a legal request. */
return (EINVAL);
}
/* Do single-step fixup if needed. */
FIX_SSTEP(t);
/* Now do the operation. */
write = 0;
*retval = 0;
switch (req) {
case PT_TRACE_ME:
/* Just set the trace flag. */
atomic_setbits_int(&tr->ps_flags, PS_TRACED);
tr->ps_oppid = tr->ps_pptr->ps_pid;
if (tr->ps_ptstat == NULL)
tr->ps_ptstat = malloc(sizeof(*tr->ps_ptstat),
M_SUBPROC, M_WAITOK);
memset(tr->ps_ptstat, 0, sizeof(*tr->ps_ptstat));
return (0);
case PT_WRITE_I: /* XXX no separate I and D spaces */
case PT_WRITE_D:
write = 1;
temp = SCARG(uap, data);
case PT_READ_I: /* XXX no separate I and D spaces */
case PT_READ_D:
/* write = 0 done above. */
iov.iov_base = (caddr_t)&temp;
iov.iov_len = sizeof(int);
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
uio.uio_offset = (off_t)(vaddr_t)SCARG(uap, addr);
uio.uio_resid = sizeof(int);
uio.uio_segflg = UIO_SYSSPACE;
uio.uio_rw = write ? UIO_WRITE : UIO_READ;
uio.uio_procp = p;
error = process_domem(p, t, &uio, write ? PT_WRITE_I :
PT_READ_I);
if (write == 0)
*retval = temp;
return (error);
case PT_IO:
error = copyin(SCARG(uap, addr), &piod, sizeof(piod));
if (error)
return (error);
iov.iov_base = piod.piod_addr;
iov.iov_len = piod.piod_len;
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
uio.uio_offset = (off_t)(vaddr_t)piod.piod_offs;
uio.uio_resid = piod.piod_len;
uio.uio_segflg = UIO_USERSPACE;
uio.uio_procp = p;
switch (piod.piod_op) {
case PIOD_READ_I:
req = PT_READ_I;
uio.uio_rw = UIO_READ;
break;
case PIOD_READ_D:
req = PT_READ_D;
uio.uio_rw = UIO_READ;
break;
case PIOD_WRITE_I:
req = PT_WRITE_I;
uio.uio_rw = UIO_WRITE;
break;
case PIOD_WRITE_D:
req = PT_WRITE_D;
uio.uio_rw = UIO_WRITE;
break;
case PIOD_READ_AUXV:
req = PT_READ_D;
uio.uio_rw = UIO_READ;
temp = tr->ps_emul->e_arglen * sizeof(char *);
if (uio.uio_offset > temp)
return (EIO);
if (uio.uio_resid > temp - uio.uio_offset)
uio.uio_resid = temp - uio.uio_offset;
piod.piod_len = iov.iov_len = uio.uio_resid;
error = process_auxv_offset(p, t, &uio);
if (error)
return (error);
break;
default:
return (EINVAL);
}
error = process_domem(p, t, &uio, req);
piod.piod_len -= uio.uio_resid;
(void) copyout(&piod, SCARG(uap, addr), sizeof(piod));
return (error);
#ifdef PT_STEP
case PT_STEP:
/*
* From the 4.4BSD PRM:
* "Execution continues as in request PT_CONTINUE; however
* as soon as possible after execution of at least one
* instruction, execution stops again. [ ... ]"
*/
#endif
case PT_CONTINUE:
/*
* From the 4.4BSD PRM:
* "The data argument is taken as a signal number and the
* child's execution continues at location addr as if it
* incurred that signal. Normally the signal number will
* be either 0 to indicate that the signal that caused the
* stop should be ignored, or that value fetched out of
* the process's image indicating which signal caused
* the stop. If addr is (int *)1 then execution continues
* from where it stopped."
*/
if (SCARG(uap, pid) < THREAD_PID_OFFSET && tr->ps_single)
t = tr->ps_single;
/* Check that the data is a valid signal number or zero. */
if (SCARG(uap, data) < 0 || SCARG(uap, data) >= NSIG)
return (EINVAL);
/* If the address parameter is not (int *)1, set the pc. */
if ((int *)SCARG(uap, addr) != (int *)1)
if ((error = process_set_pc(t, SCARG(uap, addr))) != 0)
goto relebad;
#ifdef PT_STEP
/*
* Arrange for a single-step, if that's requested and possible.
*/
error = process_sstep(t, req == PT_STEP);
if (error)
goto relebad;
#endif
goto sendsig;
case PT_DETACH:
/*
* From the 4.4BSD PRM:
* "The data argument is taken as a signal number and the
* child's execution continues at location addr as if it
* incurred that signal. Normally the signal number will
* be either 0 to indicate that the signal that caused the
* stop should be ignored, or that value fetched out of
* the process's image indicating which signal caused
* the stop. If addr is (int *)1 then execution continues
* from where it stopped."
*/
if (SCARG(uap, pid) < THREAD_PID_OFFSET && tr->ps_single)
t = tr->ps_single;
/* Check that the data is a valid signal number or zero. */
if (SCARG(uap, data) < 0 || SCARG(uap, data) >= NSIG)
return (EINVAL);
#ifdef PT_STEP
/*
* Arrange for a single-step, if that's requested and possible.
*/
error = process_sstep(t, req == PT_STEP);
if (error)
goto relebad;
#endif
/* give process back to original parent or init */
if (tr->ps_oppid != tr->ps_pptr->ps_pid) {
struct process *ppr;
ppr = prfind(tr->ps_oppid);
proc_reparent(tr, ppr ? ppr : initprocess);
}
/* not being traced any more */
tr->ps_oppid = 0;
atomic_clearbits_int(&tr->ps_flags, PS_TRACED|PS_WAITED);
sendsig:
memset(tr->ps_ptstat, 0, sizeof(*tr->ps_ptstat));
/* Finally, deliver the requested signal (or none). */
if (t->p_stat == SSTOP) {
t->p_xstat = SCARG(uap, data);
SCHED_LOCK(s);
setrunnable(t);
SCHED_UNLOCK(s);
} else {
if (SCARG(uap, data) != 0)
psignal(t, SCARG(uap, data));
}
return (0);
relebad:
return (error);
case PT_KILL:
if (SCARG(uap, pid) < THREAD_PID_OFFSET && tr->ps_single)
t = tr->ps_single;
/* just send the process a KILL signal. */
SCARG(uap, data) = SIGKILL;
goto sendsig; /* in PT_CONTINUE, above. */
case PT_ATTACH:
/*
* As was done in procfs:
* Go ahead and set the trace flag.
* Save the old parent (it's reset in
* _DETACH, and also in kern_exit.c:wait4()
* Reparent the process so that the tracing
* proc gets to see all the action.
* Stop the target.
*/
atomic_setbits_int(&tr->ps_flags, PS_TRACED);
tr->ps_oppid = tr->ps_pptr->ps_pid;
if (tr->ps_pptr != p->p_p)
proc_reparent(tr, p->p_p);
if (tr->ps_ptstat == NULL)
tr->ps_ptstat = malloc(sizeof(*tr->ps_ptstat),
M_SUBPROC, M_WAITOK);
SCARG(uap, data) = SIGSTOP;
goto sendsig;
case PT_GET_EVENT_MASK:
if (SCARG(uap, data) != sizeof(pe))
return (EINVAL);
memset(&pe, 0, sizeof(pe));
pe.pe_set_event = tr->ps_ptmask;
return (copyout(&pe, SCARG(uap, addr), sizeof(pe)));
case PT_SET_EVENT_MASK:
if (SCARG(uap, data) != sizeof(pe))
return (EINVAL);
if ((error = copyin(SCARG(uap, addr), &pe, sizeof(pe))))
return (error);
tr->ps_ptmask = pe.pe_set_event;
return (0);
case PT_GET_PROCESS_STATE:
if (SCARG(uap, data) != sizeof(*tr->ps_ptstat))
return (EINVAL);
if (tr->ps_single)
tr->ps_ptstat->pe_tid =
tr->ps_single->p_pid + THREAD_PID_OFFSET;
return (copyout(tr->ps_ptstat, SCARG(uap, addr),
sizeof(*tr->ps_ptstat)));
case PT_SETREGS:
KASSERT((p->p_flag & P_SYSTEM) == 0);
if ((error = process_checkioperm(p, tr)) != 0)
return (error);
regs = malloc(sizeof(*regs), M_TEMP, M_WAITOK);
error = copyin(SCARG(uap, addr), regs, sizeof(*regs));
if (error == 0) {
error = process_write_regs(t, regs);
}
free(regs, M_TEMP, sizeof(*regs));
return (error);
case PT_GETREGS:
KASSERT((p->p_flag & P_SYSTEM) == 0);
if ((error = process_checkioperm(p, tr)) != 0)
return (error);
regs = malloc(sizeof(*regs), M_TEMP, M_WAITOK);
error = process_read_regs(t, regs);
if (error == 0)
error = copyout(regs,
SCARG(uap, addr), sizeof (*regs));
free(regs, M_TEMP, sizeof(*regs));
return (error);
#ifdef PT_SETFPREGS
case PT_SETFPREGS:
KASSERT((p->p_flag & P_SYSTEM) == 0);
if ((error = process_checkioperm(p, tr)) != 0)
return (error);
fpregs = malloc(sizeof(*fpregs), M_TEMP, M_WAITOK);
error = copyin(SCARG(uap, addr), fpregs, sizeof(*fpregs));
if (error == 0) {
error = process_write_fpregs(t, fpregs);
}
free(fpregs, M_TEMP, sizeof(*fpregs));
return (error);
#endif
#ifdef PT_GETFPREGS
case PT_GETFPREGS:
KASSERT((p->p_flag & P_SYSTEM) == 0);
if ((error = process_checkioperm(p, tr)) != 0)
return (error);
fpregs = malloc(sizeof(*fpregs), M_TEMP, M_WAITOK);
error = process_read_fpregs(t, fpregs);
if (error == 0)
error = copyout(fpregs,
SCARG(uap, addr), sizeof(*fpregs));
free(fpregs, M_TEMP, sizeof(*fpregs));
return (error);
#endif
#ifdef PT_SETXMMREGS
case PT_SETXMMREGS:
KASSERT((p->p_flag & P_SYSTEM) == 0);
if ((error = process_checkioperm(p, tr)) != 0)
return (error);
xmmregs = malloc(sizeof(*xmmregs), M_TEMP, M_WAITOK);
error = copyin(SCARG(uap, addr), xmmregs, sizeof(*xmmregs));
if (error == 0) {
error = process_write_xmmregs(t, xmmregs);
}
free(xmmregs, M_TEMP, sizeof(*xmmregs));
return (error);
#endif
#ifdef PT_GETXMMREGS
case PT_GETXMMREGS:
KASSERT((p->p_flag & P_SYSTEM) == 0);
if ((error = process_checkioperm(p, tr)) != 0)
return (error);
xmmregs = malloc(sizeof(*xmmregs), M_TEMP, M_WAITOK);
error = process_read_xmmregs(t, xmmregs);
if (error == 0)
error = copyout(xmmregs,
SCARG(uap, addr), sizeof(*xmmregs));
free(xmmregs, M_TEMP, sizeof(*xmmregs));
return (error);
#endif
#ifdef PT_WCOOKIE
case PT_WCOOKIE:
wcookie = process_get_wcookie (t);
return (copyout(&wcookie, SCARG(uap, addr),
sizeof (register_t)));
#endif
}
#ifdef DIAGNOSTIC
panic("ptrace: impossible");
#endif
return 0;
}
void
linux_sendsig(const ksiginfo_t *ksi, const sigset_t *mask)
{
struct lwp *l = curlwp;
struct proc *p = l->l_proc;
struct sigacts *ps = p->p_sigacts;
int onstack, error;
int sig = ksi->ksi_signo;
struct linux_rt_sigframe *sfp, sigframe;
struct linux__fpstate *fpsp, fpstate;
struct fpreg fpregs;
struct trapframe *tf = l->l_md.md_regs;
sig_t catcher = SIGACTION(p, sig).sa_handler;
linux_sigset_t lmask;
char *sp;
/* Do we need to jump onto the signal stack? */
onstack =
(l->l_sigstk.ss_flags & (SS_DISABLE | SS_ONSTACK)) == 0 &&
(SIGACTION(p, sig).sa_flags & SA_ONSTACK) != 0;
/* Allocate space for the signal handler context. */
if (onstack)
sp = ((char *)l->l_sigstk.ss_sp +
l->l_sigstk.ss_size);
else
sp = (char *)tf->tf_rsp - 128;
/*
* Save FPU state, if any
*/
if (l->l_md.md_flags & MDP_USEDFPU) {
sp = (char *)
(((long)sp - sizeof(struct linux__fpstate)) & ~0xfUL);
fpsp = (struct linux__fpstate *)sp;
} else
fpsp = NULL;
/*
* Populate the rt_sigframe
*/
sp = (char *)
((((long)sp - sizeof(struct linux_rt_sigframe)) & ~0xfUL) - 8);
sfp = (struct linux_rt_sigframe *)sp;
bzero(&sigframe, sizeof(sigframe));
if (ps->sa_sigdesc[sig].sd_vers != 0)
sigframe.pretcode =
(char *)(u_long)ps->sa_sigdesc[sig].sd_tramp;
else
sigframe.pretcode = NULL;
/*
* The user context
*/
sigframe.uc.luc_flags = 0;
sigframe.uc.luc_link = NULL;
/* This is used regardless of SA_ONSTACK in Linux */
sigframe.uc.luc_stack.ss_sp = l->l_sigstk.ss_sp;
sigframe.uc.luc_stack.ss_size = l->l_sigstk.ss_size;
sigframe.uc.luc_stack.ss_flags = 0;
if (l->l_sigstk.ss_flags & SS_ONSTACK)
sigframe.uc.luc_stack.ss_flags |= LINUX_SS_ONSTACK;
if (l->l_sigstk.ss_flags & SS_DISABLE)
sigframe.uc.luc_stack.ss_flags |= LINUX_SS_DISABLE;
sigframe.uc.luc_mcontext.r8 = tf->tf_r8;
sigframe.uc.luc_mcontext.r9 = tf->tf_r9;
sigframe.uc.luc_mcontext.r10 = tf->tf_r10;
sigframe.uc.luc_mcontext.r11 = tf->tf_r11;
sigframe.uc.luc_mcontext.r12 = tf->tf_r12;
sigframe.uc.luc_mcontext.r13 = tf->tf_r13;
sigframe.uc.luc_mcontext.r14 = tf->tf_r14;
sigframe.uc.luc_mcontext.r15 = tf->tf_r15;
sigframe.uc.luc_mcontext.rdi = tf->tf_rdi;
sigframe.uc.luc_mcontext.rsi = tf->tf_rsi;
sigframe.uc.luc_mcontext.rbp = tf->tf_rbp;
sigframe.uc.luc_mcontext.rbx = tf->tf_rbx;
sigframe.uc.luc_mcontext.rdx = tf->tf_rdx;
sigframe.uc.luc_mcontext.rax = tf->tf_rax;
sigframe.uc.luc_mcontext.rcx = tf->tf_rcx;
sigframe.uc.luc_mcontext.rsp = tf->tf_rsp;
sigframe.uc.luc_mcontext.rip = tf->tf_rip;
sigframe.uc.luc_mcontext.eflags = tf->tf_rflags;
sigframe.uc.luc_mcontext.cs = tf->tf_cs;
sigframe.uc.luc_mcontext.gs = tf->tf_gs;
sigframe.uc.luc_mcontext.fs = tf->tf_fs;
sigframe.uc.luc_mcontext.err = tf->tf_err;
sigframe.uc.luc_mcontext.trapno = tf->tf_trapno;
native_to_linux_sigset(&lmask, mask);
sigframe.uc.luc_mcontext.oldmask = lmask.sig[0];
sigframe.uc.luc_mcontext.cr2 = (long)l->l_addr->u_pcb.pcb_onfault;
sigframe.uc.luc_mcontext.fpstate = fpsp;
native_to_linux_sigset(&sigframe.uc.luc_sigmask, mask);
/*
* the siginfo structure
*/
sigframe.info.lsi_signo = native_to_linux_signo[sig];
sigframe.info.lsi_errno = native_to_linux_errno[ksi->ksi_errno];
sigframe.info.lsi_code = native_to_linux_si_code(ksi->ksi_code);
/* XXX This is a rought conversion, taken from i386 code */
switch (sigframe.info.lsi_signo) {
case LINUX_SIGILL:
case LINUX_SIGFPE:
case LINUX_SIGSEGV:
case LINUX_SIGBUS:
case LINUX_SIGTRAP:
sigframe.info._sifields._sigfault._addr = ksi->ksi_addr;
break;
case LINUX_SIGCHLD:
sigframe.info._sifields._sigchld._pid = ksi->ksi_pid;
sigframe.info._sifields._sigchld._uid = ksi->ksi_uid;
sigframe.info._sifields._sigchld._utime = ksi->ksi_utime;
sigframe.info._sifields._sigchld._stime = ksi->ksi_stime;
if (WCOREDUMP(ksi->ksi_status)) {
sigframe.info.lsi_code = LINUX_CLD_DUMPED;
sigframe.info._sifields._sigchld._status =
_WSTATUS(ksi->ksi_status);
} else if (_WSTATUS(ksi->ksi_status)) {
sigframe.info.lsi_code = LINUX_CLD_KILLED;
sigframe.info._sifields._sigchld._status =
_WSTATUS(ksi->ksi_status);
} else {
sigframe.info.lsi_code = LINUX_CLD_EXITED;
sigframe.info._sifields._sigchld._status =
((ksi->ksi_status & 0xff00U) >> 8);
}
break;
case LINUX_SIGIO:
sigframe.info._sifields._sigpoll._band = ksi->ksi_band;
sigframe.info._sifields._sigpoll._fd = ksi->ksi_fd;
break;
default:
sigframe.info._sifields._sigchld._pid = ksi->ksi_pid;
sigframe.info._sifields._sigchld._uid = ksi->ksi_uid;
if ((sigframe.info.lsi_signo == LINUX_SIGALRM) ||
(sigframe.info.lsi_signo >= LINUX_SIGRTMIN))
sigframe.info._sifields._timer._sigval.sival_ptr =
ksi->ksi_value.sival_ptr;
break;
}
sendsig_reset(l, sig);
mutex_exit(p->p_lock);
error = 0;
/*
* Save FPU state, if any
*/
if (fpsp != NULL) {
(void)process_read_fpregs(l, &fpregs);
bzero(&fpstate, sizeof(fpstate));
fpstate.cwd = fpregs.fp_fcw;
fpstate.swd = fpregs.fp_fsw;
fpstate.twd = fpregs.fp_ftw;
fpstate.fop = fpregs.fp_fop;
fpstate.rip = fpregs.fp_rip;
fpstate.rdp = fpregs.fp_rdp;
fpstate.mxcsr = fpregs.fp_mxcsr;
fpstate.mxcsr_mask = fpregs.fp_mxcsr_mask;
memcpy(&fpstate.st_space, &fpregs.fp_st,
sizeof(fpstate.st_space));
memcpy(&fpstate.xmm_space, &fpregs.fp_xmm,
sizeof(fpstate.xmm_space));
error = copyout(&fpstate, fpsp, sizeof(fpstate));
}
if (error == 0)
error = copyout(&sigframe, sp, sizeof(sigframe));
mutex_enter(p->p_lock);
if (error != 0) {
sigexit(l, SIGILL);
return;
}
linux_buildcontext(l, catcher, sp);
tf->tf_rdi = sigframe.info.lsi_signo;
tf->tf_rax = 0;
tf->tf_rsi = (long)&sfp->info;
tf->tf_rdx = (long)&sfp->uc;
/*
* Remember we use signal stack
*/
if (onstack)
l->l_sigstk.ss_flags |= SS_ONSTACK;
return;
}
