Annotation of sys/arch/hp300/hp300/hpux_machdep.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: hpux_machdep.c,v 1.20 2005/11/06 17:23:39 miod Exp $ */
2: /* $NetBSD: hpux_machdep.c,v 1.19 1998/02/16 20:58:30 thorpej Exp $ */
3:
4: /*
5: * Copyright (c) 1995, 1996, 1997 Jason R. Thorpe. All rights reserved.
6: * Copyright (c) 1988 University of Utah.
7: * Copyright (c) 1990, 1993
8: * The Regents of the University of California. All rights reserved.
9: *
10: * This code is derived from software contributed to Berkeley by
11: * the Systems Programming Group of the University of Utah Computer
12: * Science Department.
13: *
14: * Redistribution and use in source and binary forms, with or without
15: * modification, are permitted provided that the following conditions
16: * are met:
17: * 1. Redistributions of source code must retain the above copyright
18: * notice, this list of conditions and the following disclaimer.
19: * 2. Redistributions in binary form must reproduce the above copyright
20: * notice, this list of conditions and the following disclaimer in the
21: * documentation and/or other materials provided with the distribution.
22: * 3. The name of the author may not be used to endorse or promote products
23: * derived from this software without specific prior written permission.
24: *
25: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35: * SUCH DAMAGE.
36: */
37:
38: /*
39: * Machine-dependent bits for HP-UX binary compatibility.
40: */
41:
42: #include <sys/param.h>
43: #include <sys/systm.h>
44: #include <sys/buf.h>
45: #include <sys/conf.h>
46: #include <sys/device.h>
47: #include <sys/exec.h>
48: #include <sys/file.h>
49: #include <sys/filedesc.h>
50: #include <sys/ioctl.h>
51: #include <sys/ipc.h>
52: #include <sys/kernel.h>
53: #include <sys/malloc.h>
54: #include <sys/mman.h>
55: #include <sys/mount.h>
56: #include <sys/namei.h>
57: #include <sys/poll.h>
58: #include <sys/proc.h>
59: #include <sys/ptrace.h>
60: #include <sys/signalvar.h>
61: #include <sys/stat.h>
62: #include <sys/syslog.h>
63: #include <sys/tty.h>
64: #include <sys/user.h>
65: #include <sys/vnode.h>
66: #include <sys/wait.h>
67:
68: #include <machine/cpu.h>
69: #include <machine/reg.h>
70: #include <machine/psl.h>
71: #include <machine/vmparam.h>
72:
73: #include <uvm/uvm_extern.h>
74:
75: #include <sys/syscallargs.h>
76:
77: #include <compat/hpux/hpux.h>
78: #include <compat/hpux/hpux_sig.h>
79: #include <compat/hpux/hpux_util.h>
80: #include <compat/hpux/hpux_syscall.h>
81: #include <compat/hpux/hpux_syscallargs.h>
82:
83: #include <machine/hpux_machdep.h>
84:
85: extern short exframesize[];
86:
87: struct valtostr {
88: int val;
89: const char *str;
90: };
91:
92: /*
93: * 6.0 and later context.
94: * XXX what are the HP-UX "localroot" semantics? Should we handle
95: * XXX diskless systems here?
96: */
97: static const char context_040[] =
98: "standalone HP-MC68040 HP-MC68881 HP-MC68020 HP-MC68010 localroot default";
99:
100: static const char context_fpu[] =
101: "standalone HP-MC68881 HP-MC68020 HP-MC68010 localroot default";
102:
103: static const char context_nofpu[] =
104: "standalone HP-MC68020 HP-MC68010 localroot default";
105:
106: static struct valtostr context_table[] = {
107: { FPU_68060, &context_040[0] },
108: { FPU_68040, &context_040[0] },
109: { FPU_68882, &context_fpu[0] },
110: { FPU_68881, &context_fpu[0] },
111: { 0, NULL },
112: };
113:
114: #define UOFF(f) ((int)&((struct user *)0)->f)
115: #define HPUOFF(f) ((int)&((struct hpux_user *)0)->f)
116:
117: /* simplified FP structure */
118: struct bsdfp {
119: int save[54];
120: int reg[24];
121: int ctrl[3];
122: };
123:
124: /*
125: * m68k-specific setup for HP-UX executables.
126: */
127: int
128: hpux_cpu_makecmds(p, epp)
129: struct proc *p;
130: struct exec_package *epp;
131: {
132: /* struct hpux_exec *hpux_ep = epp->ep_hdr; */
133:
134: /* set up command for exec header */
135: NEW_VMCMD(&epp->ep_vmcmds, hpux_cpu_vmcmd,
136: sizeof(struct hpux_exec), (long)epp->ep_hdr, NULLVP, 0, 0);
137: return (0);
138: }
139:
140: /*
141: * We need to stash the exec header in the pcb, so we define
142: * this vmcmd to do it for us, since vmcmds are executed once
143: * we're committed to the exec (i.e. the old program has been unmapped).
144: *
145: * The address of the header is in ev->ev_addr and the length is
146: * in ev->ev_len.
147: */
148: int
149: hpux_cpu_vmcmd(p, ev)
150: struct proc *p;
151: struct exec_vmcmd *ev;
152: {
153: struct hpux_exec *execp = (struct hpux_exec *)ev->ev_addr;
154:
155: /* Make sure we have room. */
156: if (ev->ev_len <= sizeof(p->p_addr->u_md.md_exec))
157: bcopy((caddr_t)ev->ev_addr, p->p_addr->u_md.md_exec,
158: ev->ev_len);
159:
160: /* Deal with misc. HP-UX process attributes. */
161: if (execp->ha_trsize & HPUXM_VALID) {
162: if (execp->ha_trsize & HPUXM_DATAWT)
163: p->p_md.md_flags &= ~MDP_CCBDATA;
164:
165: if (execp->ha_trsize & HPUXM_STKWT)
166: p->p_md.md_flags &= ~MDP_CCBSTACK;
167: }
168:
169: return (0);
170: }
171:
172: /*
173: * Return arch-type for hpux_sys_sysconf()
174: */
175: int
176: hpux_cpu_sysconf_arch()
177: {
178:
179: switch (cputype) {
180: case CPU_68020:
181: return (HPUX_SYSCONF_CPUM020);
182:
183: case CPU_68030:
184: return (HPUX_SYSCONF_CPUM030);
185:
186: default:
187: return (HPUX_SYSCONF_CPUM040);
188: }
189: /* NOTREACHED */
190: }
191:
192: /*
193: * HP-UX advise(2) system call.
194: */
195: int
196: hpux_sys_advise(p, v, retval)
197: struct proc *p;
198: void *v;
199: register_t *retval;
200: {
201: struct hpux_sys_advise_args *uap = v;
202: int error = 0;
203:
204: switch (SCARG(uap, arg)) {
205: case 0:
206: p->p_md.md_flags |= MDP_HPUXMMAP;
207: break;
208:
209: case 1:
210: ICIA();
211: break;
212:
213: case 2:
214: DCIA();
215: break;
216:
217: default:
218: error = EINVAL;
219: break;
220: }
221:
222: return (error);
223: }
224:
225: /*
226: * HP-UX getcontext(2) system call.
227: * Man page lies, behaviour here is based on observed behaviour.
228: */
229: int
230: hpux_sys_getcontext(p, v, retval)
231: struct proc *p;
232: void *v;
233: register_t *retval;
234: {
235: struct hpux_sys_getcontext_args *uap = v;
236: const char *str;
237: int l, i, error = 0;
238: int len;
239:
240: if (SCARG(uap, len) <= 0)
241: return (EINVAL);
242:
243: for (i = 0; context_table[i].str != NULL; i++)
244: if (context_table[i].val == fputype)
245: break;
246: if (context_table[i].str == NULL)
247: str = &context_nofpu[0];
248: else
249: str = context_table[i].str;
250:
251: /* + 1 ... count the terminating \0. */
252: l = strlen(str) + 1;
253: len = min(SCARG(uap, len), l);
254:
255: if (len)
256: error = copyout(str, SCARG(uap, buf), len);
257: if (error == 0)
258: *retval = l;
259: return (0);
260: }
261:
262: /*
263: * Brutal hack! Map HP-UX u-area offsets into BSD k-stack offsets.
264: * XXX This probably doesn't work anymore, BTW. --thorpej
265: */
266: int
267: hpux_to_bsd_uoff(off, isps, p)
268: int *off, *isps;
269: struct proc *p;
270: {
271: int *ar0 = p->p_md.md_regs;
272: struct hpux_fp *hp;
273: struct bsdfp *bp;
274: u_int raddr;
275:
276: *isps = 0;
277:
278: /* u_ar0 field; procxmt puts in U_ar0 */
279: if ((int)off == HPUOFF(hpuxu_ar0))
280: return(UOFF(U_ar0));
281:
282: if (fputype) {
283: /* FP registers from PCB */
284: hp = (struct hpux_fp *)HPUOFF(hpuxu_fp);
285: bp = (struct bsdfp *)UOFF(u_pcb.pcb_fpregs);
286:
287: if (off >= hp->hpfp_ctrl && off < &hp->hpfp_ctrl[3])
288: return((int)&bp->ctrl[off - hp->hpfp_ctrl]);
289:
290: if (off >= hp->hpfp_reg && off < &hp->hpfp_reg[24])
291: return((int)&bp->reg[off - hp->hpfp_reg]);
292: }
293:
294: /*
295: * Everything else we recognize comes from the kernel stack,
296: * so we convert off to an absolute address (if not already)
297: * for simplicity.
298: */
299: if (off < (int *)ctob(UPAGES))
300: off = (int *)((u_int)off + (u_int)p->p_addr); /* XXX */
301:
302: /*
303: * General registers.
304: * We know that the HP-UX registers are in the same order as ours.
305: * The only difference is that their PS is 2 bytes instead of a
306: * padded 4 like ours throwing the alignment off.
307: */
308: if (off >= ar0 && off < &ar0[18]) {
309: /*
310: * PS: return low word and high word of PC as HP-UX would
311: * (e.g. &u.u_ar0[16.5]).
312: *
313: * XXX we don't do this since HP-UX adb doesn't rely on
314: * it and passing such an offset to procxmt will cause
315: * it to fail anyway. Instead, we just set the offset
316: * to PS and let hpux_ptrace() shift up the value returned.
317: */
318: if (off == &ar0[PS]) {
319: #if 0
320: raddr = (u_int) &((short *)ar0)[PS*2+1];
321: #else
322: raddr = (u_int) &ar0[(int)(off - ar0)];
323: #endif
324: *isps = 1;
325: }
326: /*
327: * PC: off will be &u.u_ar0[16.5] since HP-UX saved PS
328: * is only 16 bits.
329: */
330: else if (off == (int *)&(((short *)ar0)[PS*2+1]))
331: raddr = (u_int) &ar0[PC];
332: /*
333: * D0-D7, A0-A7: easy
334: */
335: else
336: raddr = (u_int) &ar0[(int)(off - ar0)];
337: return((int)(raddr - (u_int)p->p_addr)); /* XXX */
338: }
339:
340: /* everything else */
341: return (-1);
342: }
343:
344: #define HSS_RTEFRAME 0x01
345: #define HSS_FPSTATE 0x02
346: #define HSS_USERREGS 0x04
347:
348: struct hpuxsigstate {
349: int hss_flags; /* which of the following are valid */
350: struct frame hss_frame; /* original exception frame */
351: struct fpframe hss_fpstate; /* 68881/68882 state info */
352: };
353:
354: /*
355: * WARNING: code in locore.s assumes the layout shown here for hsf_signum
356: * thru hsf_handler so... don't screw with them!
357: */
358: struct hpuxsigframe {
359: int hsf_signum; /* signo for handler */
360: int hsf_code; /* additional info for handler */
361: struct hpuxsigcontext *hsf_scp; /* context ptr for handler */
362: sig_t hsf_handler; /* handler addr for u_sigc */
363: struct hpuxsigstate hsf_sigstate; /* state of the hardware */
364: struct hpuxsigcontext hsf_sc; /* actual context */
365: };
366:
367: #ifdef DEBUG
368: int hpuxsigdebug = 0;
369: int hpuxsigpid = 0;
370: #define SDB_FOLLOW 0x01
371: #define SDB_KSTACK 0x02
372: #define SDB_FPSTATE 0x04
373: #endif
374:
375: /*
376: * Send an interrupt to process.
377: */
378: /* ARGSUSED */
379: void
380: hpux_sendsig(catcher, sig, mask, code, type, val)
381: sig_t catcher;
382: int sig, mask;
383: u_long code;
384: int type;
385: union sigval val;
386: {
387: struct proc *p = curproc;
388: struct hpuxsigframe *kfp, *fp;
389: struct frame *frame;
390: struct sigacts *psp = p->p_sigacts;
391: short ft;
392: int oonstack, fsize;
393:
394: frame = (struct frame *)p->p_md.md_regs;
395: ft = frame->f_format;
396: oonstack = psp->ps_sigstk.ss_flags & SS_ONSTACK;
397:
398: /*
399: * Allocate and validate space for the signal handler
400: * context. Note that if the stack is in P0 space, the
401: * call to grow() is a nop, and the useracc() check
402: * will fail if the process has not already allocated
403: * the space with a `brk'.
404: */
405: fsize = sizeof(struct hpuxsigframe);
406: if ((psp->ps_flags & SAS_ALTSTACK) && !oonstack &&
407: (psp->ps_sigonstack & sigmask(sig))) {
408: fp = (struct hpuxsigframe *)(psp->ps_sigstk.ss_sp +
409: psp->ps_sigstk.ss_size - fsize);
410: psp->ps_sigstk.ss_flags |= SS_ONSTACK;
411: } else
412: fp = (struct hpuxsigframe *)(frame->f_regs[SP] - fsize);
413: if ((unsigned)fp <= USRSTACK - ctob(p->p_vmspace->vm_ssize))
414: (void)uvm_grow(p, (unsigned)fp);
415:
416: #ifdef DEBUG
417: if ((hpuxsigdebug & SDB_KSTACK) && p->p_pid == hpuxsigpid)
418: printf("hpux_sendsig(%d): sig %d ssp %p usp %p scp %p ft %d\n",
419: p->p_pid, sig, &oonstack, fp, &fp->hsf_sc, ft);
420: #endif
421:
422: kfp = (struct hpuxsigframe *)malloc((u_long)fsize, M_TEMP, M_WAITOK);
423:
424: /*
425: * Build the argument list for the signal handler.
426: */
427: kfp->hsf_signum = bsdtohpuxsig(sig);
428: kfp->hsf_code = code;
429: kfp->hsf_scp = &fp->hsf_sc;
430: kfp->hsf_handler = catcher;
431:
432: /*
433: * Save necessary hardware state. Currently this includes:
434: * - general registers
435: * - original exception frame (if not a "normal" frame)
436: * - FP coprocessor state
437: */
438: kfp->hsf_sigstate.hss_flags = HSS_USERREGS;
439: bcopy((caddr_t)frame->f_regs,
440: (caddr_t)kfp->hsf_sigstate.hss_frame.f_regs, sizeof frame->f_regs);
441: if (ft >= FMT7) {
442: #ifdef DEBUG
443: if (ft > 15 || exframesize[ft] < 0)
444: panic("hpux_sendsig: bogus frame type");
445: #endif
446: kfp->hsf_sigstate.hss_flags |= HSS_RTEFRAME;
447: kfp->hsf_sigstate.hss_frame.f_format = frame->f_format;
448: kfp->hsf_sigstate.hss_frame.f_vector = frame->f_vector;
449: bcopy((caddr_t)&frame->F_u,
450: (caddr_t)&kfp->hsf_sigstate.hss_frame.F_u, exframesize[ft]);
451:
452: /*
453: * Leave an indicator that we need to clean up the kernel
454: * stack. We do this by setting the "pad word" above the
455: * hardware stack frame to the amount the stack must be
456: * adjusted by.
457: *
458: * N.B. we increment rather than just set f_stackadj in
459: * case we are called from syscall when processing a
460: * sigreturn. In that case, f_stackadj may be non-zero.
461: */
462: frame->f_stackadj += exframesize[ft];
463: frame->f_format = frame->f_vector = 0;
464: #ifdef DEBUG
465: if (hpuxsigdebug & SDB_FOLLOW)
466: printf("hpux_sendsig(%d): copy out %d of frame %d\n",
467: p->p_pid, exframesize[ft], ft);
468: #endif
469: }
470: if (fputype) {
471: kfp->hsf_sigstate.hss_flags |= HSS_FPSTATE;
472: m68881_save(&kfp->hsf_sigstate.hss_fpstate);
473: }
474:
475: #ifdef DEBUG
476: if ((hpuxsigdebug & SDB_FPSTATE) &&
477: *(char *)&kfp->hsf_sigstate.hss_fpstate)
478: printf("hpux_sendsig(%d): copy out FP state (%x) to %p\n",
479: p->p_pid, *(u_int *)&kfp->hsf_sigstate.hss_fpstate,
480: &kfp->hsf_sigstate.hss_fpstate);
481: #endif
482:
483: /*
484: * Build the signal context to be used by hpux_sigreturn.
485: */
486: kfp->hsf_sc.hsc_syscall = 0; /* XXX */
487: kfp->hsf_sc.hsc_action = 0; /* XXX */
488: kfp->hsf_sc.hsc_pad1 = kfp->hsf_sc.hsc_pad2 = 0;
489: kfp->hsf_sc.hsc_onstack = oonstack;
490: kfp->hsf_sc.hsc_mask = mask;
491: kfp->hsf_sc.hsc_sp = frame->f_regs[SP];
492: kfp->hsf_sc.hsc_ps = frame->f_sr;
493: kfp->hsf_sc.hsc_pc = frame->f_pc;
494:
495: /* How amazingly convenient! */
496: kfp->hsf_sc._hsc_pad = 0;
497: kfp->hsf_sc._hsc_ap = (int)&fp->hsf_sigstate;
498:
499: if (copyout((caddr_t)kfp, (caddr_t)fp, fsize) != 0) {
500: #ifdef DEBUG
501: if ((hpuxsigdebug & SDB_KSTACK) && p->p_pid == hpuxsigpid)
502: printf("hpux_sendsig(%d): copyout failed on sig %d\n",
503: p->p_pid, sig);
504: #endif
505: /*
506: * Process has trashed its stack; give it an illegal
507: * instruction to halt it in its tracks.
508: */
509: free((caddr_t)kfp, M_TEMP);
510: sigexit(p, SIGILL);
511: /* NOTREACHED */
512: }
513: frame->f_regs[SP] = (int)fp;
514:
515: #ifdef DEBUG
516: if (hpuxsigdebug & SDB_FOLLOW) {
517: printf(
518: "hpux_sendsig(%d): sig %d scp %p fp %p sc_sp %x sc_ap %x\n",
519: p->p_pid, sig, kfp->hsf_scp, fp,
520: kfp->hsf_sc.hsc_sp, kfp->hsf_sc._hsc_ap);
521: }
522: #endif
523:
524: /*
525: * Signal trampoline code is at base of user stack.
526: */
527: frame->f_pc = p->p_sigcode;
528: #ifdef DEBUG
529: if ((hpuxsigdebug & SDB_KSTACK) && p->p_pid == hpuxsigpid)
530: printf("hpux_sendsig(%d): sig %d returns\n",
531: p->p_pid, sig);
532: #endif
533: free((caddr_t)kfp, M_TEMP);
534: }
535:
536: /*
537: * System call to cleanup state after a signal
538: * has been taken. Reset signal mask and
539: * stack state from context left by sendsig (above).
540: * Return to previous pc and psl as specified by
541: * context left by sendsig. Check carefully to
542: * make sure that the user has not modified the
543: * psl to gain improper privileges or to cause
544: * a machine fault.
545: */
546: /* ARGSUSED */
547: int
548: hpux_sys_sigreturn(p, v, retval)
549: struct proc *p;
550: void *v;
551: register_t *retval;
552: {
553: struct hpux_sys_sigreturn_args /* {
554: syscallarg(struct hpuxsigcontext *) sigcntxp;
555: } */ *uap = v;
556: struct hpuxsigcontext *scp;
557: struct frame *frame;
558: int rf;
559: struct hpuxsigcontext tsigc;
560: struct hpuxsigstate tstate;
561: int flags;
562:
563: scp = SCARG(uap, sigcntxp);
564: #ifdef DEBUG
565: if (hpuxsigdebug & SDB_FOLLOW)
566: printf("sigreturn: pid %d, scp %p\n", p->p_pid, scp);
567: #endif
568: if ((int)scp & 1)
569: return (EINVAL);
570:
571: /*
572: * Fetch and test the HP-UX context structure.
573: * We grab it all at once for speed.
574: */
575: if (copyin((caddr_t)scp, (caddr_t)&tsigc, sizeof tsigc))
576: return (EINVAL);
577: scp = &tsigc;
578: if ((scp->hsc_ps & PSL_USERCLR) != 0 ||
579: (scp->hsc_ps & PSL_USERSET) != PSL_USERSET)
580: return (EINVAL);
581:
582: /*
583: * Restore the user supplied information
584: */
585: if (scp->hsc_onstack & 01)
586: p->p_sigacts->ps_sigstk.ss_flags |= SS_ONSTACK;
587: else
588: p->p_sigacts->ps_sigstk.ss_flags &= ~SS_ONSTACK;
589: p->p_sigmask = scp->hsc_mask &~ sigcantmask;
590: frame = (struct frame *) p->p_md.md_regs;
591: frame->f_regs[SP] = scp->hsc_sp;
592: frame->f_pc = scp->hsc_pc;
593: frame->f_sr = scp->hsc_ps;
594:
595: /*
596: * Grab a pointer to the hpuxsigstate.
597: * If zero, the user is probably doing a longjmp.
598: * (This will never happen, really, since HP-UX doesn't
599: * know/care about the state pointer.)
600: */
601: if ((rf = scp->_hsc_ap) == 0)
602: return (EJUSTRETURN);
603:
604: /*
605: * See if there is anything to do before we go to the
606: * expense of copying in close to 1/2K of data
607: */
608: if (copyin((caddr_t)rf, &flags, sizeof(int)) != 0)
609: return (EINVAL);
610: #ifdef DEBUG
611: if (hpuxsigdebug & SDB_FOLLOW)
612: printf("sigreturn(%d): sc_ap %x flags %x\n",
613: p->p_pid, rf, flags);
614: #endif
615: if (flags == 0 || copyin((caddr_t)rf, (caddr_t)&tstate, sizeof tstate))
616: return (EJUSTRETURN);
617: #ifdef DEBUG
618: if ((hpuxsigdebug & SDB_KSTACK) && p->p_pid == hpuxsigpid)
619: printf("sigreturn(%d): ssp %p usp %x scp %p ft %d\n",
620: p->p_pid, &flags, scp->hsc_sp, SCARG(uap, sigcntxp),
621: (flags & HSS_RTEFRAME) ? tstate.hss_frame.f_format : -1);
622: #endif
623: /*
624: * Restore most of the users registers except for A6 and SP
625: * which were handled above.
626: */
627: if (flags & HSS_USERREGS)
628: bcopy((caddr_t)tstate.hss_frame.f_regs,
629: (caddr_t)frame->f_regs, sizeof(frame->f_regs)-2*NBPW);
630:
631: /*
632: * Restore long stack frames. Note that we do not copy
633: * back the saved SR or PC, they were picked up above from
634: * the sigcontext structure.
635: */
636: if (flags & HSS_RTEFRAME) {
637: int sz;
638:
639: /* grab frame type and validate */
640: sz = tstate.hss_frame.f_format;
641: if (sz > 15 || (sz = exframesize[sz]) < 0)
642: return (EINVAL);
643: frame->f_stackadj -= sz;
644: frame->f_format = tstate.hss_frame.f_format;
645: frame->f_vector = tstate.hss_frame.f_vector;
646: bcopy((caddr_t)&tstate.hss_frame.F_u,
647: (caddr_t)&frame->F_u, sz);
648: #ifdef DEBUG
649: if (hpuxsigdebug & SDB_FOLLOW)
650: printf("sigreturn(%d): copy in %d of frame type %d\n",
651: p->p_pid, sz, tstate.hss_frame.f_format);
652: #endif
653: }
654:
655: /*
656: * Finally we restore the original FP context
657: */
658: if (flags & HSS_FPSTATE)
659: m68881_restore(&tstate.hss_fpstate);
660:
661: #ifdef DEBUG
662: if ((hpuxsigdebug & SDB_FPSTATE) && *(char *)&tstate.hss_fpstate)
663: printf("sigreturn(%d): copied in FP state (%x) at %p\n",
664: p->p_pid, *(u_int *)&tstate.hss_fpstate,
665: &tstate.hss_fpstate);
666:
667: if ((hpuxsigdebug & SDB_FOLLOW) ||
668: ((hpuxsigdebug & SDB_KSTACK) && p->p_pid == hpuxsigpid))
669: printf("sigreturn(%d): returns\n", p->p_pid);
670: #endif
671: return (EJUSTRETURN);
672: }
673:
674: /*
675: * Set registers on exec.
676: * XXX Should clear registers except sp, pc.
677: */
678: void
679: hpux_setregs(p, pack, stack, retval)
680: struct proc *p;
681: struct exec_package *pack;
682: u_long stack;
683: register_t *retval;
684: {
685: struct frame *frame = (struct frame *)p->p_md.md_regs;
686:
687: frame->f_pc = pack->ep_entry & ~1;
688: frame->f_regs[SP] = stack;
689: frame->f_regs[A2] = (int)PS_STRINGS;
690:
691: /* restore a null state frame */
692: p->p_addr->u_pcb.pcb_fpregs.fpf_null = 0;
693: if (fputype)
694: m68881_restore(&p->p_addr->u_pcb.pcb_fpregs);
695:
696: p->p_md.md_flags &= ~MDP_HPUXMMAP;
697: frame->f_regs[A0] = 0; /* not 68010 (bit 31), no FPA (30) */
698: retval[0] = 0; /* no float card */
699: if (fputype)
700: retval[1] = 1; /* yes 68881 */
701: else
702: retval[1] = 0; /* no 68881 */
703: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to hpux_machdep.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hp300 / hp300