home *** CD-ROM | disk | FTP | other *** search
/ Internet MPEG Audio Archive / IMAA.mdf / util / dos / l3v100n / rsx / source / signals.c < prev    next >
C/C++ Source or Header  |  1994-01-19  |  7KB  |  287 lines
  1. /* This file is SIGNALS.C
  2. **
  3. ** contains :
  4. **
  5. **    - signal handling
  6. **    - exception handling
  7. **
  8. ** Copyright (c) Rainer Schnitker '92 '93
  9. */
  10.  
  11. #include <stdio.h>
  12. #include <string.h>
  13. #include <errno.h>
  14. #include "DPMI.H"
  15. #include "PROCESS.H"
  16. #include "SIGNALS.H"
  17. #include "START32.H"
  18. #include "CDOSX32.H"
  19. #include "EXCEP32.H"
  20. #include "ADOSX32.H"
  21. #include "COPY32.H"
  22. #include "RSX.H"
  23.  
  24. /* local functions */
  25. static int exception2signal(WORD);
  26. static int signal_handler_returned(WORD);
  27. static int do_signal(WORD);
  28. static void print_exception_exit(void);
  29. static void print_regs_exception(void);
  30.  
  31. /* regs after exceptions */
  32. REG386 regf;
  33. extern char *sigtext[];
  34.  
  35. /*
  36. ** give back a signal no from a hardware exception fault no
  37. */
  38. static int exception2signal(WORD faultno)
  39. {
  40.     int signal;
  41.  
  42.     switch (faultno) {
  43.     case 0:
  44.     case 2:
  45.     case 4:
  46.     case 5:
  47.     case 6:
  48.     case 8:
  49.     case 10:
  50.     case 15:
  51.     signal = SIGILL;
  52.     break;
  53.     case 1:
  54.     case 3:
  55.     signal = SIGTRAP;
  56.     break;
  57.     case 7:
  58.     case 16:
  59.     signal = SIGFPE;
  60.     break;
  61.     case 9:
  62.     case 11:
  63.     case 12:
  64.     case 13:
  65.     case 14:
  66.     case 17:
  67.     signal = SIGSEGV;
  68.     break;
  69.     default:
  70.     signal = SIGSEGV;
  71.     break;
  72.     }
  73.  
  74.     return signal;
  75. }
  76.  
  77. /*
  78. ** signal handlers have a return address 0xffffffff
  79. ** if signal handler returned: caused a gp-fault no_13
  80. ** restore all registers, check raise() , back to user
  81. */
  82. static int signal_handler_returned(WORD faultno)
  83. {
  84.     WORD sig;
  85.  
  86.     /* returned signal caused only a GP-fault 0xD */
  87.     if (faultno != 13)
  88.     return 0;
  89.  
  90.     /* test [eip]==ret instruction*/
  91.     if (verify_illegal(npz, EIP, sizeof(DWORD)))
  92.     return 0;
  93.     if ((BYTE) read32(npz->data32sel, EIP) != (BYTE) 0xC3)
  94.     return 0;
  95.  
  96.     /* test [esp]==0xffffffff */
  97.     if (verify_illegal(npz, ESP, 2 * sizeof(DWORD)))
  98.     return 0;
  99.     if (read32(npz->data32sel, ESP) != 0xffffffff)
  100.     return 0;
  101.     sig = (WORD) read32(npz->data32sel, ESP + 4);
  102.  
  103.     /* get saved values from stack (stackpos+=ret address + sig no) */
  104.     cpy32_16(npz->data32sel, ESP + 2 * sizeof(DWORD), &(npz->regs), sizeof(REG386));
  105.  
  106.     if (AX == 0x7f0E) {        /* back from raise() */
  107.     EAX = ECX = 0;        /* put return values */
  108.     }
  109.     /*
  110.     ** if we had a hardware exception, we zero the user handler, to
  111.     ** prevent a exception loop to handler (may be changed in future)
  112.     */
  113.     else if (sig == SIGSEGV || sig == SIGILL || sig == SIGFPE || sig == SIGTRAP) {
  114.     npz->sigs[sig] = 0;
  115.     npz->sig_ack &= ~(1L << sig);
  116.     }
  117.     return 1;
  118. }
  119.  
  120. /*
  121. ** called before return to user process
  122. */
  123. int check_signals(void)
  124. {
  125.     int i;
  126.     DWORD sigs;
  127.  
  128.     sigs = ~npz->sig_ack & npz->sig_raised;
  129.     if (!sigs)
  130.     return 0;
  131.  
  132.     for (i = 0; i < MAX_SIGNALS; i++) {
  133.     if (sigs & 1)
  134.         if (do_signal(i))
  135.         return 1;
  136.     sigs >>= 1;
  137.     }
  138.     return 0;
  139. }
  140.  
  141. /*
  142. ** check signals settings , change eip to signal handler
  143. */
  144. static int do_signal(WORD signal)
  145. {
  146.     DWORD address;
  147.     DWORD mask;
  148.  
  149.     if (opt_printall)
  150.     printf("do_signal %d\n", signal);
  151.  
  152.     if ((npz->p_flags & PF_DEBUG) && signal != SIGKILL) {
  153.     npz->p_status = PS_STOP;
  154.     npz->wait_return = (signal << 8) | 127;
  155.     npz->p_flags |= PF_WAIT_WAIT;
  156.     switch_to_process(npz->pptr);
  157.     EAX = ECX = 0;
  158.     npz->p_status = PS_RUN;
  159.     return 1;
  160.     }
  161.     address = npz->sigs[signal];/* handler address */
  162.  
  163.     if (address == 1L)        /* ignore sig */
  164.     return 0;
  165.  
  166.     if (address == 0L) {
  167.     if (signal == SIGCLD) {
  168.         npz->sig_raised &= ~(1L << SIGCLD);    /* clear SIGCLD signal */
  169.         return 0;        /* sigcld,not terminate */
  170.     }
  171.     do_exit4c(signal);
  172.     return 1;
  173.     }
  174.     mask = 1L << signal;
  175.  
  176.     /* ok, do user handler */
  177.     npz->sig_raised &= ~mask;    /* clear sig_raised */
  178.     npz->sig_ack |= mask;    /* set blocked */
  179.  
  180.     if (ESP == ESPORG)        /* build stack-frame,if not */
  181.     ESP -= 12;
  182.  
  183.     /* save regs for handler return, put reg values on user stack */
  184.     cpy16_32(npz->data32sel, ESP - sizeof(REG386),
  185.          &(npz->regs), sizeof(REG386));
  186.     ESP -= sizeof(REG386);    /* sub register-frame */
  187.  
  188.     EIP = address;        /* sighandler address */
  189.  
  190.     ESP -= sizeof(long);    /* put signalno on user stack */
  191.     store32(npz->data32sel, ESP, signal);
  192.     ESP -= sizeof(long);    /* put bad return address on user stack */
  193.     store32(npz->data32sel, ESP, 0xFFFFFFFF);
  194.     ESP -= 12;            /* sub iret frame */
  195.  
  196.     return 1;
  197. }
  198.  
  199. char *exceptext[] =
  200. {
  201.     "division by zero",
  202.     "debug",
  203.     "NMI",
  204.     "breakpoint",
  205.     "overflow",
  206.     "bound check",
  207.     "invalid opcode",
  208.     "copro not availble",
  209.     "double fault",
  210.     "copro exception",
  211.     "invalid TSS",
  212.     "segment not present",
  213.     "stack fault",
  214.     "general protection",
  215.     "page fault",
  216.     "reserved",
  217.     "copro error",
  218.     "alignment error"
  219. };
  220. /*
  221. ** this function is called after hardware exceptions
  222. */
  223. void myexcep13(void)
  224. {                /* C exception handler */
  225.     int signal;
  226.  
  227.     if (opt_printall)
  228.     printf("Exception %d\n", (WORD) regf.faultno);
  229.  
  230.     /* test if we have a error in kernel, abort rsx */
  231.     /* future versions will just terminate the running process */
  232.  
  233.     if ((WORD) regf.cs == code16sel || (WORD) regf.ds == data16sel) {
  234.     printf("Kernel fault at %X %lX\n", (WORD) regf.cs, regf.eip);
  235.     printf("EAX=%08lX EBX=%08lX ECX=%08lX EDX=%08lX\n"
  236.            "EBP=%08lX ESP=%08lX  ESI=%08lX EDI=%08lX\n"
  237.            "CS=%04X DS=%04X ES=%04X SS=%04X\n",
  238.            regf.eax, regf.ebx, regf.ecx, regf.edx,
  239.            regf.ebp, regf.esp, regf.esi, regf.edi,
  240.      (WORD) regf.cs, (WORD) regf.ds, (WORD) regf.es, (WORD) regf.ss);
  241.  
  242.     printf("User Registers:\n");
  243.     npz->regs.faultno = regf.faultno;
  244.     print_exception_exit();
  245.     }
  246.     /* user fault, copy saved regs to process table */
  247.     memcpy(&(npz->regs), ®f, sizeof(REG386));
  248.  
  249.     /* if signal-handler returns (caused gp-fault), back to program */
  250.     if (signal_handler_returned(FAULTNO))
  251.     return;
  252.  
  253.     /* ok, we have a normal fault, get convert to signal */
  254.     signal = exception2signal(FAULTNO);
  255.  
  256.     if (signal != SIGTRAP) {
  257.     printf("process %d get hardware fault %d (%s) at %lX\n",
  258.            npz->pid, FAULTNO, exceptext[FAULTNO], EIP);
  259.     if (opt_printall)
  260.         print_regs_exception();
  261.     }
  262.     send_signal(npz, signal);
  263.  
  264.     /* then, check_signal() is called (see excep32.asm) */
  265. }
  266.  
  267. static void print_regs_exception(void)
  268. {
  269.     printf("selector=%lX  errbits: %X\n"
  270.        "cs:eip=%04X:%08lX eflags=%08lX\n"
  271.        "eax=%08lX ebx=%08lX ecx=%08lX edx=%08lX\n"
  272.        "ebp=%08lX esp=%08lX  esi=%08lX edi=%08lX\n"
  273.        "cs=%04X ds=%04X es=%04X ss=%04X fs=%04X gs=%04X\n",
  274.        ERR & ~7L, (WORD) ERR & 7,
  275.        CS, EIP, EFLAGS,
  276.        EAX, EBX, ECX, EDX,
  277.        EBP, ESP, ESI, EDI,
  278.        CS, DS, ES, SS, FS, GS);
  279. }
  280.  
  281. static void print_exception_exit()
  282. {
  283.     printf("PROTECTION FAULT  %d :\n", FAULTNO);
  284.     print_regs_exception();
  285.     shut_down(3);
  286. }
  287.