1 /*-
2 * Copyright (C) 1995, 1996 Wolfgang Solfrank.
3 * Copyright (C) 1995, 1996 TooLs GmbH.
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. All advertising materials mentioning features or use of this software
15 * must display the following acknowledgement:
16 * This product includes software developed by TooLs GmbH.
17 * 4. The name of TooLs GmbH may not be used to endorse or promote products
18 * derived from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23 * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
26 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
27 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
28 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
29 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31 /*-
32 * Copyright (C) 2001 Benno Rice
33 * All rights reserved.
34 *
35 * Redistribution and use in source and binary forms, with or without
36 * modification, are permitted provided that the following conditions
37 * are met:
38 * 1. Redistributions of source code must retain the above copyright
39 * notice, this list of conditions and the following disclaimer.
40 * 2. Redistributions in binary form must reproduce the above copyright
41 * notice, this list of conditions and the following disclaimer in the
42 * documentation and/or other materials provided with the distribution.
43 *
44 * THIS SOFTWARE IS PROVIDED BY Benno Rice ``AS IS'' AND ANY EXPRESS OR
45 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
46 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
47 * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
48 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
49 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
50 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
51 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
52 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
53 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
54 * $NetBSD: machdep.c,v 1.74.2.1 2000/11/01 16:13:48 tv Exp $
55 */
56
57 #include <sys/cdefs.h>
58 __FBSDID("$FreeBSD: releng/11.1/sys/powerpc/powerpc/exec_machdep.c 301961 2016-06-16 12:05:44Z kib $");
59
60 #include "opt_compat.h"
61 #include "opt_fpu_emu.h"
62
63 #include <sys/param.h>
64 #include <sys/proc.h>
65 #include <sys/systm.h>
66 #include <sys/bio.h>
67 #include <sys/buf.h>
68 #include <sys/bus.h>
69 #include <sys/cons.h>
70 #include <sys/cpu.h>
71 #include <sys/exec.h>
72 #include <sys/imgact.h>
73 #include <sys/kernel.h>
74 #include <sys/ktr.h>
75 #include <sys/lock.h>
76 #include <sys/malloc.h>
77 #include <sys/mutex.h>
78 #include <sys/signalvar.h>
79 #include <sys/syscallsubr.h>
80 #include <sys/syscall.h>
81 #include <sys/sysent.h>
82 #include <sys/sysproto.h>
83 #include <sys/ucontext.h>
84 #include <sys/uio.h>
85
86 #include <machine/altivec.h>
87 #include <machine/cpu.h>
88 #include <machine/elf.h>
89 #include <machine/fpu.h>
90 #include <machine/pcb.h>
91 #include <machine/reg.h>
92 #include <machine/sigframe.h>
93 #include <machine/trap.h>
94 #include <machine/vmparam.h>
95
96 #ifdef FPU_EMU
97 #include <powerpc/fpu/fpu_extern.h>
98 #endif
99
100 #ifdef COMPAT_FREEBSD32
101 #include <compat/freebsd32/freebsd32_signal.h>
102 #include <compat/freebsd32/freebsd32_util.h>
103 #include <compat/freebsd32/freebsd32_proto.h>
104
105 typedef struct __ucontext32 {
106 sigset_t uc_sigmask;
107 mcontext32_t uc_mcontext;
108 uint32_t uc_link;
109 struct sigaltstack32 uc_stack;
110 uint32_t uc_flags;
111 uint32_t __spare__[4];
112 } ucontext32_t;
113
114 struct sigframe32 {
115 ucontext32_t sf_uc;
116 struct siginfo32 sf_si;
117 };
118
119 static int grab_mcontext32(struct thread *td, mcontext32_t *, int flags);
120 #endif
121
122 static int grab_mcontext(struct thread *, mcontext_t *, int);
123
124 void
125 sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
126 {
127 struct trapframe *tf;
128 struct sigacts *psp;
129 struct sigframe sf;
130 struct thread *td;
131 struct proc *p;
132 #ifdef COMPAT_FREEBSD32
133 struct siginfo32 siginfo32;
134 struct sigframe32 sf32;
135 #endif
136 size_t sfpsize;
137 caddr_t sfp, usfp;
138 int oonstack, rndfsize;
139 int sig;
140 int code;
141
142 td = curthread;
143 p = td->td_proc;
144 PROC_LOCK_ASSERT(p, MA_OWNED);
145
146 psp = p->p_sigacts;
147 mtx_assert(&psp->ps_mtx, MA_OWNED);
148 tf = td->td_frame;
149 oonstack = sigonstack(tf->fixreg[1]);
150
151 /*
152 * Fill siginfo structure.
153 */
154 ksi->ksi_info.si_signo = ksi->ksi_signo;
155 ksi->ksi_info.si_addr = (void *)((tf->exc == EXC_DSI) ?
156 tf->dar : tf->srr0);
157
158 #ifdef COMPAT_FREEBSD32
159 if (SV_PROC_FLAG(p, SV_ILP32)) {
160 siginfo_to_siginfo32(&ksi->ksi_info, &siginfo32);
161 sig = siginfo32.si_signo;
162 code = siginfo32.si_code;
163 sfp = (caddr_t)&sf32;
164 sfpsize = sizeof(sf32);
165 rndfsize = roundup(sizeof(sf32), 16);
166
167 /*
168 * Save user context
169 */
170
171 memset(&sf32, 0, sizeof(sf32));
172 grab_mcontext32(td, &sf32.sf_uc.uc_mcontext, 0);
173
174 sf32.sf_uc.uc_sigmask = *mask;
175 sf32.sf_uc.uc_stack.ss_sp = (uintptr_t)td->td_sigstk.ss_sp;
176 sf32.sf_uc.uc_stack.ss_size = (uint32_t)td->td_sigstk.ss_size;
177 sf32.sf_uc.uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK)
178 ? ((oonstack) ? SS_ONSTACK : 0) : SS_DISABLE;
179
180 sf32.sf_uc.uc_mcontext.mc_onstack = (oonstack) ? 1 : 0;
181 } else {
182 #endif
183 sig = ksi->ksi_signo;
184 code = ksi->ksi_code;
185 sfp = (caddr_t)&sf;
186 sfpsize = sizeof(sf);
187 #ifdef __powerpc64__
188 /*
189 * 64-bit PPC defines a 288 byte scratch region
190 * below the stack.
191 */
192 rndfsize = 288 + roundup(sizeof(sf), 48);
193 #else
194 rndfsize = roundup(sizeof(sf), 16);
195 #endif
196
197 /*
198 * Save user context
199 */
200
201 memset(&sf, 0, sizeof(sf));
202 grab_mcontext(td, &sf.sf_uc.uc_mcontext, 0);
203
204 sf.sf_uc.uc_sigmask = *mask;
205 sf.sf_uc.uc_stack = td->td_sigstk;
206 sf.sf_uc.uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK)
207 ? ((oonstack) ? SS_ONSTACK : 0) : SS_DISABLE;
208
209 sf.sf_uc.uc_mcontext.mc_onstack = (oonstack) ? 1 : 0;
210 #ifdef COMPAT_FREEBSD32
211 }
212 #endif
213
214 CTR4(KTR_SIG, "sendsig: td=%p (%s) catcher=%p sig=%d", td, p->p_comm,
215 catcher, sig);
216
217 /*
218 * Allocate and validate space for the signal handler context.
219 */
220 if ((td->td_pflags & TDP_ALTSTACK) != 0 && !oonstack &&
221 SIGISMEMBER(psp->ps_sigonstack, sig)) {
222 usfp = (void *)(((uintptr_t)td->td_sigstk.ss_sp +
223 td->td_sigstk.ss_size - rndfsize) & ~0xFul);
224 } else {
225 usfp = (void *)((tf->fixreg[1] - rndfsize) & ~0xFul);
226 }
227
228 /*
229 * Save the floating-point state, if necessary, then copy it.
230 */
231 /* XXX */
232
233 /*
234 * Set up the registers to return to sigcode.
235 *
236 * r1/sp - sigframe ptr
237 * lr - sig function, dispatched to by blrl in trampoline
238 * r3 - sig number
239 * r4 - SIGINFO ? &siginfo : exception code
240 * r5 - user context
241 * srr0 - trampoline function addr
242 */
243 tf->lr = (register_t)catcher;
244 tf->fixreg[1] = (register_t)usfp;
245 tf->fixreg[FIRSTARG] = sig;
246 #ifdef COMPAT_FREEBSD32
247 tf->fixreg[FIRSTARG+2] = (register_t)usfp +
248 ((SV_PROC_FLAG(p, SV_ILP32)) ?
249 offsetof(struct sigframe32, sf_uc) :
250 offsetof(struct sigframe, sf_uc));
251 #else
252 tf->fixreg[FIRSTARG+2] = (register_t)usfp +
253 offsetof(struct sigframe, sf_uc);
254 #endif
255 if (SIGISMEMBER(psp->ps_siginfo, sig)) {
256 /*
257 * Signal handler installed with SA_SIGINFO.
258 */
259 #ifdef COMPAT_FREEBSD32
260 if (SV_PROC_FLAG(p, SV_ILP32)) {
261 sf32.sf_si = siginfo32;
262 tf->fixreg[FIRSTARG+1] = (register_t)usfp +
263 offsetof(struct sigframe32, sf_si);
264 sf32.sf_si = siginfo32;
265 } else {
266 #endif
267 tf->fixreg[FIRSTARG+1] = (register_t)usfp +
268 offsetof(struct sigframe, sf_si);
269 sf.sf_si = ksi->ksi_info;
270 #ifdef COMPAT_FREEBSD32
271 }
272 #endif
273 } else {
274 /* Old FreeBSD-style arguments. */
275 tf->fixreg[FIRSTARG+1] = code;
276 tf->fixreg[FIRSTARG+3] = (tf->exc == EXC_DSI) ?
277 tf->dar : tf->srr0;
278 }
279 mtx_unlock(&psp->ps_mtx);
280 PROC_UNLOCK(p);
281
282 tf->srr0 = (register_t)p->p_sysent->sv_sigcode_base;
283
284 /*
285 * copy the frame out to userland.
286 */
287 if (copyout(sfp, usfp, sfpsize) != 0) {
288 /*
289 * Process has trashed its stack. Kill it.
290 */
291 CTR2(KTR_SIG, "sendsig: sigexit td=%p sfp=%p", td, sfp);
292 PROC_LOCK(p);
293 sigexit(td, SIGILL);
294 }
295
296 CTR3(KTR_SIG, "sendsig: return td=%p pc=%#x sp=%#x", td,
297 tf->srr0, tf->fixreg[1]);
298
299 PROC_LOCK(p);
300 mtx_lock(&psp->ps_mtx);
301 }
302
303 int
304 sys_sigreturn(struct thread *td, struct sigreturn_args *uap)
305 {
306 ucontext_t uc;
307 int error;
308
309 CTR2(KTR_SIG, "sigreturn: td=%p ucp=%p", td, uap->sigcntxp);
310
311 if (copyin(uap->sigcntxp, &uc, sizeof(uc)) != 0) {
312 CTR1(KTR_SIG, "sigreturn: efault td=%p", td);
313 return (EFAULT);
314 }
315
316 error = set_mcontext(td, &uc.uc_mcontext);
317 if (error != 0)
318 return (error);
319
320 kern_sigprocmask(td, SIG_SETMASK, &uc.uc_sigmask, NULL, 0);
321
322 CTR3(KTR_SIG, "sigreturn: return td=%p pc=%#x sp=%#x",
323 td, uc.uc_mcontext.mc_srr0, uc.uc_mcontext.mc_gpr[1]);
324
325 return (EJUSTRETURN);
326 }
327
328 #ifdef COMPAT_FREEBSD4
329 int
330 freebsd4_sigreturn(struct thread *td, struct freebsd4_sigreturn_args *uap)
331 {
332
333 return sys_sigreturn(td, (struct sigreturn_args *)uap);
334 }
335 #endif
336
337 /*
338 * Construct a PCB from a trapframe. This is called from kdb_trap() where
339 * we want to start a backtrace from the function that caused us to enter
340 * the debugger. We have the context in the trapframe, but base the trace
341 * on the PCB. The PCB doesn't have to be perfect, as long as it contains
342 * enough for a backtrace.
343 */
344 void
345 makectx(struct trapframe *tf, struct pcb *pcb)
346 {
347
348 pcb->pcb_lr = tf->srr0;
349 pcb->pcb_sp = tf->fixreg[1];
350 }
351
352 /*
353 * get_mcontext/sendsig helper routine that doesn't touch the
354 * proc lock
355 */
356 static int
357 grab_mcontext(struct thread *td, mcontext_t *mcp, int flags)
358 {
359 struct pcb *pcb;
360 int i;
361
362 pcb = td->td_pcb;
363
364 memset(mcp, 0, sizeof(mcontext_t));
365
366 mcp->mc_vers = _MC_VERSION;
367 mcp->mc_flags = 0;
368 memcpy(&mcp->mc_frame, td->td_frame, sizeof(struct trapframe));
369 if (flags & GET_MC_CLEAR_RET) {
370 mcp->mc_gpr[3] = 0;
371 mcp->mc_gpr[4] = 0;
372 }
373
374 /*
375 * This assumes that floating-point context is *not* lazy,
376 * so if the thread has used FP there would have been a
377 * FP-unavailable exception that would have set things up
378 * correctly.
379 */
380 if (pcb->pcb_flags & PCB_FPREGS) {
381 if (pcb->pcb_flags & PCB_FPU) {
382 KASSERT(td == curthread,
383 ("get_mcontext: fp save not curthread"));
384 critical_enter();
385 save_fpu(td);
386 critical_exit();
387 }
388 mcp->mc_flags |= _MC_FP_VALID;
389 memcpy(&mcp->mc_fpscr, &pcb->pcb_fpu.fpscr, sizeof(double));
390 for (i = 0; i < 32; i++)
391 memcpy(&mcp->mc_fpreg[i], &pcb->pcb_fpu.fpr[i].fpr,
392 sizeof(double));
393 }
394
395 if (pcb->pcb_flags & PCB_VSX) {
396 for (i = 0; i < 32; i++)
397 memcpy(&mcp->mc_vsxfpreg[i],
398 &pcb->pcb_fpu.fpr[i].vsr[2], sizeof(double));
399 }
400
401 /*
402 * Repeat for Altivec context
403 */
404
405 if (pcb->pcb_flags & PCB_VEC) {
406 KASSERT(td == curthread,
407 ("get_mcontext: fp save not curthread"));
408 critical_enter();
409 save_vec(td);
410 critical_exit();
411 mcp->mc_flags |= _MC_AV_VALID;
412 mcp->mc_vscr = pcb->pcb_vec.vscr;
413 mcp->mc_vrsave = pcb->pcb_vec.vrsave;
414 memcpy(mcp->mc_avec, pcb->pcb_vec.vr, sizeof(mcp->mc_avec));
415 }
416
417 mcp->mc_len = sizeof(*mcp);
418
419 return (0);
420 }
421
422 int
423 get_mcontext(struct thread *td, mcontext_t *mcp, int flags)
424 {
425 int error;
426
427 error = grab_mcontext(td, mcp, flags);
428 if (error == 0) {
429 PROC_LOCK(curthread->td_proc);
430 mcp->mc_onstack = sigonstack(td->td_frame->fixreg[1]);
431 PROC_UNLOCK(curthread->td_proc);
432 }
433
434 return (error);
435 }
436
437 int
438 set_mcontext(struct thread *td, mcontext_t *mcp)
439 {
440 struct pcb *pcb;
441 struct trapframe *tf;
442 register_t tls;
443 int i;
444
445 pcb = td->td_pcb;
446 tf = td->td_frame;
447
448 if (mcp->mc_vers != _MC_VERSION || mcp->mc_len != sizeof(*mcp))
449 return (EINVAL);
450
451 /*
452 * Don't let the user set privileged MSR bits
453 */
454 if ((mcp->mc_srr1 & PSL_USERSTATIC) != (tf->srr1 & PSL_USERSTATIC)) {
455 return (EINVAL);
456 }
457
458 /* Copy trapframe, preserving TLS pointer across context change */
459 if (SV_PROC_FLAG(td->td_proc, SV_LP64))
460 tls = tf->fixreg[13];
461 else
462 tls = tf->fixreg[2];
463 memcpy(tf, mcp->mc_frame, sizeof(mcp->mc_frame));
464 if (SV_PROC_FLAG(td->td_proc, SV_LP64))
465 tf->fixreg[13] = tls;
466 else
467 tf->fixreg[2] = tls;
468
469 if (mcp->mc_flags & _MC_FP_VALID) {
470 /* enable_fpu() will happen lazily on a fault */
471 pcb->pcb_flags |= PCB_FPREGS;
472 memcpy(&pcb->pcb_fpu.fpscr, &mcp->mc_fpscr, sizeof(double));
473 bzero(pcb->pcb_fpu.fpr, sizeof(pcb->pcb_fpu.fpr));
474 for (i = 0; i < 32; i++) {
475 memcpy(&pcb->pcb_fpu.fpr[i].fpr, &mcp->mc_fpreg[i],
476 sizeof(double));
477 memcpy(&pcb->pcb_fpu.fpr[i].vsr[2],
478 &mcp->mc_vsxfpreg[i], sizeof(double));
479 }
480 }
481
482 if (mcp->mc_flags & _MC_AV_VALID) {
483 if ((pcb->pcb_flags & PCB_VEC) != PCB_VEC) {
484 critical_enter();
485 enable_vec(td);
486 critical_exit();
487 }
488 pcb->pcb_vec.vscr = mcp->mc_vscr;
489 pcb->pcb_vec.vrsave = mcp->mc_vrsave;
490 memcpy(pcb->pcb_vec.vr, mcp->mc_avec, sizeof(mcp->mc_avec));
491 }
492
493 return (0);
494 }
495
496 /*
497 * Set set up registers on exec.
498 */
499 void
500 exec_setregs(struct thread *td, struct image_params *imgp, u_long stack)
501 {
502 struct trapframe *tf;
503 register_t argc;
504
505 tf = trapframe(td);
506 bzero(tf, sizeof *tf);
507 #ifdef __powerpc64__
508 tf->fixreg[1] = -roundup(-stack + 48, 16);
509 #else
510 tf->fixreg[1] = -roundup(-stack + 8, 16);
511 #endif
512
513 /*
514 * Set up arguments for _start():
515 * _start(argc, argv, envp, obj, cleanup, ps_strings);
516 *
517 * Notes:
518 * - obj and cleanup are the auxilliary and termination
519 * vectors. They are fixed up by ld.elf_so.
520 * - ps_strings is a NetBSD extention, and will be
521 * ignored by executables which are strictly
522 * compliant with the SVR4 ABI.
523 *
524 * XXX We have to set both regs and retval here due to different
525 * XXX calling convention in trap.c and init_main.c.
526 */
527
528 /* Collect argc from the user stack */
529 argc = fuword((void *)stack);
530
531 /*
532 * XXX PG: these get overwritten in the syscall return code.
533 * execve() should return EJUSTRETURN, like it does on NetBSD.
534 * Emulate by setting the syscall return value cells. The
535 * registers still have to be set for init's fork trampoline.
536 */
537 td->td_retval[0] = argc;
538 td->td_retval[1] = stack + sizeof(register_t);
539 tf->fixreg[3] = argc;
540 tf->fixreg[4] = stack + sizeof(register_t);
541 tf->fixreg[5] = stack + (2 + argc)*sizeof(register_t);
542 tf->fixreg[6] = 0; /* auxillary vector */
543 tf->fixreg[7] = 0; /* termination vector */
544 tf->fixreg[8] = (register_t)imgp->ps_strings; /* NetBSD extension */
545
546 tf->srr0 = imgp->entry_addr;
547 #ifdef __powerpc64__
548 tf->fixreg[12] = imgp->entry_addr;
549 tf->srr1 = PSL_SF | PSL_USERSET | PSL_FE_DFLT;
550 if (mfmsr() & PSL_HV)
551 tf->srr1 |= PSL_HV;
552 #else
553 tf->srr1 = PSL_USERSET | PSL_FE_DFLT;
554 #endif
555 td->td_pcb->pcb_flags = 0;
556 }
557
558 #ifdef COMPAT_FREEBSD32
559 void
560 ppc32_setregs(struct thread *td, struct image_params *imgp, u_long stack)
561 {
562 struct trapframe *tf;
563 uint32_t argc;
564
565 tf = trapframe(td);
566 bzero(tf, sizeof *tf);
567 tf->fixreg[1] = -roundup(-stack + 8, 16);
568
569 argc = fuword32((void *)stack);
570
571 td->td_retval[0] = argc;
572 td->td_retval[1] = stack + sizeof(uint32_t);
573 tf->fixreg[3] = argc;
574 tf->fixreg[4] = stack + sizeof(uint32_t);
575 tf->fixreg[5] = stack + (2 + argc)*sizeof(uint32_t);
576 tf->fixreg[6] = 0; /* auxillary vector */
577 tf->fixreg[7] = 0; /* termination vector */
578 tf->fixreg[8] = (register_t)imgp->ps_strings; /* NetBSD extension */
579
580 tf->srr0 = imgp->entry_addr;
581 tf->srr1 = PSL_USERSET | PSL_FE_DFLT;
582 tf->srr1 &= ~PSL_SF;
583 if (mfmsr() & PSL_HV)
584 tf->srr1 |= PSL_HV;
585 td->td_pcb->pcb_flags = 0;
586 }
587 #endif
588
589 int
590 fill_regs(struct thread *td, struct reg *regs)
591 {
592 struct trapframe *tf;
593
594 tf = td->td_frame;
595 memcpy(regs, tf, sizeof(struct reg));
596
597 return (0);
598 }
599
600 int
601 fill_dbregs(struct thread *td, struct dbreg *dbregs)
602 {
603 /* No debug registers on PowerPC */
604 return (ENOSYS);
605 }
606
607 int
608 fill_fpregs(struct thread *td, struct fpreg *fpregs)
609 {
610 struct pcb *pcb;
611 int i;
612
613 pcb = td->td_pcb;
614
615 if ((pcb->pcb_flags & PCB_FPREGS) == 0)
616 memset(fpregs, 0, sizeof(struct fpreg));
617 else {
618 memcpy(&fpregs->fpscr, &pcb->pcb_fpu.fpscr, sizeof(double));
619 for (i = 0; i < 32; i++)
620 memcpy(&fpregs->fpreg[i], &pcb->pcb_fpu.fpr[i].fpr,
621 sizeof(double));
622 }
623
624 return (0);
625 }
626
627 int
628 set_regs(struct thread *td, struct reg *regs)
629 {
630 struct trapframe *tf;
631
632 tf = td->td_frame;
633 memcpy(tf, regs, sizeof(struct reg));
634
635 return (0);
636 }
637
638 int
639 set_dbregs(struct thread *td, struct dbreg *dbregs)
640 {
641 /* No debug registers on PowerPC */
642 return (ENOSYS);
643 }
644
645 int
646 set_fpregs(struct thread *td, struct fpreg *fpregs)
647 {
648 struct pcb *pcb;
649 int i;
650
651 pcb = td->td_pcb;
652 pcb->pcb_flags |= PCB_FPREGS;
653 memcpy(&pcb->pcb_fpu.fpscr, &fpregs->fpscr, sizeof(double));
654 for (i = 0; i < 32; i++) {
655 memcpy(&pcb->pcb_fpu.fpr[i].fpr, &fpregs->fpreg[i],
656 sizeof(double));
657 }
658
659 return (0);
660 }
661
662 #ifdef COMPAT_FREEBSD32
663 int
664 set_regs32(struct thread *td, struct reg32 *regs)
665 {
666 struct trapframe *tf;
667 int i;
668
669 tf = td->td_frame;
670 for (i = 0; i < 32; i++)
671 tf->fixreg[i] = regs->fixreg[i];
672 tf->lr = regs->lr;
673 tf->cr = regs->cr;
674 tf->xer = regs->xer;
675 tf->ctr = regs->ctr;
676 tf->srr0 = regs->pc;
677
678 return (0);
679 }
680
681 int
682 fill_regs32(struct thread *td, struct reg32 *regs)
683 {
684 struct trapframe *tf;
685 int i;
686
687 tf = td->td_frame;
688 for (i = 0; i < 32; i++)
689 regs->fixreg[i] = tf->fixreg[i];
690 regs->lr = tf->lr;
691 regs->cr = tf->cr;
692 regs->xer = tf->xer;
693 regs->ctr = tf->ctr;
694 regs->pc = tf->srr0;
695
696 return (0);
697 }
698
699 static int
700 grab_mcontext32(struct thread *td, mcontext32_t *mcp, int flags)
701 {
702 mcontext_t mcp64;
703 int i, error;
704
705 error = grab_mcontext(td, &mcp64, flags);
706 if (error != 0)
707 return (error);
708
709 mcp->mc_vers = mcp64.mc_vers;
710 mcp->mc_flags = mcp64.mc_flags;
711 mcp->mc_onstack = mcp64.mc_onstack;
712 mcp->mc_len = mcp64.mc_len;
713 memcpy(mcp->mc_avec,mcp64.mc_avec,sizeof(mcp64.mc_avec));
714 memcpy(mcp->mc_av,mcp64.mc_av,sizeof(mcp64.mc_av));
715 for (i = 0; i < 42; i++)
716 mcp->mc_frame[i] = mcp64.mc_frame[i];
717 memcpy(mcp->mc_fpreg,mcp64.mc_fpreg,sizeof(mcp64.mc_fpreg));
718 memcpy(mcp->mc_vsxfpreg,mcp64.mc_vsxfpreg,sizeof(mcp64.mc_vsxfpreg));
719
720 return (0);
721 }
722
723 static int
724 get_mcontext32(struct thread *td, mcontext32_t *mcp, int flags)
725 {
726 int error;
727
728 error = grab_mcontext32(td, mcp, flags);
729 if (error == 0) {
730 PROC_LOCK(curthread->td_proc);
731 mcp->mc_onstack = sigonstack(td->td_frame->fixreg[1]);
732 PROC_UNLOCK(curthread->td_proc);
733 }
734
735 return (error);
736 }
737
738 static int
739 set_mcontext32(struct thread *td, mcontext32_t *mcp)
740 {
741 mcontext_t mcp64;
742 int i, error;
743
744 mcp64.mc_vers = mcp->mc_vers;
745 mcp64.mc_flags = mcp->mc_flags;
746 mcp64.mc_onstack = mcp->mc_onstack;
747 mcp64.mc_len = mcp->mc_len;
748 memcpy(mcp64.mc_avec,mcp->mc_avec,sizeof(mcp64.mc_avec));
749 memcpy(mcp64.mc_av,mcp->mc_av,sizeof(mcp64.mc_av));
750 for (i = 0; i < 42; i++)
751 mcp64.mc_frame[i] = mcp->mc_frame[i];
752 mcp64.mc_srr1 |= (td->td_frame->srr1 & 0xFFFFFFFF00000000ULL);
753 memcpy(mcp64.mc_fpreg,mcp->mc_fpreg,sizeof(mcp64.mc_fpreg));
754 memcpy(mcp64.mc_vsxfpreg,mcp->mc_vsxfpreg,sizeof(mcp64.mc_vsxfpreg));
755
756 error = set_mcontext(td, &mcp64);
757
758 return (error);
759 }
760 #endif
761
762 #ifdef COMPAT_FREEBSD32
763 int
764 freebsd32_sigreturn(struct thread *td, struct freebsd32_sigreturn_args *uap)
765 {
766 ucontext32_t uc;
767 int error;
768
769 CTR2(KTR_SIG, "sigreturn: td=%p ucp=%p", td, uap->sigcntxp);
770
771 if (copyin(uap->sigcntxp, &uc, sizeof(uc)) != 0) {
772 CTR1(KTR_SIG, "sigreturn: efault td=%p", td);
773 return (EFAULT);
774 }
775
776 error = set_mcontext32(td, &uc.uc_mcontext);
777 if (error != 0)
778 return (error);
779
780 kern_sigprocmask(td, SIG_SETMASK, &uc.uc_sigmask, NULL, 0);
781
782 CTR3(KTR_SIG, "sigreturn: return td=%p pc=%#x sp=%#x",
783 td, uc.uc_mcontext.mc_srr0, uc.uc_mcontext.mc_gpr[1]);
784
785 return (EJUSTRETURN);
786 }
787
788 /*
789 * The first two fields of a ucontext_t are the signal mask and the machine
790 * context. The next field is uc_link; we want to avoid destroying the link
791 * when copying out contexts.
792 */
793 #define UC32_COPY_SIZE offsetof(ucontext32_t, uc_link)
794
795 int
796 freebsd32_getcontext(struct thread *td, struct freebsd32_getcontext_args *uap)
797 {
798 ucontext32_t uc;
799 int ret;
800
801 if (uap->ucp == NULL)
802 ret = EINVAL;
803 else {
804 get_mcontext32(td, &uc.uc_mcontext, GET_MC_CLEAR_RET);
805 PROC_LOCK(td->td_proc);
806 uc.uc_sigmask = td->td_sigmask;
807 PROC_UNLOCK(td->td_proc);
808 ret = copyout(&uc, uap->ucp, UC32_COPY_SIZE);
809 }
810 return (ret);
811 }
812
813 int
814 freebsd32_setcontext(struct thread *td, struct freebsd32_setcontext_args *uap)
815 {
816 ucontext32_t uc;
817 int ret;
818
819 if (uap->ucp == NULL)
820 ret = EINVAL;
821 else {
822 ret = copyin(uap->ucp, &uc, UC32_COPY_SIZE);
823 if (ret == 0) {
824 ret = set_mcontext32(td, &uc.uc_mcontext);
825 if (ret == 0) {
826 kern_sigprocmask(td, SIG_SETMASK,
827 &uc.uc_sigmask, NULL, 0);
828 }
829 }
830 }
831 return (ret == 0 ? EJUSTRETURN : ret);
832 }
833
834 int
835 freebsd32_swapcontext(struct thread *td, struct freebsd32_swapcontext_args *uap)
836 {
837 ucontext32_t uc;
838 int ret;
839
840 if (uap->oucp == NULL || uap->ucp == NULL)
841 ret = EINVAL;
842 else {
843 get_mcontext32(td, &uc.uc_mcontext, GET_MC_CLEAR_RET);
844 PROC_LOCK(td->td_proc);
845 uc.uc_sigmask = td->td_sigmask;
846 PROC_UNLOCK(td->td_proc);
847 ret = copyout(&uc, uap->oucp, UC32_COPY_SIZE);
848 if (ret == 0) {
849 ret = copyin(uap->ucp, &uc, UC32_COPY_SIZE);
850 if (ret == 0) {
851 ret = set_mcontext32(td, &uc.uc_mcontext);
852 if (ret == 0) {
853 kern_sigprocmask(td, SIG_SETMASK,
854 &uc.uc_sigmask, NULL, 0);
855 }
856 }
857 }
858 }
859 return (ret == 0 ? EJUSTRETURN : ret);
860 }
861
862 #endif
863
864 void
865 cpu_set_syscall_retval(struct thread *td, int error)
866 {
867 struct proc *p;
868 struct trapframe *tf;
869 int fixup;
870
871 if (error == EJUSTRETURN)
872 return;
873
874 p = td->td_proc;
875 tf = td->td_frame;
876
877 if (tf->fixreg[0] == SYS___syscall &&
878 (SV_PROC_FLAG(p, SV_ILP32))) {
879 int code = tf->fixreg[FIRSTARG + 1];
880 if (p->p_sysent->sv_mask)
881 code &= p->p_sysent->sv_mask;
882 fixup = (
883 #if defined(COMPAT_FREEBSD6) && defined(SYS_freebsd6_lseek)
884 code != SYS_freebsd6_lseek &&
885 #endif
886 code != SYS_lseek) ? 1 : 0;
887 } else
888 fixup = 0;
889
890 switch (error) {
891 case 0:
892 if (fixup) {
893 /*
894 * 64-bit return, 32-bit syscall. Fixup byte order
895 */
896 tf->fixreg[FIRSTARG] = 0;
897 tf->fixreg[FIRSTARG + 1] = td->td_retval[0];
898 } else {
899 tf->fixreg[FIRSTARG] = td->td_retval[0];
900 tf->fixreg[FIRSTARG + 1] = td->td_retval[1];
901 }
902 tf->cr &= ~0x10000000; /* Unset summary overflow */
903 break;
904 case ERESTART:
905 /*
906 * Set user's pc back to redo the system call.
907 */
908 tf->srr0 -= 4;
909 break;
910 default:
911 tf->fixreg[FIRSTARG] = SV_ABI_ERRNO(p, error);
912 tf->cr |= 0x10000000; /* Set summary overflow */
913 break;
914 }
915 }
916
917 /*
918 * Threading functions
919 */
920 void
921 cpu_thread_exit(struct thread *td)
922 {
923 }
924
925 void
926 cpu_thread_clean(struct thread *td)
927 {
928 }
929
930 void
931 cpu_thread_alloc(struct thread *td)
932 {
933 struct pcb *pcb;
934
935 pcb = (struct pcb *)((td->td_kstack + td->td_kstack_pages * PAGE_SIZE -
936 sizeof(struct pcb)) & ~0x2fUL);
937 td->td_pcb = pcb;
938 td->td_frame = (struct trapframe *)pcb - 1;
939 }
940
941 void
942 cpu_thread_free(struct thread *td)
943 {
944 }
945
946 int
947 cpu_set_user_tls(struct thread *td, void *tls_base)
948 {
949
950 if (SV_PROC_FLAG(td->td_proc, SV_LP64))
951 td->td_frame->fixreg[13] = (register_t)tls_base + 0x7010;
952 else
953 td->td_frame->fixreg[2] = (register_t)tls_base + 0x7008;
954 return (0);
955 }
956
957 void
958 cpu_copy_thread(struct thread *td, struct thread *td0)
959 {
960 struct pcb *pcb2;
961 struct trapframe *tf;
962 struct callframe *cf;
963
964 pcb2 = td->td_pcb;
965
966 /* Copy the upcall pcb */
967 bcopy(td0->td_pcb, pcb2, sizeof(*pcb2));
968
969 /* Create a stack for the new thread */
970 tf = td->td_frame;
971 bcopy(td0->td_frame, tf, sizeof(struct trapframe));
972 tf->fixreg[FIRSTARG] = 0;
973 tf->fixreg[FIRSTARG + 1] = 0;
974 tf->cr &= ~0x10000000;
975
976 /* Set registers for trampoline to user mode. */
977 cf = (struct callframe *)tf - 1;
978 memset(cf, 0, sizeof(struct callframe));
979 cf->cf_func = (register_t)fork_return;
980 cf->cf_arg0 = (register_t)td;
981 cf->cf_arg1 = (register_t)tf;
982
983 pcb2->pcb_sp = (register_t)cf;
984 #if defined(__powerpc64__) && (!defined(_CALL_ELF) || _CALL_ELF == 1)
985 pcb2->pcb_lr = ((register_t *)fork_trampoline)[0];
986 pcb2->pcb_toc = ((register_t *)fork_trampoline)[1];
987 #else
988 pcb2->pcb_lr = (register_t)fork_trampoline;
989 pcb2->pcb_context[0] = pcb2->pcb_lr;
990 #endif
991 pcb2->pcb_cpu.aim.usr_vsid = 0;
992
993 /* Setup to release spin count in fork_exit(). */
994 td->td_md.md_spinlock_count = 1;
995 td->td_md.md_saved_msr = PSL_KERNSET;
996 }
997
998 void
999 cpu_set_upcall(struct thread *td, void (*entry)(void *), void *arg,
1000 stack_t *stack)
1001 {
1002 struct trapframe *tf;
1003 uintptr_t sp;
1004
1005 tf = td->td_frame;
1006 /* align stack and alloc space for frame ptr and saved LR */
1007 #ifdef __powerpc64__
1008 sp = ((uintptr_t)stack->ss_sp + stack->ss_size - 48) &
1009 ~0x1f;
1010 #else
1011 sp = ((uintptr_t)stack->ss_sp + stack->ss_size - 8) &
1012 ~0x1f;
1013 #endif
1014 bzero(tf, sizeof(struct trapframe));
1015
1016 tf->fixreg[1] = (register_t)sp;
1017 tf->fixreg[3] = (register_t)arg;
1018 if (SV_PROC_FLAG(td->td_proc, SV_ILP32)) {
1019 tf->srr0 = (register_t)entry;
1020 tf->srr1 = PSL_USERSET | PSL_FE_DFLT;
1021 #ifdef __powerpc64__
1022 tf->srr1 &= ~PSL_SF;
1023 #endif
1024 } else {
1025 #ifdef __powerpc64__
1026 register_t entry_desc[3];
1027 (void)copyin((void *)entry, entry_desc, sizeof(entry_desc));
1028 tf->srr0 = entry_desc[0];
1029 tf->fixreg[2] = entry_desc[1];
1030 tf->fixreg[11] = entry_desc[2];
1031 tf->srr1 = PSL_SF | PSL_USERSET | PSL_FE_DFLT;
1032 #endif
1033 }
1034
1035 #ifdef __powerpc64__
1036 if (mfmsr() & PSL_HV)
1037 tf->srr1 |= PSL_HV;
1038 #endif
1039 td->td_pcb->pcb_flags = 0;
1040
1041 td->td_retval[0] = (register_t)entry;
1042 td->td_retval[1] = 0;
1043 }
1044
1045 int
1046 ppc_instr_emulate(struct trapframe *frame, struct pcb *pcb)
1047 {
1048 uint32_t instr;
1049 int reg, sig;
1050
1051 instr = fuword32((void *)frame->srr0);
1052 sig = SIGILL;
1053
1054 if ((instr & 0xfc1fffff) == 0x7c1f42a6) { /* mfpvr */
1055 reg = (instr & ~0xfc1fffff) >> 21;
1056 frame->fixreg[reg] = mfpvr();
1057 frame->srr0 += 4;
1058 return (0);
1059 }
1060
1061 if ((instr & 0xfc000ffe) == 0x7c0004ac) { /* various sync */
1062 powerpc_sync(); /* Do a heavy-weight sync */
1063 frame->srr0 += 4;
1064 return (0);
1065 }
1066
1067 #ifdef FPU_EMU
1068 if (!(pcb->pcb_flags & PCB_FPREGS)) {
1069 bzero(&pcb->pcb_fpu, sizeof(pcb->pcb_fpu));
1070 pcb->pcb_flags |= PCB_FPREGS;
1071 }
1072 sig = fpu_emulate(frame, &pcb->pcb_fpu);
1073 #endif
1074
1075 return (sig);
1076 }
1077
Cache object: 95b2f272f33c2a61b6cea3bc7b96dd63
|