![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sig.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / coh.386|
Return to sig.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / coh.386 |
1.1 root 1: /* (lgl-
2: * The information contained herein is a trade secret of Mark Williams
3: * Company, and is confidential information. It is provided under a
4: * license agreement, and may be copied or disclosed only under the
5: * terms of that agreement. Any reproduction or disclosure of this
6: * material without the express written authorization of Mark Williams
7: * Company or persuant to the license agreement is unlawful.
8: *
9: * COHERENT Version 5.0
10: * Copyright (c) 1982, 1993.
11: * An unpublished work by Mark Williams Company, Chicago.
12: * All rights reserved.
13: -lgl) */
14: /*
15: * File: coh.386/sig.c
16: *
17: * Purpose: signal handling
18: *
19: * Revised: Tue May 4 11:59:15 1993 CDT
20: */
21:
22: /*
23: * ----------------------------------------------------------------------
24: * Includes.
25: */
26:
27: #include <common/_limits.h>
28: #include <common/_wait.h>
29: #include <common/_gregset.h>
30: #include <kernel/sigproc.h>
31:
32: #include <sys/coherent.h>
33: #include <sys/errno.h>
34: #include <sys/ino.h>
35: #include <sys/inode.h>
36: #include <sys/io.h>
37: #include <sys/proc.h>
38: #include <sys/ptrace.h>
39: #include <sys/sched.h>
40: #include <sys/seg.h>
41: #include <sys/file.h>
42: #include <sys/core.h>
43:
44:
45: /*
46: * ----------------------------------------------------------------------
47: * Definitions.
48: * Constants.
49: * Macros with argument lists.
50: * Typedefs.
51: * Enums.
52: */
53:
54: /*
55: * ----------------------------------------------------------------------
56: * Functions.
57: * Import Functions.
58: * Export Functions.
59: * Local Functions.
60: */
61: void curr_check_signals();
62: int ptset();
63: void sendsig();
64: int sigdump();
65: __sigfunc_t usigsys();
66:
67: static struct _fpstate * empack();
68: static int ptret();
69:
70: /*
71: * ----------------------------------------------------------------------
72: * Global Data.
73: * Import Variables.
74: * Export Variables.
75: * Local Variables.
76: */
77: /*
78: * Patchable variables.
79: *
80: * Patch DUMP_TEXT nonzero to make text segment show up in core files.
81: * Patch DUMP_LIM set the upper limit in bytes of how much of a
82: * segment is written to a core file.
83: *
84: * CATCH_SEGV can be patched to allow signal () to be used to catch the
85: * SIGSEGV signal (). This is off by default because:
86: * i) Experience has shown that kernel printf () messages being on by
87: * default is very useful for catching bugs.
88: * ii) Certain extremely ill-behaved applications apparently catch SIGSEGV
89: * blindly as part of some catch-all behaviour, and when such faults
90: * happen have been known to loop generating kernel printf () output
91: * which bogs down the system unacceptably.
92: * iii) Turning the signal off to avoid ii) causes less actual disruption than
93: * leaving it on.
94: * This only applies to the signal () interface; we assume that apps which are
95: * smart enough to use sigset () or sigaction () also know what to do with
96: * SIGSEGV.
97: */
98:
99: int DUMP_TEXT = 0;
100: int DUMP_LIM=512*1024;
101: int CATCH_SEGV = 0;
102:
103: /*
104: * ----------------------------------------------------------------------
105: * Code.
106: */
107:
108: /*
109: * Or an entire signal mask into the "hold" mask.
110: */
111:
112: static void
113: sigMask (mask)
114: __sigset_t * mask;
115: {
116: int i;
117: __sigmask_t * loop = mask->_sigbits;
118: __sigset_t signal_mask;
119:
120: curr_signal_mask (NULL, & signal_mask);
121:
122: for (i = 0 ; i < __ARRAY_LENGTH (mask->_sigbits) ; i ++)
123: signal_mask._sigbits [i] |= * loop ++;
124:
125: curr_signal_mask (& signal_mask, NULL);
126: }
127:
128:
129: /*
130: * Set up the action to be taken on a signal.
131: */
132:
133: __sigfunc_t
134: usigsys (signal, func, regsetp)
135: unsigned signal;
136: __sigfunc_t func;
137: gregset_t * regsetp;
138: {
139: int sigtype;
140: __sigmask_t mask;
141: __sigset_t signal_mask;
142: __sigaction_t signal_action;
143:
144: sigtype = signal & ~ 0xFF;
145: signal &= 0xFF;
146:
147: #if 0
148: T_HAL(8, printf("[%d]sig(%d, %x) ", SELF->p_pid, signal, func));
149: #endif
150:
151: /*
152: * Check the passed signal number. SIGKILL and SIGSTOP are not allowed
153: * to be caught.
154: */
155:
156: /* Range check on 1-based signal number. */
157: if (signal <= 0 || signal > NSIG || signal == SIGSTOP ||
158: signal == SIGKILL) {
159: u.u_error = EINVAL;
160: return;
161: }
162:
163: signal_action.sa_handler = func;
164: signal_action.sa_flags = 0;
165: __SIGSET_EMPTY (signal_action.sa_mask);
166: func = 0;
167:
168: curr_signal_mask (NULL, & signal_mask);
169:
170: mask = __SIGSET_MASK (signal);
171:
172: switch (sigtype) {
173: case SIGHOLD:
174: __SIGSET_ADDMASK (signal_mask, signal, mask);
175: break;
176:
177: case SIGRELSE:
178: __SIGSET_CLRMASK (signal_mask, signal, mask);
179: break;
180:
181: case SIGIGNORE:
182: __SIGSET_CLRMASK (signal_mask, signal, mask);
183: signal_action.sa_handler = SIG_IGN;
184: curr_signal_action (signal, & signal_action, NULL);
185: break;
186:
187: case 0: /* signal () */
188: if (signal == SIGSEGV && CATCH_SEGV == 0) {
189: u.u_error = EINVAL;
190: return 0;
191: }
192: u.u_sigreturn = (__sigfunc_t) regsetp->_i386._edx;
193:
194: if (signal == SIGCHLD) {
195: /*
196: * With signal (), the argument implicitly mangles the
197: * SA_NOCLDWAIT flag. I have no idea whether the
198: * SA_NOCLDSTOP flag is also implicitly affected, but
199: * for now we leave it alone.
200: */
201:
202: curr_signal_misc (__SF_NOCLDWAIT,
203: signal_action.sa_handler ==
204: SIG_IGN ? __SF_NOCLDWAIT : 0);
205: }
206: signal_action.sa_flags |= __SA_RESETHAND;
207: curr_signal_action (signal, & signal_action, & signal_action);
208:
209: /*
210: * Using the signal () interface automatically causes a
211: * pending signal to be discarded.
212: */
213:
214: proc_unkill (SELF, signal);
215: return signal_action.sa_handler;
216:
217: case SIGSET:
218: u.u_sigreturn = (__sigfunc_t) regsetp->_i386._edx;
219:
220: if (__SIGSET_TSTMASK (signal_mask, signal, mask))
221: func = SIG_HOLD;
222:
223: if (signal_action.sa_handler == SIG_HOLD) {
224:
225: __SIGSET_ADDMASK (signal_mask, signal, mask);
226:
227: if (func != SIG_HOLD) {
228: curr_signal_action (signal, NULL,
229: & signal_action);
230: func = signal_action.sa_handler;
231: }
232: break;
233: }
234:
235: if (signal == SIGCHLD) {
236: /*
237: * With sigset (), the argument implicitly mangles the
238: * SA_NOCLDWAIT flag. I have no idea whether the
239: * SA_NOCLDSTOP flag is also implicitly affected, but
240: * for now we leave it alone.
241: */
242:
243: curr_signal_misc (__SF_NOCLDWAIT,
244: signal_action.sa_handler ==
245: SIG_IGN ? __SF_NOCLDWAIT : 0);
246: }
247: __SIGSET_CLRMASK (signal_mask, signal, mask);
248: __SIGSET_ADDMASK (signal_action.sa_mask, signal, mask);
249: curr_signal_action (signal, & signal_action, & signal_action);
250:
251: if (func != SIG_HOLD)
252: func = signal_action.sa_handler;
253: break;
254:
255: case SIGPAUSE:
256: /*
257: * Like upause(), do a sleep on an event which never gets a
258: * wakeup. The sleep returns immediately if a signal was
259: * already holding.
260: */
261:
262: __SIGSET_CLRMASK (signal_mask, signal, mask);
263: curr_signal_mask (& signal_mask, NULL);
264: (void) x_sleep ((char *) & u, prilo, slpriSigCatch,
265: "sigpause");
266: return 0;
267:
268: default:
269: u.u_error = SIGSYS;
270: return 0;
271: }
272:
273: curr_signal_mask (& signal_mask, NULL);
274: return func;
275: }
276:
277: /*
278: * Send a signal to the process `pp'. This function is only valid for use with
279: * signals generated from user level with kill (), sigsend () or
280: * sigsendset ().
281: */
282:
283: void
284: sendsig(sig, pp)
285: register unsigned sig;
286: register PROC *pp;
287: {
288: __siginfo_t siginfo;
289:
290: #if 0
291: T_HAL(8, if (sig == SIGINT) printf("[%d]gets int ", pp->p_pid));
292: #else
293: T_HAL(8, printf ("[%d] sig=%d ", pp->p_pid, sig));
294: #endif
295:
296: siginfo.__si_signo = sig;
297: siginfo.__si_code = 0;
298: siginfo.__si_errno = 0;
299: siginfo.__si_pid = SELF->p_pid;
300: siginfo.__si_uid = SELF->p_uid;
301:
302: proc_send_signal (pp, & siginfo);
303: }
304:
305:
306: /*
307: * Return signal number if we have a non ignored or delayed signal, else zero.
308: */
309:
310: int
311: nondsig()
312: {
313: return curr_signal_pending ();
314: }
315:
316:
317: /*
318: * If we have a signal that isn't ignored, activate it. The register set is
319: * not "const" because the low-level trap code that uses it wants to modify
320: * it.
321: */
322:
323: #if __USE_PROTO__
324: void curr_check_signals (gregset_t * regsetp)
325: #else
326: void
327: curr_check_signals (regsetp)
328: gregset_t * regsetp;
329: #endif
330: {
331: register int signum;
332: int ptval;
333:
334: /*
335: * Fetch an unprocessed signal.
336: * Return if there are none.
337: * The while() structure is only for traced processes.
338: */
339: while ((signum = curr_signal_pending ()) != 0) {
340: __sigaction_t signal_action;
341:
342: /*
343: * Reset the signal to indicate that it has been processed,
344: * and fetch the signal disposition.
345: */
346:
347: got_signal:
348: proc_unkill (SELF, signum);
349: curr_signal_action (signum, NULL, & signal_action);
350:
351: /*
352: * Store the signal number in the u area.
353: * This is how a core dump records the death signal.
354: */
355: u.u_signo = signum;
356:
357: /*
358: * If the signal is not defaulted, go run the requested
359: * function.
360: */
361:
362: if (signal_action.sa_handler != SIG_DFL) {
363: if (__xmode_286 (regsetp))
364: oldsigstart (signum, signal_action.sa_handler,
365: regsetp);
366: else
367: msigstart (signum, signal_action.sa_handler,
368: regsetp);
369:
370: /*
371: * If the signal needs to be reset after delivery, do so. Note that
372: * all signal-related activity goes though the defined function
373: * interface; many subtle things may need to happen, so we let the
374: * layering take care of it.
375: */
376:
377: if ((signal_action.sa_flags & __SA_RESETHAND) != 0) {
378: signal_action.sa_handler = SIG_DFL;
379: curr_signal_action (signum, & signal_action,
380: NULL);
381: } else
382: sigMask (& signal_action.sa_mask);
383:
384: return;
385: }
386:
387: /*
388: * msysgen() is a nop for COHERENT 4.0. The comment in the
389: * assembly code is "Nothing useful to save".
390: */
391:
392: msysgen (u.u_sysgen);
393:
394: /*
395: * When a traced process is signaled, it may need to exchange
396: * data with its parent (via ptret).
397: */
398:
399: if ((SELF->p_flags & PFTRAC) != 0) {
400: SELF->p_flags |= PFWAIT;
401: ptval = ptret (regsetp);
402:
403: T_HAL(0x10000, printf("ptret()=%x ", ptval));
404:
405: SELF->p_flags &= ~ (PFWAIT | PFSTOP);
406:
407: while ((signum = curr_signal_pending ()) != 0)
408: proc_unkill (SELF, signum);
409:
410: if (ptval == 0)
411: /* see if another signal came in */
412: continue;
413:
414: if ((signum = ptval) != SIGKILL)
415: goto got_signal;
416: }
417:
418: /*
419: * Some signals cause a core file to be written.
420: */
421: switch (signum) {
422: case SIGQUIT:
423: case SIGILL:
424: case SIGTRAP:
425: case SIGABRT:
426: case SIGFPE:
427: case SIGSEGV:
428: case SIGSYS:
429: if (sigdump ())
430: signum |= __WCOREFLG;
431: break;
432: }
433: pexit (signum);
434: }
435: }
436:
437: /*
438: * Create a dump of ourselves onto the file `core'.
439: */
440:
441: int
442: sigdump ()
443: {
444: register INODE *ip;
445: register SR *srp;
446: register SEG * sp;
447: register int n;
448: register paddr_t ssize;
449: extern int DUMP_LIM;
450: struct ch_info chInfo;
451: IO io;
452: struct direct dir;
453:
454: if (SELF->p_flags & PFNDMP)
455: return 0;
456:
457: /* Make the core with the real owners */
458: schizo ();
459:
460: io.io_seg = IOSYS;
461: io.io_flag = 0;
462: if (ftoi ("core", 'c', & io, & dir)) {
463: schizo ();
464: return 0;
465: }
466:
467: if ((ip = u.u_cdiri) == NULL) {
468: if ((ip = imake (IFREG | 0644, 0, & io, & dir)) == NULL) {
469: schizo ();
470: return 0;
471: }
472: } else {
473: if ((ip->i_mode & IFMT) != IFREG || iaccess (ip, IPW) == 0 ||
474: getment (ip->i_dev, 1) == NULL) {
475: idetach (ip);
476: schizo ();
477: return 0;
478: }
479: iclear (ip);
480: }
481: schizo ();
482: u.u_error = 0;
483:
484: /* Write core file header */
485: chInfo.ch_magic = CORE_MAGIC;
486: chInfo.ch_info_len = sizeof (chInfo);
487: chInfo.ch_uproc_offset = U_OFFSET;
488:
489: io.io_seek = 0;
490: io.io_seg = IOSYS;
491: io.io.vbase = & chInfo;
492: io.io_ioc = sizeof (chInfo);
493: io.io_flag = 0;
494:
495: iwrite (ip, & io);
496:
497: /*
498: * Added to aid in kernel debugging - if DUMP_TEXT is nonzero,
499: * dump the text segment (to see if it was corrupted) and set
500: * the dump flag so that postmortem utilities will know that
501: * text is present in the core file.
502: */
503:
504: if (DUMP_TEXT)
505: u.u_segl [SISTEXT].sr_flag |= SRFDUMP;
506:
507: for (srp = u.u_segl + 1 ; u.u_error == 0 && srp < u.u_segl + NUSEG ;
508: srp ++) {
509:
510: if ((srp->sr_flag & SRFDUMP) == 0)
511: continue;
512:
513: /* Don't try to dump empty segments. */
514: if ((sp = srp->sr_segp) == NULL) {
515: srp->sr_flag &= ~SRFDUMP;
516: continue;
517: }
518:
519: /* Don't dump segments too big to dump. */
520: if (sp->s_size > DUMP_LIM)
521: srp->sr_flag &= ~SRFDUMP;
522: }
523:
524: /* Always dump the U segment. */
525: u.u_segl [SIUSERP].sr_flag |= SRFDUMP;
526:
527: for (srp = u.u_segl ; u.u_error == 0 && srp < u.u_segl + NUSEG ;
528: srp ++) {
529:
530: /* Only dump segments flagged for dumping. */
531: if ((srp->sr_flag & SRFDUMP) == 0)
532: continue;
533:
534: sp = srp->sr_segp;
535:
536: ssize = sp->s_size;
537: io.io_seg = IOPHY;
538: io.io.pbase = MAPIO (sp->s_vmem, 0);
539: io.io_flag = 0;
540: sp->s_lrefc ++;
541: while (u.u_error == 0 && ssize != 0) {
542: n = ssize > SCHUNK ? SCHUNK : ssize;
543: io.io_ioc = n;
544: iwrite (ip, & io);
545: io.io.pbase += n;
546: ssize -= (paddr_t) n;
547: }
548: sp->s_lrefc --;
549: }
550: idetach (ip);
551: return u.u_error == 0;
552: }
553:
554: /*
555: * Send a ptrace command to the child.
556: *
557: * "pid" is child pid.
558: */
559:
560: int
561: ptset(req, pid, addr, data)
562: unsigned req;
563: int *addr;
564: {
565: register PROC *pp;
566:
567: lock (pnxgate);
568: for (pp = procq.p_nforw ; pp != & procq ; pp = pp->p_nforw)
569: if (pp->p_pid == pid)
570: break;
571: unlock (pnxgate);
572: if (pp == & procq || (pp->p_flags & PFSTOP) == 0 ||
573: pp->p_ppid != SELF->p_pid) {
574: u.u_error = ESRCH;
575: return;
576: }
577:
578: lock (pts.pt_gate);
579: pts.pt_req = req;
580: pts.pt_pid = pid;
581: pts.pt_addr = addr;
582: pts.pt_data = data;
583: pts.pt_errs = 0;
584: pts.pt_rval = 0;
585: pts.pt_busy = 1;
586:
587: wakeup ((char *) & pts.pt_req);
588:
589: while (pts.pt_busy) {
590: x_sleep ((char *) & pts.pt_busy, primed, slpriSigCatch,
591: "ptrace");
592: /* Send a ptrace command to the child. */
593: }
594:
595: u.u_error = pts.pt_errs;
596: unlock (pts.pt_gate);
597: return pts.pt_rval;
598: }
599:
600: /*
601: * This routine is called when a child that is being traced receives a signal
602: * that is not caught or ignored. It follows up on any requests by the parent
603: * and returns when done.
604: *
605: * After ptrace handling done in this routine, a real or simulated signal
606: * may need to be sent to the traced process.
607: * Return a signal number to be sent to the child process, or 0 if none.
608: */
609:
610: static int
611: ptret (regsetp)
612: gregset_t * regsetp;
613: {
614: extern void (*ndpKfrstor)();
615: register PROC *pp;
616: register PROC *pp1;
617: register int sign;
618: unsigned off;
619: int doEmUnpack = 0;
620: struct _fpstate * fstp = empack ();
621:
622: pp = SELF;
623: next:
624: u.u_error = 0;
625: if (pp->p_ppid == 1)
626: return SIGKILL;
627: sign = -1;
628:
629: /* wake up parent if it is sleeping */
630: lock (pnxgate);
631: pp1 = & procq;
632: for (;;) {
633: if ((pp1 = pp1->p_nforw) == & procq) {
634: sign = SIGKILL;
635: break;
636: }
637: if (pp1->p_pid != pp->p_ppid)
638: continue;
639: if (ASLEEP (pp1))
640: wakeup ((char *) pp1);
641: break;
642: }
643: unlock (pnxgate);
644:
645: while (sign < 0) {
646: /* If no pending ptrace transaction for this process, sleep. */
647: if (pts.pt_busy == 0 || pp->p_pid != pts.pt_pid) {
648: /*
649: * If a signal bit is set now, just exit - let
650: * actvsig() handle it next time through.
651: * Doing sleep and goto next will stick us in a loop
652: */
653:
654: if (nondsig ())
655: return 0;
656: x_sleep ((char *) & pts.pt_req, primed,
657: slpriSigCatch, "ptret");
658: goto next;
659: }
660:
661: switch (pts.pt_req) {
662: case PTRACE_RD_TXT:
663: if (__xmode_286 (regsetp)) {
664: pts.pt_rval = getuwd (NBPS + pts.pt_addr);
665: break;
666: }
667: /* Fall through for 386 mode processes. */
668:
669: case PTRACE_RD_DAT:
670: pts.pt_rval = getuwd (pts.pt_addr);
671: break;
672:
673: case PTRACE_RD_USR:
674: /* See ptrace.h for valid offsets. */
675: off = (unsigned) pts.pt_addr;
676: if (off & 3)
677: u.u_error = EINVAL;
678: else if (off < PTRACE_FP_CW) {
679: /* Reading CPU general register state */
680: if (off == PTRACE_SIG)
681: pts.pt_rval = u.u_signo;
682: else
683: pts.pt_rval =
684: ((int *) regsetp) [off >> 2];
685: } else if (off < PTRACE_DR0) {
686: /*
687: * Reading NDP state.
688: * If NDP state not already saved, save it.
689: * Fetch desired info.
690: * Restore NDP state in case we will resume.
691: */
692: if (rdNdpUser ()) {
693: /* if using coprocessor */
694: if (! rdNdpSaved ()) {
695: ndpSave (& u.u_ndpCon);
696: wrNdpSaved (1);
697: }
698: pts.pt_rval = ((int *) & u.u_ndpCon) [(off - PTRACE_FP_CW) >> 2];
699: ndpRestore (& u.u_ndpCon);
700: wrNdpSaved (0);
701: } else if (fstp) {
702: pts.pt_rval = getuwd(((int *) fstp) + ((off - PTRACE_FP_CW) >> 2));
703: /* if emulating */
704: } else { /* no ndp state to display */
705: pts.pt_rval = 0;
706: u.u_error = EFAULT;
707: }
708: } else /* Bad pseudo offset. */
709: u.u_error = EINVAL;
710: break;
711:
712: case PTRACE_WR_TXT:
713: if (__xmode_286 (regsetp)) {
714: putuwd (NBPS + pts.pt_addr, pts.pt_data);
715: break;
716: }
717: /* Fall through for 386 mode processes. */
718:
719: case PTRACE_WR_DAT:
720: putuwd (pts.pt_addr, pts.pt_data);
721: break;
722:
723: case PTRACE_WR_USR:
724: /* See ptrace.h for valid offsets. */
725: off = (unsigned) pts.pt_addr;
726:
727: if (off & 3)
728: u.u_error = EINVAL;
729: else if (off < PTRACE_FP_CW) {
730: /* Writing CPU general register state */
731: if (off == PTRACE_SIG)
732: u.u_error = EINVAL;
733: else
734: ((int *) regsetp) [off >> 2] =
735: pts.pt_data;
736: } else if (off < PTRACE_DR0) {
737: if (rdNdpUser ()) {
738: /*
739: * Writing NDP state.
740: * If NDP state not already saved, save it.
741: * Store desired info.
742: * Restore NDP state in case we will resume.
743: */
744: if (! rdNdpSaved ()) {
745: ndpSave (& u.u_ndpCon);
746: wrNdpSaved (1);
747: }
748: ((int *)&u.u_ndpCon)[(off - PTRACE_FP_CW)>>2] = pts.pt_data;
749: ndpRestore (& u.u_ndpCon);
750: wrNdpSaved (0);
751: } else if (fstp && ndpKfrstor) {
752: putuwd(((int *)fstp) + ((off - PTRACE_FP_CW)>>2), pts.pt_data);
753: doEmUnpack = 1;
754: } else { /* No NDP state to modify. */
755: u.u_error = EFAULT;
756: }
757: } else /* Bad pseudo offset. */
758: u.u_error = EINVAL;
759: break;
760:
761: case PTRACE_RESUME:
762: regsetp->_i386._eflags &= ~ MFTTB;
763: goto sig;
764:
765: case PTRACE_TERM:
766: sign = SIGKILL;
767: break;
768:
769: case PTRACE_SSTEP:
770: regsetp->_i386._eflags |= MFTTB;
771: sig:
772: if (pts.pt_data < 0 || pts.pt_data > NSIG) {
773: u.u_error = EINVAL;
774: break;
775: }
776: sign = pts.pt_data;
777: break;
778:
779: default:
780: u.u_error = EINVAL;
781: }
782:
783: if ((pts.pt_errs = u.u_error) == EFAULT)
784: pts.pt_errs = EINVAL;
785:
786: pts.pt_busy = 0;
787: wakeup((char *) & pts.pt_busy);
788: }
789: if (doEmUnpack)
790: (* ndpKfrstor) (fstp, & u.u_ndpCon);
791: return sign;
792: }
793:
794: /*
795: * If using floating point emulator, make room on user stack and save
796: * floating point context there. Code elsewhere takes care of floating
797: * point context if there is a coprocessor.
798: *
799: * Return the virtual address in user space of the context area, or
800: * return NULL if not using FP emulation.
801: */
802:
803: static struct _fpstate *
804: empack (regsetp)
805: gregset_t * regsetp;
806: {
807: int sphi;
808: struct _fpstate * ret;
809: SEG * segp = u.u_segl [SISTACK].sr_segp;
810: extern void (*ndpKfsave)();
811: unsigned long sw_old;
812:
813: /* If not emulating, do nothing */
814: if (rdNdpUser () || ! rdEmTrapped () || ! ndpKfsave)
815: return NULL;
816:
817: /*
818: * Will copy at least u_sigreturn, _fpstackframe, and ndpFlags.
819: * If using ndp, need room for an _fpstate.
820: * If emulating, need room for an _fpemstate.
821: */
822:
823: ret = (struct _fpstate *)
824: (__xmode_286 (regsetp) ? regsetp->_i286._usp :
825: regsetp->_i386._uesp) - 1;
826:
827: /* Add to user stack if necessary. */
828: sphi = __xmode_286 (regsetp) ? ISP_286 : ISP_386;
829:
830: if (sphi - segp->s_size > (__ptr_arith_t) ret) {
831: cseg_t * pp;
832:
833: pp = c_extend (segp->s_vmem, btoc (segp->s_size));
834: if (pp == 0) {
835: printf ("Empack failed. cmd=%s c_extend(%x,%x)=0 ",
836: u.u_comm, segp->s_vmem, btoc (segp->s_size));
837: return NULL;
838: }
839:
840: segp->s_vmem = pp;
841: segp->s_size += NBPC;
842: if (sproto (0) == 0) {
843: printf ("Empack failed. cmd=%s sproto(0)=0 ",
844: u.u_comm);
845: return NULL;
846: }
847:
848: segload ();
849: }
850:
851: (* ndpKfsave) (& u.u_ndpCon, ret);
852: sw_old = getuwd (& ret->sw);
853: putuwd (& ret->status, sw_old);
854: putuwd (& ret->sw, sw_old & 0x7f00);
855:
856: return ret;
857: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.