![[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 / kernel / coh.386|
Return to sig.c CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / 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: #include <sys/coherent.h> ! 27: #include <errno.h> ! 28: #include <sys/ino.h> ! 29: #include <sys/inode.h> ! 30: #include <sys/io.h> ! 31: #include <sys/proc.h> ! 32: #include <sys/ptrace.h> ! 33: #include <sys/sched.h> ! 34: #include <sys/seg.h> ! 35: #include <signal.h> ! 36: #include <sys/core.h> ! 37: ! 38: /* ! 39: * ---------------------------------------------------------------------- ! 40: * Definitions. ! 41: * Constants. ! 42: * Macros with argument lists. ! 43: * Typedefs. ! 44: * Enums. ! 45: */ ! 46: typedef void (*VFPTR)(); /* pointer to void function */ ! 47: ! 48: /* ! 49: * ---------------------------------------------------------------------- ! 50: * Functions. ! 51: * Import Functions. ! 52: * Export Functions. ! 53: * Local Functions. ! 54: */ ! 55: int actvsig(); ! 56: int nondsig(); ! 57: int ptret(); ! 58: int ptset(); ! 59: void sendsig(); ! 60: void sigDefault(); ! 61: void sigHold(); ! 62: void sigIgnore(); ! 63: void sigPause(); ! 64: void sigRelease(); ! 65: int sigSet(); ! 66: int sigdump(); ! 67: int usigsys(); ! 68: ! 69: static struct _fpstate * empack(); ! 70: ! 71: /* ! 72: * ---------------------------------------------------------------------- ! 73: * Global Data. ! 74: * Import Variables. ! 75: * Export Variables. ! 76: * Local Variables. ! 77: */ ! 78: /* ! 79: * Patchable variables. ! 80: * ! 81: * Patch DUMP_TEXT nonzero to make text segment show up in core files. ! 82: * Patch DUMP_LIM set the upper limit in bytes of how much of a ! 83: * segment is written to a core file. ! 84: * ! 85: * Patch CATCH_SEGV nonzero if you are trying to run software that was ! 86: * written in blatant defiance of the SVID 2 caution that handling SIGSEGV ! 87: * is nonportable and should not be assumed valid on all systems. ! 88: */ ! 89: int DUMP_TEXT = 0; ! 90: int DUMP_LIM=512*1024; ! 91: int CATCH_SEGV = 0; ! 92: ! 93: /* ! 94: * ---------------------------------------------------------------------- ! 95: * Code. ! 96: */ ! 97: ! 98: /* ! 99: * Given 1-based signal number, ask whether a signal handler was ! 100: * attached to the current process using sigset(). This allows ! 101: * the kernel to process sigset() differently from signal(), as ! 102: * required. ! 103: * ! 104: * return 1 if sigset(), 0 if not. ! 105: */ ! 106: int ! 107: sigSet(signal) ! 108: int signal; ! 109: { ! 110: return (SELF->p_dsig & SIG_BIT(signal)) ? 1 : 0; ! 111: } ! 112: ! 113: /* ! 114: * Given 1-based signal number, ignore that signal in the current process. ! 115: */ ! 116: void ! 117: sigIgnore(signal) ! 118: int signal; ! 119: { ! 120: int sigbit = SIG_BIT(signal); ! 121: ! 122: SELF->p_dfsig &= ~sigbit; /* No longer defaulted. */ ! 123: SELF->p_isig |= sigbit; /* Mark signal as ignored. */ ! 124: u.u_sfunc[signal - 1] = SIG_IGN; ! 125: } ! 126: ! 127: /* ! 128: * Given 1-based signal number, restore default handling for the current ! 129: * process. ! 130: * ! 131: * There is some duplication of work done in sigAttach(), but sigDefault() ! 132: * is also called from msig.c ! 133: */ ! 134: void ! 135: sigDefault(signal) ! 136: int signal; ! 137: { ! 138: int sigbit = SIG_BIT(signal); ! 139: ! 140: SELF->p_dfsig |= sigbit; ! 141: SELF->p_isig &= ~sigbit; ! 142: u.u_sfunc[signal - 1] = SIG_DFL; ! 143: } ! 144: ! 145: /* ! 146: * Given 1-based signal number, hold that signal for the current process. ! 147: */ ! 148: void ! 149: sigHold(signal) ! 150: int signal; ! 151: { ! 152: SELF->p_hsig |= SIG_BIT(signal); ! 153: } ! 154: ! 155: /* ! 156: * Given 1-based signal number, pause for that signal for the current process. ! 157: */ ! 158: void ! 159: sigPause(signal) ! 160: int signal; ! 161: { ! 162: SELF->p_hsig &= ~SIG_BIT(signal); ! 163: ! 164: /* ! 165: * Like upause(), do a sleep on an event which never gets a wakeup. ! 166: * The sleep returns immediately if a signal was already holding. ! 167: */ ! 168: x_sleep((char *)&u, prilo, slpriSigCatch, "sigpause"); ! 169: actvsig(); ! 170: } ! 171: ! 172: /* ! 173: * Given 1-based signal number, release that signal for the current process. ! 174: */ ! 175: void ! 176: sigRelease(signal) ! 177: int signal; ! 178: { ! 179: SELF->p_hsig &= ~SIG_BIT(signal); ! 180: if (nondsig()) { ! 181: actvsig(); ! 182: } ! 183: } ! 184: ! 185: /* ! 186: * Given 1-based signal number, a pointer to a signal-handling function, ! 187: * and a flag, attach the signal handler to the current process. ! 188: * ! 189: * Function pointer "func" may take on special values SIG_DFL, SIG_IGN, ! 190: * and, if "how" is SIGSET, SIG_HOLD. ! 191: * ! 192: * The flag "how" is 0 if attachment is via signal(), SIGSET if attachment ! 193: * is via sigset(). ! 194: * ! 195: * Return the previously attached signal handler, or SIG_HOLD if signals ! 196: * were previously held. ! 197: */ ! 198: VFPTR ! 199: sigAttach(signal, func, how) ! 200: int signal; ! 201: VFPTR func; ! 202: int how; ! 203: { ! 204: VFPTR retval; ! 205: int sigbit = SIG_BIT(signal); ! 206: ! 207: /* ! 208: * Set up the return value, which says what was previously ! 209: * done with the given signal. ! 210: */ ! 211: if (SELF->p_isig & sigbit) ! 212: retval = (VFPTR)SIG_IGN; ! 213: else if (SELF->p_hsig & sigbit) ! 214: retval = (VFPTR)SIG_HOLD; ! 215: else ! 216: retval = u.u_sfunc[signal - 1]; ! 217: ! 218: u.u_sigreturn = (VFPTR)(u.u_regl[EDX]); ! 219: u.u_sfunc[signal - 1] = func; ! 220: ! 221: /* ! 222: * Remove previous default, ignore, or hold status. ! 223: */ ! 224: SELF->p_dfsig &= ~sigbit; ! 225: SELF->p_isig &= ~sigbit; ! 226: SELF->p_hsig &= ~sigbit; ! 227: ! 228: /* ! 229: * Any pending signal is lost. ! 230: */ ! 231: SELF->p_ssig &= ~sigbit; ! 232: ! 233: /* ! 234: * Special cases for handler. ! 235: */ ! 236: switch ((int)func) { ! 237: case (int)SIG_DFL: ! 238: sigDefault(signal); ! 239: break; ! 240: case (int)SIG_IGN: ! 241: sigIgnore(signal); ! 242: break; ! 243: case (int)SIG_HOLD: ! 244: sigHold(signal); ! 245: break; ! 246: } ! 247: ! 248: /* ! 249: * Remember whether handler was attached with sigset() vs signal(). ! 250: */ ! 251: if (how == SIGSET) ! 252: SELF->p_dsig |= sigbit; ! 253: else ! 254: SELF->p_dsig &= ~sigbit; ! 255: ! 256: return retval; ! 257: } ! 258: ! 259: /* ! 260: * Set up the action to be taken on a signal. ! 261: */ ! 262: int ! 263: usigsys(signal, func) ! 264: int signal; ! 265: VFPTR func; ! 266: { ! 267: int sigtype; ! 268: int retval = 0; ! 269: ! 270: sigtype = signal & ~0xFF; ! 271: signal &= 0xFF; ! 272: ! 273: T_HAL(8, if (signal == SIGINT) ! 274: printf("[%d]sigint(%x, %x) ", SELF->p_pid, sigtype, func)); ! 275: ! 276: /* Range check on 1-based signal number. */ ! 277: if (signal <= 0 || signal > NSIG) { ! 278: u.u_error = EINVAL; ! 279: return; ! 280: } ! 281: ! 282: /* ! 283: * Don't allow setting/holding/releasing some signals. ! 284: * ! 285: * NOTICE: Ignoring SIGSEGV causes runaway user faults. ! 286: * SVID Issue 2 says *don't* do signal(SIGSEGV,...)!!! ! 287: */ ! 288: if (signal == SIGKILL) { ! 289: u.u_error = EINVAL; ! 290: return; ! 291: } ! 292: ! 293: if (signal == SIGSEGV && CATCH_SEGV == 0) { ! 294: u.u_error = EINVAL; ! 295: return; ! 296: } ! 297: ! 298: switch (sigtype) { ! 299: case SIGHOLD: ! 300: sigHold(signal); ! 301: break; ! 302: case SIGRELSE: ! 303: sigRelease(signal); ! 304: break; ! 305: case SIGIGNORE: ! 306: sigIgnore(signal); ! 307: break; ! 308: case 0: /* old system entry */ ! 309: retval = (int)sigAttach(signal, func, 0); ! 310: break; ! 311: case SIGSET: /* new system entry */ ! 312: retval = (int)sigAttach(signal, func, SIGSET); ! 313: break; ! 314: case SIGPAUSE: ! 315: sigPause(signal); ! 316: break; ! 317: default: ! 318: u.u_error = SIGSYS; ! 319: break; ! 320: } ! 321: return retval; ! 322: } ! 323: ! 324: /* ! 325: * Send a signal to the process `pp'. ! 326: * Return 1 if signal was sent. ! 327: * Return 0 if signal was ignored. ! 328: * The return value is of use to the trap handler. ! 329: */ ! 330: void ! 331: sendsig(sig, pp) ! 332: register unsigned sig; ! 333: register PROC *pp; ! 334: { ! 335: register sig_t f; ! 336: register int s; ! 337: ! 338: T_HAL(8, if (sig == SIGINT) printf("[%d]gets int ", pp->p_pid)); ! 339: ! 340: /* ! 341: * Convert the signal to a bit position. ! 342: */ ! 343: f = SIG_BIT(sig); ! 344: ! 345: /* ! 346: * If the signal is ignored, and is not SIGCLD, do nothing. ! 347: */ ! 348: if ((pp->p_isig & f) && sig != SIGCLD) { ! 349: goto sendSigDone; ! 350: } ! 351: ! 352: /* ! 353: * No further processing for delayed or held signals. ! 354: */ ! 355: if ((pp->p_ssig & f) && (pp->p_hsig|pp->p_dsig) & f) ! 356: goto sendSigDone; ! 357: ! 358: /* ! 359: * Actually send the signal by flagging the needed bit. ! 360: */ ! 361: pp->p_ssig |= f; ! 362: ! 363: /* ! 364: * If the process is sleeping, wake it up so that ! 365: * it can process this signal. ! 366: */ ! 367: if (pp->p_state == PSSLSIG) { ! 368: s = sphi(); ! 369: pp->p_lback->p_lforw = pp->p_lforw; ! 370: pp->p_lforw->p_lback = pp->p_lback; ! 371: #ifndef _I386 ! 372: addu(pp->p_cval, (utimer-pp->p_lctim)*CVCLOCK); ! 373: #endif ! 374: setrun(pp); ! 375: spl(s); ! 376: } ! 377: sendSigDone: ! 378: return; ! 379: } ! 380: ! 381: /* ! 382: * Return signal number if we have a non ignored or delayed signal, else zero. ! 383: */ ! 384: int ! 385: nondsig() ! 386: { ! 387: register PROC *pp; ! 388: register sig_t mask; ! 389: register int signo; ! 390: ! 391: pp = SELF; ! 392: signo = 0; ! 393: ! 394: /* ! 395: * Turn off all ignored signals except SIGCLD. ! 396: */ ! 397: pp->p_ssig &= ~(pp->p_isig & ~SIG_BIT(SIGCLD)); ! 398: ! 399: /* ! 400: * If any signals have arrived, but which are not held, ! 401: * figure out what they are. ! 402: */ ! 403: if (pp->p_ssig&~pp->p_hsig) { ! 404: /* ! 405: * There is at least one signal. Extract its number ! 406: * from the signal bits. ! 407: */ ! 408: mask = (sig_t) 1; ! 409: signo += 1; ! 410: while (((pp->p_ssig&~pp->p_hsig) & mask) == 0) { ! 411: mask <<= 1; ! 412: signo += 1; ! 413: } ! 414: } ! 415: return signo; ! 416: } ! 417: ! 418: /* ! 419: * If we have a signal that isn't ignored, activate it. ! 420: */ ! 421: int ! 422: actvsig() ! 423: { ! 424: register int signum; ! 425: register PROC *pp; ! 426: register int (*func)(); ! 427: int ptval; ! 428: ! 429: /* ! 430: * Fetch an unprocessed signal. ! 431: * Return if there are none. ! 432: * The while() structure is only for traced processes. ! 433: */ ! 434: while (signum = nondsig()) { ! 435: ! 436: pp = SELF; ! 437: ! 438: /* ! 439: * Reset the signal to indicate that it has been processed. ! 440: * Bit table p_ssig uses 0-based signals, while signal.h ! 441: * lists 1-based signals. ! 442: */ ! 443: pp->p_ssig &= ~SIG_BIT(signum); ! 444: ! 445: /* ! 446: * Fetch the user function that goes with this signal. ! 447: * Function table u_sfunc uses 0-based signals, while signal.h ! 448: * lists 1-based signals. ! 449: */ ! 450: func = u.u_sfunc[signum-1]; ! 451: ! 452: /* ! 453: * SIGCLD causes no work here if defaulted or ignored. ! 454: */ ! 455: if (signum == SIGCLD && (func == SIG_DFL || func == SIG_IGN)) ! 456: return; ! 457: ! 458: /* ! 459: * Store the (1-based) signal number in the u area. ! 460: * This is how a core dump records the death signal. ! 461: */ ! 462: u.u_signo = signum; ! 463: ! 464: /* ! 465: * If the signal is not defaulted, go run the requested ! 466: * function. ! 467: */ ! 468: if (func != SIG_DFL) { ! 469: if (XMODE_286) ! 470: oldsigstart(signum, func); ! 471: else { ! 472: msigstart(signum, func); ! 473: } ! 474: return; ! 475: } ! 476: ! 477: /* ! 478: * ASSERTION: the signal being processed is SIG_DFL'd. ! 479: */ ! 480: ! 481: /* ! 482: * msysgen() is a nop for COHERENT 4.0. The comment in the ! 483: * assembly code is "Nothing useful to save". ! 484: */ ! 485: msysgen(u.u_sysgen); ! 486: ! 487: /* ! 488: * When a traced process is signaled, it may need to exchange ! 489: * data with its parent (via ptret). ! 490: */ ! 491: if (pp->p_flags&PFTRAC) { ! 492: pp->p_flags |= PFWAIT; ! 493: ptval = ptret(); ! 494: T_HAL(0x10000, printf("ptret()=%x ", ptval)); ! 495: pp->p_flags &= ~(PFWAIT|PFSTOP); ! 496: if (ptval == 0) ! 497: /* see if another signal came in */ ! 498: continue; ! 499: else ! 500: signum = ptval; ! 501: } ! 502: ! 503: /* ! 504: * Some signals cause a core file to be written. ! 505: */ ! 506: switch(signum) { ! 507: case SIGQUIT: ! 508: case SIGILL: ! 509: case SIGTRAP: ! 510: case SIGABRT: ! 511: case SIGFPE: ! 512: case SIGSEGV: ! 513: case SIGSYS: ! 514: if (sigdump()) ! 515: signum |= 0x80; ! 516: break; ! 517: } ! 518: pexit(signum); ! 519: } ! 520: } ! 521: ! 522: /* ! 523: * Create a dump of ourselves onto the file `core'. ! 524: */ ! 525: int ! 526: sigdump() ! 527: { ! 528: register INODE *ip; ! 529: register SR *srp; ! 530: register SEG * sp; ! 531: register int n; ! 532: register paddr_t ssize; ! 533: extern int DUMP_LIM; ! 534: struct ch_info chInfo; ! 535: ! 536: if (SELF->p_flags&PFNDMP) ! 537: return (0); ! 538: u.u_io.io_seg = IOSYS; ! 539: u.u_io.io_flag = 0; ! 540: /* Make the core with the real owners */ ! 541: schizo(); ! 542: if (ftoi("core", 'c')) { ! 543: schizo(); ! 544: return (0); ! 545: } ! 546: if ((ip=u.u_cdiri) == NULL) { ! 547: if ((ip=imake(IFREG|0644, 0)) == NULL) { ! 548: schizo(); ! 549: return (0); ! 550: } ! 551: } else { ! 552: if ((ip->i_mode&IFMT)!=IFREG ! 553: || iaccess(ip, IPW)==0 ! 554: || getment(ip->i_dev, 1)==NULL) { ! 555: idetach(ip); ! 556: schizo(); ! 557: return (0); ! 558: } ! 559: iclear(ip); ! 560: } ! 561: schizo(); ! 562: u.u_error = 0; ! 563: u.u_io.io_seek = 0; ! 564: ! 565: /* Write core file header */ ! 566: chInfo.ch_magic = CORE_MAGIC; ! 567: chInfo.ch_info_len = sizeof(chInfo); ! 568: chInfo.ch_uproc_offset = U_OFFSET; ! 569: ! 570: u.u_io.io_seg = IOSYS; ! 571: u.u_io.io.vbase = &chInfo; ! 572: u.u_io.io_ioc = sizeof(chInfo); ! 573: u.u_io.io_flag = 0; ! 574: ! 575: sp->s_lrefc++; ! 576: iwrite(ip, &u.u_io); ! 577: sp->s_lrefc--; ! 578: ! 579: /* ! 580: * Added to aid in kernel debugging - if DUMP_TEXT is nonzero, ! 581: * dump the text segment (to see if it was corrupted) and set ! 582: * the dump flag so that postmortem utilities will know that ! 583: * text is present in the core file. ! 584: */ ! 585: if (DUMP_TEXT) ! 586: u.u_segl[SISTEXT].sr_flag |= SRFDUMP; ! 587: ! 588: for (srp=u.u_segl; u.u_error==0 && srp<&u.u_segl[NUSEG]; srp++) { ! 589: ! 590: if ((srp->sr_flag & SRFDUMP)==0) ! 591: continue; ! 592: ! 593: /* Don't try to dump empty segments. */ ! 594: if ((sp = srp->sr_segp)==NULL) { ! 595: srp->sr_flag &= ~SRFDUMP; ! 596: continue; ! 597: } ! 598: ! 599: /* Don't dump segments too big to dump. */ ! 600: if (sp->s_size > DUMP_LIM) ! 601: srp->sr_flag &= ~SRFDUMP; ! 602: } ! 603: ! 604: for (srp=u.u_segl; u.u_error==0 && srp<&u.u_segl[NUSEG]; srp++) { ! 605: ! 606: /* Only dump segments flagged for dumping. */ ! 607: if ((srp->sr_flag & SRFDUMP)==0) ! 608: continue; ! 609: ! 610: ssize = sp->s_size; ! 611: u.u_io.io_seg = IOPHY; ! 612: u.u_io.io.pbase = MAPIO(sp->s_vmem, 0); ! 613: u.u_io.io_flag = 0; ! 614: sp->s_lrefc++; ! 615: while (u.u_error == 0 && ssize != 0) { ! 616: n = ssize > SCHUNK ? SCHUNK : ssize; ! 617: u.u_io.io_ioc = n; ! 618: iwrite(ip, &u.u_io); ! 619: u.u_io.io.pbase += n; ! 620: ssize -= (paddr_t)n; ! 621: } ! 622: sp->s_lrefc--; ! 623: } ! 624: idetach(ip); ! 625: return (u.u_error==0); ! 626: } ! 627: ! 628: /* ! 629: * Send a ptrace command to the child. ! 630: * ! 631: * "pid" is child pid. ! 632: */ ! 633: int ! 634: ptset(req, pid, addr, data) ! 635: unsigned req; ! 636: int *addr; ! 637: { ! 638: register PROC *pp; ! 639: ! 640: lock(pnxgate); ! 641: for (pp=procq.p_nforw; pp!=&procq; pp=pp->p_nforw) ! 642: if (pp->p_pid == pid) ! 643: break; ! 644: unlock(pnxgate); ! 645: if (pp==&procq || (pp->p_flags&PFSTOP)==0 || pp->p_ppid!=SELF->p_pid){ ! 646: u.u_error = ESRCH; ! 647: return; ! 648: } ! 649: lock(pts.pt_gate); ! 650: pts.pt_req = req; ! 651: pts.pt_pid = pid; ! 652: pts.pt_addr = addr; ! 653: pts.pt_data = data; ! 654: pts.pt_errs = 0; ! 655: pts.pt_rval = 0; ! 656: pts.pt_busy = 1; ! 657: wakeup((char *)&pts.pt_req); ! 658: while (pts.pt_busy) { ! 659: x_sleep((char *)&pts.pt_busy, primed, slpriSigCatch, "ptrace"); ! 660: /* Send a ptrace command to the child. */ ! 661: } ! 662: u.u_error = pts.pt_errs; ! 663: unlock(pts.pt_gate); ! 664: return (pts.pt_rval); ! 665: } ! 666: ! 667: /* ! 668: * This routine is called when a child that is being traced receives a signal ! 669: * that is not caught or ignored. It follows up on any requests by the parent ! 670: * and returns when done. ! 671: * ! 672: * After ptrace handling done in this routine, a real or simulated signal ! 673: * may need to be sent to the traced process. ! 674: * Return a signal number to be sent to the child process, or 0 if none. ! 675: */ ! 676: int ! 677: ptret() ! 678: { ! 679: extern void (*ndpKfrstor)(); ! 680: register PROC *pp; ! 681: register PROC *pp1; ! 682: register int sign; ! 683: unsigned off; ! 684: int doEmUnpack = 0; ! 685: ! 686: struct _fpstate * fstp = empack(); ! 687: ! 688: pp = SELF; ! 689: next: ! 690: u.u_error = 0; ! 691: if (pp->p_ppid == 1) ! 692: return (SIGKILL); ! 693: sign = -1; ! 694: ! 695: /* wake up parent if it is sleeping */ ! 696: lock(pnxgate); ! 697: pp1 = &procq; ! 698: for (;;) { ! 699: if ((pp1=pp1->p_nforw) == &procq) { ! 700: sign = SIGKILL; ! 701: break; ! 702: } ! 703: if (pp1->p_pid != pp->p_ppid) ! 704: continue; ! 705: if (ASLEEP(pp1)) ! 706: wakeup((char *)pp1); ! 707: break; ! 708: } ! 709: unlock(pnxgate); ! 710: ! 711: while (sign < 0) { ! 712: /* If no pending ptrace transaction for this process, sleep. */ ! 713: if (pts.pt_busy==0 || pp->p_pid!=pts.pt_pid) { ! 714: /* If a signal bit is set now, just exit - let ! 715: * actvsig() handle it next time through. ! 716: * Doing sleep and goto next will stick us in a loop */ ! 717: if (nondsig()) ! 718: return 0; ! 719: x_sleep((char *)&pts.pt_req, ! 720: primed, slpriSigCatch, "ptret"); ! 721: goto next; ! 722: } ! 723: switch (pts.pt_req) { ! 724: case PTRACE_RD_TXT: ! 725: if (XMODE_286) { ! 726: pts.pt_rval = getuwd(NBPS+pts.pt_addr); ! 727: break; ! 728: } ! 729: /* Fall through for 386 mode processes. */ ! 730: case PTRACE_RD_DAT: ! 731: pts.pt_rval = getuwd(pts.pt_addr); ! 732: break; ! 733: case PTRACE_RD_USR: ! 734: /* See ptrace.h for valid offsets. */ ! 735: off = (unsigned)pts.pt_addr; ! 736: if (off & 3) ! 737: u.u_error = EINVAL; ! 738: else if (off < PTRACE_FP_CW) { ! 739: /* Reading CPU general register state */ ! 740: if (off == PTRACE_SIG) ! 741: pts.pt_rval = u.u_signo; ! 742: else ! 743: pts.pt_rval = u.u_regl[off>>2]; ! 744: } else if (off < PTRACE_DR0) { ! 745: /* ! 746: * Reading NDP state. ! 747: * If NDP state not already saved, save it. ! 748: * Fetch desired info. ! 749: * Restore NDP state in case we will resume. ! 750: */ ! 751: if (rdNdpUser()) { ! 752: /* if using coprocessor */ ! 753: if (!rdNdpSaved()) { ! 754: ndpSave(&u.u_ndpCon); ! 755: wrNdpSaved(1); ! 756: } ! 757: pts.pt_rval = ((int *)&u.u_ndpCon)[(off - PTRACE_FP_CW)>>2]; ! 758: ndpRestore(&u.u_ndpCon); ! 759: wrNdpSaved(0); ! 760: } else if (fstp) { ! 761: pts.pt_rval = getuwd(((int *)fstp) + ((off - PTRACE_FP_CW)>>2)); ! 762: /* if emulating */ ! 763: } else /* no ndp state to display */ ! 764: pts.pt_rval = 0; ! 765: } else ! 766: u.u_error = EINVAL; ! 767: break; ! 768: case PTRACE_WR_TXT: ! 769: if (XMODE_286) { ! 770: putuwd(NBPS+pts.pt_addr, pts.pt_data); ! 771: break; ! 772: } ! 773: /* Fall through for 386 mode processes. */ ! 774: case PTRACE_WR_DAT: ! 775: putuwd(pts.pt_addr, pts.pt_data); ! 776: break; ! 777: case PTRACE_WR_USR: ! 778: /* See ptrace.h for valid offsets. */ ! 779: off = (unsigned)pts.pt_addr; ! 780: ! 781: if (off & 3) ! 782: u.u_error = EINVAL; ! 783: else if (off < PTRACE_FP_CW) { ! 784: /* Writing CPU general register state */ ! 785: if (off == PTRACE_SIG) ! 786: u.u_error = EINVAL; ! 787: else ! 788: u.u_regl[off>>2] = pts.pt_data; ! 789: } else if (off < PTRACE_DR0) { ! 790: if (rdNdpUser()) { ! 791: /* ! 792: * Writing NDP state. ! 793: * If NDP state not already saved, save it. ! 794: * Store desired info. ! 795: * Restore NDP state in case we will resume. ! 796: */ ! 797: if (!rdNdpSaved()) { ! 798: ndpSave(&u.u_ndpCon); ! 799: wrNdpSaved(1); ! 800: } ! 801: ((int *)&u.u_ndpCon)[(off - PTRACE_FP_CW)>>2] = pts.pt_data; ! 802: ndpRestore(&u.u_ndpCon); ! 803: wrNdpSaved(0); ! 804: } else if (fstp && ndpKfrstor) { ! 805: putuwd(((int *)fstp) + ((off - PTRACE_FP_CW)>>2), pts.pt_data); ! 806: doEmUnpack = 1; ! 807: } ! 808: } else ! 809: u.u_error = EINVAL; ! 810: break; ! 811: case PTRACE_RESUME: ! 812: u.u_regl[EFL] &= ~MFTTB; ! 813: goto sig; ! 814: case PTRACE_TERM: ! 815: sign = SIGKILL; ! 816: break; ! 817: case PTRACE_SSTEP: ! 818: u.u_regl[EFL] |= MFTTB; ! 819: sig: ! 820: if (pts.pt_data<0 || pts.pt_data>NSIG) { ! 821: u.u_error = EINVAL; ! 822: break; ! 823: } ! 824: sign = pts.pt_data; ! 825: if (pts.pt_addr != SIG_IGN) { ! 826: u.u_regl[EIP] = (int)pts.pt_addr; ! 827: } ! 828: break; ! 829: default: ! 830: u.u_error = EINVAL; ! 831: } ! 832: if ((pts.pt_errs=u.u_error) == EFAULT) ! 833: pts.pt_errs = EINVAL; ! 834: pts.pt_busy = 0; ! 835: wakeup((char *)&pts.pt_busy); ! 836: } ! 837: if (doEmUnpack) ! 838: (*ndpKfrstor)(fstp, &u.u_ndpCon); ! 839: return (sign); ! 840: } ! 841: ! 842: /* ! 843: * If using floating point emulator, make room on user stack and save ! 844: * floating point context there. Code elsewhere takes care of floating ! 845: * point context if there is a coprocessor. ! 846: * ! 847: * Return the virtual address in user space of the context area, or ! 848: * return NULL if not using FP emulation. ! 849: */ ! 850: static struct _fpstate * ! 851: empack() ! 852: { ! 853: int uesp; ! 854: int sphi, splo; ! 855: SEG * segp; ! 856: cseg_t * pp; ! 857: struct _fpstate * ret = NULL; ! 858: extern void (*ndpKfsave)(); ! 859: unsigned long sw_old; ! 860: ! 861: /* If not emulating, do nothing */ ! 862: if (rdNdpUser() || !rdEmTrapped() || !ndpKfsave) ! 863: return NULL; ! 864: ! 865: /* ! 866: * Will copy at least u_sigreturn, _fpstackframe, and ndpFlags. ! 867: * If using ndp, need room for an _fpstate. ! 868: * If emulating, need room for an _fpemstate. ! 869: */ ! 870: uesp = u.u_regl[UESP] - sizeof(struct _fpstate); ! 871: ! 872: /* Add to user stack if necessary. */ ! 873: segp = u.u_segl[SISTACK].sr_segp; ! 874: sphi = (XMODE_286) ? ISP_286 : ISP_386; ! 875: splo = sphi - segp->s_size; ! 876: ! 877: if (splo > uesp) { ! 878: pp = c_extend(segp->s_vmem, btoc(segp->s_size)); ! 879: if (pp==0) { ! 880: printf("Empack failed. cmd=%s c_extend(%x,%x)=0 ", ! 881: u.u_comm, segp->s_vmem, btoc(segp->s_size)); ! 882: return NULL; ! 883: } ! 884: ! 885: segp->s_vmem = pp; ! 886: segp->s_size += NBPC; ! 887: if (sproto(0)==0) { ! 888: printf("Empack failed. cmd=%s sproto(0)=0 ", ! 889: u.u_comm); ! 890: return NULL; ! 891: } ! 892: ! 893: segload(); ! 894: } ! 895: ! 896: ret = (struct _fpstate *)uesp; ! 897: (*ndpKfsave)(&u.u_ndpCon, uesp); ! 898: sw_old = getuwd(&ret->sw); ! 899: putuwd(&ret->status, sw_old); ! 900: putuwd(&ret->sw, sw_old & 0x7f00); ! 901: ! 902: return ret; ! 903: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.