/* signal.c -- Manage signals and exceptions Copyright (c) 1994-1998 by Eberhard Mattes This file is part of emx. emx is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. emx is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with emx; see the file COPYING. If not, write to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. As special exception, emx.dll can be distributed without source code unless it has been changed. If you modify emx.dll, this exception no longer applies and you must remove this paragraph from all source files for emx.dll. */ #define INCL_DOSEXCEPTIONS #define INCL_DOSPROCESS #define INCL_DOSSEMAPHORES #define INCL_DOSDATETIME #define INCL_DOSMISC #define INCL_DOSERRORS #include #include "wrapper.h" #include #include #include #include #include "emxdll.h" #define SIGF_CORE 0x01 /* TODO: SIGSTOP */ #define SET_BLOCKED(td,set) ((td)->sig_blocked = (set) & ~_SIGMASK (SIGKILL)) /* This structure describes a signal. */ struct signal_descr { const char *name; /* Name of the signal */ BYTE dfl_action; /* Action for SIG_DFL */ BYTE fun_action; /* Action taken after function */ BYTE flags; /* Flags (SIGF_CORE) */ }; /* Inhibit core dumps. */ BYTE nocore_flag; /* Don't display harderror popups. This is done by terminating the process instead of returning XCPT_CONTINUE_SEARCH from the exception handler. */ BYTE no_popup; /* Event semaphore for temporarily blocked signal. */ HEV signal_sem; /* This flag is set when a temporarily blocked signal is generated. */ char sig_flag; /* When exec() is called in a forked process, we pass on signals to the child process until it terminates. This variable holds the process ID of the child process. If the value is zero, there is no such child process. */ ULONG fork_exec_pid; /* Critical sections for signal processing are protected by this Mutex semaphore. */ static HMTX sig_access; /* 16-bit signal handler. */ extern _far16ptr old_sig16_handler; extern void (*sig16_handler)(void); #define ST_TERM 0 /* Terminate process (SIGINT for instance) */ #define ST_NEXT 1 /* Pass on to next exception handler */ #define ST_IGNORE 2 /* Ignore exception and continue thread */ /* This array contains TRUE for all valid signal numbers. */ char const signal_valid[NSIG] = { FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, /* 0..9 */ TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, /* 10..19 */ FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE /* 20..28 */ }; /* This array contains constant information about the signals: The name of the signal, what to do for SIG_DFL and after calling the signal handler, respectively, and whether to dump core or not. */ static struct signal_descr const signal_info[NSIG] = { {"SIG0", ST_TERM, ST_TERM, 0}, {"SIGHUP", ST_TERM, ST_IGNORE, 0}, {"SIGINT", ST_TERM, ST_IGNORE, 0}, {"SIGQUIT", ST_TERM, ST_IGNORE, SIGF_CORE}, {"SIGILL", ST_NEXT, ST_NEXT, SIGF_CORE}, {"SIGTRAP", ST_NEXT, ST_NEXT, SIGF_CORE}, {"SIGABRT", ST_TERM, ST_TERM, SIGF_CORE}, {"SIGEMT", ST_TERM, ST_TERM, SIGF_CORE}, {"SIGFPE", ST_NEXT, ST_NEXT, SIGF_CORE}, {"SIGKILL", ST_TERM, ST_TERM, 0}, {"SIGBUS", ST_TERM, ST_TERM, SIGF_CORE}, {"SIGSEGV", ST_NEXT, ST_NEXT, SIGF_CORE}, {"SIGSYS", ST_TERM, ST_TERM, SIGF_CORE}, {"SIGPIPE", ST_TERM, ST_IGNORE, 0}, {"SIGALRM", ST_TERM, ST_IGNORE, 0}, {"SIGTERM", ST_NEXT, ST_IGNORE, 0}, {"SIGUSR1", ST_IGNORE, ST_IGNORE, 0}, {"SIGUSR2", ST_IGNORE, ST_IGNORE, 0}, {"SIGCLD", ST_IGNORE, ST_IGNORE, 0}, {"SIG19", ST_TERM, ST_TERM, 0}, {"SIG20", ST_TERM, ST_TERM, 0}, {"SIGBREAK", ST_TERM, ST_IGNORE, 0}, {"SIG22", ST_TERM, ST_TERM, 0}, {"SIG23", ST_TERM, ST_TERM, 0}, {"SIG24", ST_TERM, ST_TERM, 0}, {"SIG25", ST_TERM, ST_TERM, 0}, {"SIG26", ST_TERM, ST_TERM, 0}, {"SIG27", ST_TERM, ST_TERM, 0}, {"SIGWINCH", ST_IGNORE, ST_IGNORE, 0} }; /* Prototypes. */ static ULONG kill_emx (int pid, int signo, int tree); /* Display a message when terminating a process due to signal SIGNO. */ static void signal_message (int signo) { if (signo == SIGABRT) otext ("\r\nAbnormal program termination\r\n"); else oprintf ("\r\nProcess terminated by %s\r\n", signal_info[signo].name); } static void sig_lock (void) { ULONG count; DosEnterMustComplete (&count); request_mutex (sig_access); } static void sig_unlock (void) { ULONG count; DosReleaseMutexSem (sig_access); DosExitMustComplete (&count); } /* Acknowledge the signal to OS/2. */ static void acknowledge (int signo) { switch (signo) { case SIGINT: DosAcknowledgeSignalException (XCPT_SIGNAL_INTR); break; case SIGTERM: DosAcknowledgeSignalException (XCPT_SIGNAL_KILLPROC); break; case SIGBREAK: DosAcknowledgeSignalException (XCPT_SIGNAL_BREAK); break; } } static void acknowledge_mult (ULONG set) { if (set & _SIGMASK (SIGINT)) acknowledge (SIGINT); if (set & _SIGMASK (SIGBREAK)) acknowledge (SIGBREAK); if (set & _SIGMASK (SIGKILL)) acknowledge (SIGKILL); } /* Generate a signal. */ void generate_signal (thread_data *td, int signo) { struct signal_entry *p; sig_lock (); p = td->sig_table + signo; if (p->handler != SIG_IGN) { td->sig_pending |= _SIGMASK (signo); if ((td->sig_blocked & ~td->sig_prev_blocked & _SIGMASK (signo)) && p->handler != SIG_DFL) { /* Wake up __select() */ sig_flag = TRUE; DosPostEventSem (signal_sem); } if (td == threads[1] && get_tid () != 1) { /* Interrupt thread 1 and let it examine its set of pending signals. */ DosFlagProcess (my_pid, FLGP_PID, PFLG_A, 0); } } sig_unlock (); } static void regen_sigcld (int lock) { if (lock) sig_lock (); if (zombie_count > 0) threads[1]->sig_pending |= _SIGMASK (SIGCLD); if (lock) sig_unlock (); } /* Terminate the process. Optionally do a core dump, taking the registers from the syscall stack frame or the exception context record. Actually, the process is not terminated by this function if CONTEXT_RECORD is non-NULL and no_popup is false. */ static void sig_terminate (int signo, syscall_frame *frame, CONTEXTRECORD *context_record) { signal_message (signo); if (signo == SIGKILL || (!nocore_flag && (signal_info[signo].flags & SIGF_CORE))) { if (frame != NULL) { core_regs_i (frame); core_dump (); } else if (context_record != NULL) { core_regs_e (context_record); core_dump (); } } if (context_record == NULL || no_popup) quit (3); } /* Call a signal handler. This function's stack frame contains four magic words, a pointer to the syscall frame, and a pointer to the context record. This allows backtracing over invocations of signal handlers. */ static void call_handler2 (ULONG magic1, ULONG magic2, ULONG magic3, ULONG magic4, syscall_frame *frame, CONTEXTRECORD *context_record, void (*handler)(int), int signo) { handler (signo); } /* Call a signal handler. This function puts magic words into the stack, see call_handler2(). */ static void call_handler1 (void (*handler)(int), int signo, syscall_frame *frame, CONTEXTRECORD *context_record) { call_handler2 (_SIG_MAGIC1, _SIG_MAGIC2, _SIG_MAGIC3, _SIG_MAGIC4, frame, context_record, handler, signo); } /* Deliver a signal. FRAME points to the system call stack frame, CONTEXT_RECORD points to the exception context record. This function must be called with sig_lock() in effect; sig_unlock() is called by this function. Return ST_TERM, ST_IGNORE, or ST_NEXT. */ static int deliver_signal (thread_data *td, int signo, syscall_frame *frame, CONTEXTRECORD *context_record) { struct signal_entry *p; void (*handler)(int signo); ULONG mask, old_blocked; mask = _SIGMASK (signo); p = td->sig_table + signo; td->sig_pending &= ~mask; handler = p->handler; if (handler == SIG_IGN) { /* Ignore the signal. */ sig_unlock (); } else if (handler == SIG_DFL) { /* If the default handler SIG_DFL is installed, check the signal information table to learn whether to ignore the signal or to terminate the process. */ sig_unlock (); if (signal_info[signo].dfl_action != ST_IGNORE) { sig_terminate (signo, frame, context_record); return signal_info[signo].dfl_action; } } else { /* Call the user-defined signal handler. */ if (p->sa_flags & SA_SYSV) { p->handler = SIG_DFL; sig_unlock (); call_handler1 (handler, signo, frame, context_record); } else if (p->sa_flags & SA_ACK) { td->sig_blocked |= mask; sig_unlock (); call_handler1 (handler, signo, frame, context_record); } else { old_blocked = td->sig_blocked; SET_BLOCKED (td, td->sig_blocked | mask | p->sa_mask); sig_unlock (); call_handler1 (handler, signo, frame, context_record); td->sig_blocked = old_blocked; } if (signo == SIGCLD && td == threads[1]) regen_sigcld (TRUE); /* Check the signal information table to learn whether to continue the program or to terminate the process. This is only done when called from an exception handler. */ if (context_record != NULL && signal_info[signo].fun_action != ST_IGNORE) { sig_terminate (signo, frame, context_record); return signal_info[signo].fun_action; } } return ST_IGNORE; } /* Deliver all pending signals. */ int deliver_pending_signals (thread_data *td, syscall_frame *frame, CONTEXTRECORD *context_record) { int signo, action; sig_lock (); while ((td->sig_pending & ~td->sig_blocked) != 0) { for (signo = 1; signo < NSIG; ++signo) if (td->sig_pending & ~td->sig_blocked & _SIGMASK (signo)) { action = deliver_signal (td, signo, frame, context_record); if (action != ST_IGNORE) return action; sig_lock (); } } sig_unlock (); return ST_IGNORE; } /* This function is called from the 16-bit signal handler to generate signal SIGNO (if SIGNO is non-zero) and to deliver pending signals. */ void raise_from_16 (int signo) { if (fork_exec_pid != 0) kill_emx (fork_exec_pid, signo, FALSE); else { if (signo != 0) generate_signal (threads[1], signo); deliver_pending_signals (threads[1], NULL, NULL); } } /* Unblock temporarily blocked signals, raise pending signals. */ void sig_block_end (void) { thread_data *td; td = get_thread (); sig_lock (); td->sig_blocked = td->sig_prev_blocked; td->sig_prev_blocked = 0; sig_unlock (); deliver_pending_signals (td, NULL, NULL); } /* Temporarily block signals (for the duration of a system call). From now on, no signals will be raised. Instead, generated signals will be made pending. */ void sig_block_start (void) { thread_data *td; td = get_thread (); sig_lock (); sig_flag = FALSE; reset_event_sem (signal_sem); /* select() waits for this semaphore */ td->sig_prev_blocked = td->sig_blocked; SET_BLOCKED (td, ~0); sig_unlock (); } /* Send a signal to another process (or process tree). PID is the process ID of the target process and SIGNO is the signal number. Send signal to the process tree starting at PID if tree is true. */ static ULONG kill_emx (int pid, int signo, int tree) { return DosFlagProcess (pid, (tree ? FLGP_SUBTREE : FLGP_PID), PFLG_A, signo); } void do_raise (int signo, syscall_frame *frame) { thread_data *td; td = get_thread (); generate_signal (td, signo); deliver_pending_signals (td, frame, NULL); } /* This function implements the __kill() system call. SIGNO is the signal number (or 0 to check whether the target process is alive). PID is the process ID of the target process. Store the error number (errno) to *ERRNOP. Return 0 on success, -1 on failure. */ int do_kill (int signo, int pid, syscall_frame *frame, int *errnop) { ULONG rc; int org_pid; /* Check whether process PID is alive if SIGNO is 0. */ if (signo == 0) { if (proc_check (pid)) { /* The process is alive. */ *errnop = 0; return 0; } /* The process does not exist. */ *errnop = ESRCH; return -1; } /* Fail if SIGNO is not a valid signal number. */ if (signo < 0 || signo >= NSIG || !signal_valid[signo]) { *errnop = EINVAL; return -1; } /* Map `kill(getpid(),signo)' to `raise(signo)' to enable core dumps. Do this only for the main thread as kill() is defined (for emx) to send the signal to the main thread. */ if (pid == my_pid && get_tid () == 1) { do_raise (signo, frame); *errnop = 0; return 0; } /* Save the original process or group ID and turn a group ID (PID is negative) into a process ID. */ org_pid = pid; if (pid < -1) /* Process group? */ pid = -pid; /* Yes: compute PID from group ID */ /* SIGKILL is treated specially: Call DosKillProcess. */ if (signo == SIGKILL) { /* When sending SIGKILL to a process group, first try to kill the process tree. If this fails, kill only one process. When sending SIGKILL to a single process, kill only that process. */ if (org_pid < -1) { rc = DosKillProcess (DKP_PROCESSTREE, pid); if (rc != 0) rc = DosKillProcess (DKP_PROCESS, pid); } else rc = DosKillProcess (DKP_PROCESS, pid); /* If the process has already been killed but has not yet reacted to the signal, the return code will be ERROR_SIGNAL_PENDING. Ignore this error. */ if (rc == 0 || rc == ERROR_SIGNAL_PENDING) { *errnop = 0; return 0; } *errnop = set_error (rc); return -1; } /* We can send SIGINT and SIGBREAK to child processes. */ if ((signo == SIGINT || signo == SIGBREAK) && pid != my_pid) { rc = DosSendSignalException (pid, ((signo == SIGINT) ? XCPT_SIGNAL_INTR : XCPT_SIGNAL_BREAK)); if (rc == 0) { *errnop = 0; return 0; } /* Seems not to be a child process. Use DosFlagProcess. */ } /* Send the signal via a 16-bit signal (DosFlagProcess). This works only for emx programs. */ if (org_pid < -1) { rc = kill_emx (pid, signo, TRUE); if (rc != 0) rc = kill_emx (pid, signo, FALSE); } else rc = kill_emx (pid, signo, FALSE); if (rc == 0) { *errnop = 0; return 0; } *errnop = set_error (rc); return -1; } /* Set a signal handler or acknowledge a signal. This is the main code for the __signal() system call. SIGNO is the signal number. HANDLER is SIG_DFL, SIG_IGN, SIG_ACK or the address of the signal handler to be used. FRAME points to the syscall stack frame in case we have to dump core. Return the previous (or current for SIG_ACK) signal handler or SIG_ERR on error. */ sigfun *do_signal (ULONG signo, sigfun *handler, syscall_frame *frame) { if (handler == SIG_ACK) { thread_data *td; struct signal_entry *p; void (*result)(int signo); /* Acknowledge (unblock) the signal. */ if (signo < 1 || signo >= NSIG || !signal_valid[signo]) return SIG_ERR; td = get_thread (); p = td->sig_table + signo; sig_lock (); if (!(p->sa_flags & SA_ACK)) { sig_unlock (); return SIG_ERR; } acknowledge (signo); td->sig_blocked &= ~_SIGMASK (signo); result = p->handler; sig_unlock (); deliver_pending_signals (td, frame, NULL); return handler; } else { struct sigaction isa, osa; isa.sa_handler = handler; isa.sa_mask = 0; switch (uflags & _UF_SIG_MODEL) { case _UF_SIG_SYSV: isa.sa_flags = SA_SYSV; break; case _UF_SIG_EMX: isa.sa_flags = SA_ACK; break; default: isa.sa_flags = 0; break; } if (do_sigaction (signo, &isa, &osa) != 0) return SIG_ERR; else return osa.sa_handler; } } /* This function implements the __sigaction() system call. */ int do_sigaction (int signo, const struct sigaction *iact, struct sigaction *oact) { thread_data *td; struct signal_entry *p; struct sigaction output; /* Check the signal number. */ if (signo < 1 || signo >= NSIG || !signal_valid[signo]) return EINVAL; /* Fail if the process tries to set the action for SIGKILL. POSIX.1, 3.3.1.3: "The system shall not allow the action for the signals SIGKILL or SIGSTOP to be set to SIG_IGN." POSIX.1, 3.3.1.3: "The system shall not allow a process to catch the signals SIGKILL and SIGSTOP." POSIX.1, 3.3.4.2: "It is unspecified whether an attempt to set the action for a signal that cannot be caught or ignored to SIG_DFL is ignored or causes an error to be returned with errno set to [EINVAL]." */ if (signo == SIGKILL && iact != NULL) return EINVAL; /* Get a pointer to the thread data block and a pointer to the signal table entry for SIGNO of the current thread. */ td = get_thread (); p = td->sig_table + signo; /* Save the previous action. */ sig_lock (); output.sa_handler = p->handler; output.sa_mask = p->sa_mask; output.sa_flags = p->sa_flags; /* Install new action if IACT is not NULL. */ if (iact != NULL) { p->handler = iact->sa_handler; p->sa_mask = iact->sa_mask; p->sa_flags = iact->sa_flags; if ((p->handler == SIG_DFL && signal_info[signo].dfl_action != ST_IGNORE) || p->handler == SIG_IGN) { /* POSIX.1, 3.3.1.3: "Setting a signal action to SIG_DFL for a signal that is pending, and whose default action is to ignore the signal (for example, SIGCHLD), shall cause the pending signal to be discarded, whether or not it is blocked." POSIX.1, 3.3.1.3: "Setting a signal action to SIG_IGN for a signal that is pending shall cause the pending signal to be discarded, whether or not it is blocked." */ td->sig_pending &= ~_SIGMASK (signo); } if ((p->sa_flags & SA_SYSV) && signo == SIGCLD) regen_sigcld (FALSE); } /* Store previous action to *OACT if OACT is not NULL. Do this after reading *IACT because IACT may point to the same set as OACT. */ if (oact != NULL) *oact = output; sig_unlock (); return 0; } int do_sigpending (sigset_t *set) { thread_data *td; td = get_thread (); sig_lock (); *set = td->sig_blocked & td->sig_pending; sig_unlock (); return 0; } int do_sigprocmask (int how, const sigset_t *iset, sigset_t *oset, syscall_frame *frame) { thread_data *td; ULONG temp, output; td = get_thread (); sig_lock (); output = td->sig_blocked; if (iset != NULL) { switch (how) { case SIG_BLOCK: temp = td->sig_blocked | *iset; break; case SIG_UNBLOCK: temp = td->sig_blocked & ~*iset; break; case SIG_SETMASK: temp = *iset; break; default: sig_unlock (); return EINVAL; } acknowledge_mult (td->sig_blocked & ~temp); SET_BLOCKED (td, temp); } /* Set *OSET after reading *ISET, because ISET may point to the same set as OSET. */ if (oset != NULL) *oset = output; /* POSIX.1, 3.3.5.2: "If there are any pending unblocked signals after the call to the sigprocmask() function, at least one of those signals shall be delivered before the sigprocmask() function returns." */ sig_unlock (); deliver_pending_signals (td, frame, NULL); return 0; } /* This function implements the __pause() system call. Wait for the occurance of a signal. Signals set to SIG_IGN should not make this function return, but they do (for now). */ void do_pause (void) { ULONG rc; do { rc = DosSleep ((ULONG)(-1)); } while (rc == 0); } int do_sigsuspend (const sigset_t *mask) { ULONG old_blocked; thread_data *td; td = get_thread (); sig_lock (); old_blocked = td->sig_blocked; acknowledge_mult (~*mask & td->sig_blocked); SET_BLOCKED (td, *mask); sig_unlock (); do_pause (); td->sig_blocked = old_blocked; return EINTR; } /* Raise signal SIGNO from the exception handler. */ ULONG signal_exception (int signo, CONTEXTRECORD *context) { thread_data *td; struct signal_entry *p; int action; if (fork_exec_pid != 0) { kill_emx (fork_exec_pid, signo, FALSE); acknowledge (signo); return XCPT_CONTINUE_EXECUTION; } /* Get a pointer to the thread data block and a pointer to the signal table entry for SIGNO of the current thread. */ td = get_thread (); p = td->sig_table + signo; if (p->handler != SIG_IGN) { generate_signal (td, signo); action = deliver_pending_signals (td, NULL, context); switch (action) { case ST_TERM: quit (3); case ST_NEXT: acknowledge (signo); return XCPT_CONTINUE_SEARCH; default: break; } } acknowledge (signo); return XCPT_CONTINUE_EXECUTION; } static ULONG trap (EXCEPTIONREPORTRECORD *report, CONTEXTRECORD *context, int signo) { struct signal_entry *p; thread_data *td; /* Don't try to do anything if the stack is invalid or in a nested exception. */ if (report->fHandlerFlags & (EH_STACK_INVALID|EH_NESTED_CALL)) return XCPT_CONTINUE_SEARCH; /* Get a pointer to the thread data block and a pointer to the signal table entry for SIGNO of the current thread. */ td = get_thread (); p = get_thread ()->sig_table + signo; if (p->handler != SIG_IGN) { generate_signal (td, signo); /* Deliver the signal even if its blocked. */ sig_lock (); deliver_signal (td, signo, NULL, context); /* Deliver any other pending signals. */ deliver_pending_signals (td, NULL, context); } /* Invoke the next exception handler. */ return XCPT_CONTINUE_SEARCH; } /* Load a heap page from a dumped executable. */ static void load_heap (ULONG addr) { ULONG rc, cbread, newpos; addr &= ~0xfff; rc = DosSetFilePtr (exe_fhandle, addr - heap_objs[0].base + heap_off, FILE_BEGIN, &newpos); if (rc == 0) rc = DosRead (exe_fhandle, (void *)addr, 0x1000, &cbread); if (rc != 0) { otext ("\r\nCannot read EXE file\r\n"); quit (255); } } /* This is the exception handler. */ ULONG exception (EXCEPTIONREPORTRECORD *report, EXCEPTIONREGISTRATIONRECORD *registration, CONTEXTRECORD *context, void *dummy) { ULONG addr; /* Don't trust -- clear the decrement flag. */ __asm__ ("cld"); /* Don't do anything when unwinding exception handlers. */ if (report->fHandlerFlags & (EH_EXIT_UNWIND|EH_UNWINDING)) return XCPT_CONTINUE_SEARCH; /* The rest of this function depends on the exception number. */ switch (report->ExceptionNum) { case XCPT_GUARD_PAGE_VIOLATION: /* Guard page violation. This exception is used for loading heap pages from a dumped executable. Moreover, this is used by old emx programs for expanding the stack. First, get the address of the page. */ addr = report->ExceptionInfo[1]; /* Load a page from the executable if the page is in the heap and we have a dumped executable. */ if (exe_heap && heap_obj_count >= 1 && addr >= heap_objs[0].base && addr < heap_objs[0].brk) { load_heap (addr); return XCPT_CONTINUE_EXECUTION; } /* Looks like a guard page created by the application program. Pass the exception to the next exception handler. */ return XCPT_CONTINUE_SEARCH; case XCPT_ACCESS_VIOLATION: case XCPT_DATATYPE_MISALIGNMENT: /* Map access violations to SIGSEGV. */ return trap (report, context, SIGSEGV); case XCPT_INTEGER_DIVIDE_BY_ZERO: case XCPT_INTEGER_OVERFLOW: case XCPT_ARRAY_BOUNDS_EXCEEDED: case XCPT_FLOAT_DENORMAL_OPERAND: case XCPT_FLOAT_DIVIDE_BY_ZERO: case XCPT_FLOAT_INEXACT_RESULT: case XCPT_FLOAT_INVALID_OPERATION: case XCPT_FLOAT_OVERFLOW: case XCPT_FLOAT_STACK_CHECK: case XCPT_FLOAT_UNDERFLOW: /* Map integer division by zero and floating point exceptions to SIGFPE. */ return trap (report, context, SIGFPE); case XCPT_ILLEGAL_INSTRUCTION: case XCPT_INVALID_LOCK_SEQUENCE: case XCPT_PRIVILEGED_INSTRUCTION: /* Map the various exceptions for illegal instructions to SIGILL. */ return trap (report, context, SIGILL); case XCPT_SIGNAL: /* Map signal exceptions to SIGINT, SIGTERM or SIGBREAK. */ if (report->cParameters >= 1) switch (report->ExceptionInfo[0]) { case XCPT_SIGNAL_INTR: return signal_exception (SIGINT, context); case XCPT_SIGNAL_KILLPROC: return signal_exception (SIGTERM, context); case XCPT_SIGNAL_BREAK: return signal_exception (SIGBREAK, context); } return XCPT_CONTINUE_SEARCH; } /* The exception is not handled by emx. Pass it to the next exception handler. */ return XCPT_CONTINUE_SEARCH; } /* Install the exception handler for the main thread. REGISTRATION points to the exception registration record, which must be in the stack (at the `bottom' of the stack). */ void install_except (EXCEPTIONREGISTRATIONRECORD *registration) { ULONG rc; registration->prev_structure = NULL; registration->ExceptionHandler = exception; rc = DosSetExceptionHandler (registration); if (rc != 0) error (rc, "DosSetExceptionHandler"); } /* Install the exception handler for another thread. REGISTRATION points to the exception registration record, which must be in the stack (at the `bottom' of the stack). */ int initthread (EXCEPTIONREGISTRATIONRECORD *registration) { ULONG rc; registration->prev_structure = NULL; registration->ExceptionHandler = exception; rc = DosSetExceptionHandler (registration); return 0; } /* We want to receive signals. */ void receive_signals (void) { ULONG times; DosSetSignalExceptionFocus (SIG_SETFOCUS, ×); } void init_exceptions (void) { USHORT old_sig16_action; /* Dummy (output) */ sig_flag = FALSE; create_event_sem (&signal_sem, DC_SEM_SHARED); create_mutex_sem (&sig_access); install_except (exc_reg_ptr); init_signal16 (); DosSetSigHandler (_emx_32to16 (&sig16_handler), &old_sig16_handler, &old_sig16_action, SIGA_ACCEPT, SIG_PFLG_A); } /* alarm() */ static BYTE alarm_started; static BYTE alarm_set; static ULONG alarm_interval; static ULONG alarm_time; static HTIMER alarm_timer; static HEV alarm_sem_timer; static TID alarm_tid; /* Exception handler for alarm_thread(). On termination of the thread, alarm_tid will be set to zero. */ static ULONG alarm_exception (EXCEPTIONREPORTRECORD *report, EXCEPTIONREGISTRATIONRECORD *registration, CONTEXTRECORD *context, void *dummy) { if (report->fHandlerFlags & (EH_EXIT_UNWIND|EH_UNWINDING)) return XCPT_CONTINUE_SEARCH; switch (report->ExceptionNum) { case XCPT_ASYNC_PROCESS_TERMINATE: /* This is the correct one */ case XCPT_PROCESS_TERMINATE: /* OS/2 bug */ alarm_tid = 0; break; } return XCPT_CONTINUE_SEARCH; } static void alarm_thread (ULONG arg) { ULONG rc; EXCEPTIONREGISTRATIONRECORD registration; registration.prev_structure = NULL; registration.ExceptionHandler = alarm_exception; DosSetExceptionHandler (®istration); for (;;) { rc = DosWaitEventSem (alarm_sem_timer, -1); if (rc == 0) { reset_event_sem (alarm_sem_timer); generate_signal (threads[1], SIGALRM); } else if (rc != ERROR_INTERRUPT) error (rc, "DosWaitEventSem"); } } void start_alarm (void) { ULONG rc; if (create_event_sem (&alarm_sem_timer, DC_SEM_SHARED) == 0) { rc = DosCreateThread (&alarm_tid, alarm_thread, 0, CREATE_READY | STACK_COMMITTED, 0x4000); if (rc != 0) error (rc, "DosCreateThread"); else alarm_started = TRUE; } } ULONG set_alarm (ULONG value) { ULONG rc, rest, result; if (!alarm_started) { start_alarm (); if (!alarm_started) return -1; } result = 0; if (alarm_set) { rest = querysysinfo (QSV_TIME_LOW) - alarm_time; if (alarm_interval >= rest) result = alarm_interval - rest; DosStopTimer (alarm_timer); alarm_set = FALSE; reset_event_sem (alarm_sem_timer); } if (value == 0) alarm_interval = 0; else { alarm_set = TRUE; alarm_interval = value; rc = DosAsyncTimer (1000 * value, (HSEM)alarm_sem_timer, &alarm_timer); if (rc != 0) error (rc, "DosAsyncTimer"); alarm_time = querysysinfo (QSV_TIME_LOW); } return result; } void stop_alarm (void) { if (!alarm_started) set_alarm (0); } /* Called from DLL termination routine. */ void term_signal (void) { if (alarm_tid != 0) DosKillThread (alarm_tid); } /* Inherit signal settings from parent process. These are passed in the `_emx_sig' environment variable, which consists of the PID of the parent process (to ensure that we get the signal settings of our parent process), a colon, and a 32-bit number. Bit n is set in that number if signal n is to be ignored. Each number is passed as 8 hexadecimal digits. */ void init2_signal (void) { PSZ val; ULONG ppid, sigset; int sig; if (!(debug_flags & DEBUG_NOINHSIG) && DosScanEnv ("_emx_sig", &val) == 0 && conv_hex8 (val, &ppid) && ppid == init_pib_ptr->pib_ulppid && val[8] == ':' && conv_hex8 (val + 9, &sigset) && val[17] == 0) { for (sig = 1; sig < NSIG; ++sig) if (sigset & (1 << sig)) threads[1]->sig_table[sig].handler = SIG_IGN; } }