Changeset 1617

Timestamp:

Nov 7, 2004, 10:33:03 AM (21 years ago)

Author:

bird

Message:

Debugging signals.

Location:

trunk/src/emx

Files:

• include/InnoTekLIBC/backend.h (modified) (2 diffs, 1 prop)
• include/InnoTekLIBC/logstrict.h (modified) (2 diffs, 1 prop)
• include/InnoTekLIBC/sharedpm.h (modified) (3 diffs, 1 prop)
• include/InnoTekLIBC/signals.h (deleted)
• include/sys/_sigset.h (modified) (3 diffs, 1 prop)
• include/sys/cdefs.h (modified) (21 diffs, 1 prop)
• include/sys/signal.h (modified) (6 diffs, 1 prop)
• src/lib/libc.def (modified) (1 diff, 1 prop)
• src/lib/process/kill.c (modified) (1 diff, 1 prop)
• src/lib/process/raise.c (modified) (1 diff, 1 prop)
• src/lib/process/sigaction.c (modified) (4 diffs, 1 prop)
• src/lib/process/sigaltstack.c (modified) (3 diffs, 1 prop)
• src/lib/process/sigprocmask.c (modified) (2 diffs, 1 prop)
• src/lib/sys/386/signal16bit.asm (modified) (1 diff, 1 prop)
• src/lib/sys/__init.c (modified) (3 diffs, 1 prop)
• src/lib/sys/__select.c (modified) (2 diffs, 1 prop)
• src/lib/sys/b_signalMask.c (added)
• src/lib/sys/b_signalSendPGrp.c (modified) (1 diff, 1 prop)
• src/lib/sys/b_signalSendPid.c (modified) (2 diffs, 1 prop)
• src/lib/sys/b_signalStack.c (added)
• src/lib/sys/b_signalVerifyPGrp.c (modified) (2 diffs, 1 prop)
• src/lib/sys/b_signalVerifyPid.c (modified) (2 diffs, 1 prop)
• src/lib/sys/libcfork.c (modified) (1 diff, 1 prop)
• src/lib/sys/logstrict.c (modified) (1 diff, 1 prop)
• src/lib/sys/sharedpm.c (modified) (11 diffs, 1 prop)
• src/lib/sys/signals.c (modified) (54 diffs, 1 prop)
• src/lib/sys/signals.h (added)

trunk/src/emx/include/InnoTekLIBC/backend.h

@@ -30 +30 @@
 #include <sys/cdefs.h>
 #include <sys/types.h>
+#include <signal.h>
 #include <emx/io.h>
+
 
 __BEGIN_DECLS
@@ -446 +448 @@
 
 
+/** @defgroup   __libc_Back_signal      LIBC Backend - Signals
+ * @{
+ */
+
+/** @defgroup __libc_Back_signalRaise_return    __libc_back_signalRaise() returns.
+ * These are only valid for positive return values.
+ * @{ */
+/** Try restart any interrupted system call. */
+#define __LIBC_BSRR_RESTART     0x01
+/** Go ahead interrupt system call in progress. */
+#define __LIBC_BSRR_INTERRUPT   0x02
+/** If set execution should be resumed. */
+#define __LIBC_BSRR_CONTINUE    0x10
+/** If set execution should not be resumed but the signal should be passed
+ * on to the system. */
+#define __LIBC_BSRR_PASSITON    0x20
+/** If set the passed in SIGQUEUED structure was used. */
+#define __LIBC_BSRR_USED_QUEUED 0x40
+/** @} */
+
+/** @defgroup __libc_back_signalRaise_flags     __libc_back_signalRaise() flags.
+ * @{ */
+/** The signal is thread specific and must be delivered to the current thread. */
+#define __LIBC_BSRF_THREAD      0x01
+/** The signal was send from an unknown process. */
+#define __LIBC_BSRF_EXTERNAL    0x02
+/** The signal was generated by the hardware (i.e. CPUs and such). */
+#define __LIBC_BSRF_HARDWARE    0x04
+/** The signal should be queued. */
+#define __LIBC_BSRF_QUEUED      0x08
+/** @} */
+
+
+/**
+ * Raises a signal in the current process.
+ *
+ * @returns On success a flag mask out of the __LIBC_BSRR_* #defines is returned.
+ * @returns On failure a negative error code (errno.h) is returned.
+ * @param   iSignalNo           Signal to raise.
+ * @param   pSigInfo            Pointer to signal info for this signal.
+ *                              NULL is allowed.
+ * @param   pvXcptOrQueued      Exception handler parameter list.
+ *                              Or if __LIBC_BSRF_QUEUED is set, a pointer to locally malloced
+ *                              SIGQUEUED node.
+ * @param   fFlags              Flags of the #defines __LIBC_BSRF_* describing how to
+ *                              deliver the signal.
+ *
+ * @remark  This Backend Signal API does NOT require the caller to own the signal semaphore.
+ */
+int __libc_Back_signalRaise(int iSignalNo, siginfo_t *pSigInfo, void *pvXcptOrQueued, unsigned fFlags);
+
+/**
+ * Worker called after __libc_Back_signalRaise() was called with a
+ * preallocated signal queue entry. This function will make sure
+ * we're not ending up with too many heap allocated packets in the
+ * free list.
+ */
+void __libc_Back_signalFreeWorker(void);
+
+/**
+ * Send a signal to a process.
+ *
+ * @returns 0 on if signal sent.
+ * @returns -errno on failure.
+ *
+ * @param   pid         Process Id of the process which the signal is to be sent to.
+ * @param   iSignalNo   The signal to send.
+ * @remark  This Backend Signal API does NOT require the caller to own the signal semaphore.
+ */
+int __libc_Back_signalSendPid(pid_t pid, int iSignalNo);
+
+/**
+ * Verify the existance of another process and that the current process
+ * is allowed to signal it.
+ *
+ * @return 0 on success.
+ * @return -ESRCH if pid doesn't exist.
+ * @return -EPERM if we aren't allowed to signal the pid.
+ * @param   pid     Process Id for the process which we wanna signal.
+ * @todo    Do EPERM check, no ideas here yet.
+ * @remark  This Backend Signal API does NOT require the caller to own the signal semaphore.
+ */
+int __libc_Back_signalVerifyPid(pid_t pid);
+
+/**
+ * Not implemented.
+ *
+ * @returns -ENOSYS.
+ * @param   pgrp        Process group (positive).
+ *                      0 means the process group of this process.
+ *                      1 means all process in the system.
+ * @param   iSignalNo   Signal to send to all the processes in the group.
+ */
+int __libc_Back_signalSendPGrp(pid_t pgrp, int iSignalNo);
+
+/**
+ * Verify the existance of a process group and that the current process
+ * is allowed to signal it.
+ *
+ * @return 0 on success.
+ * @return -ESRCH if pgid doesn't exist.
+ * @return -EPERM if we aren't allowed to signal the pgid.
+ * @param   pgid    Process group id which the current process intend to signal.
+ * @todo    Do EPERM check, no ideas here yet.
+ * @remark  This Backend Signal API does NOT require the caller to own the signal semaphore.
+ */
+int __libc_Back_signalVerifyPGrp(pid_t pgid);
+
+/**
+ * sigaction worker; queries and/or sets the action for a signal.
+ *
+ * @returns 0 on success.
+ * @returns -Negative errno on failure.
+ * @param   iSignalNo   Signal number.
+ * @param   pSigAct     Pointer to new signal action.
+ *                      If NULL no update is done.
+ * @param   pSigActOld  Where to store the old signal action.
+ *                      If NULL nothing is attempted stored.
+ */
+int __libc_Back_signalAction(int iSignalNo, const struct sigaction *pSigAct, struct sigaction *pSigActOld);
+
+/**
+ * Changes and/or queries the alternative signal stack settings of a thread.
+ *
+ * @returns 0 on success.
+ * @returns Negative error number (errno.h) on failure.
+ * @param   pThrd       Thread which signal stack to change and/or query.
+ * @param   pStack      New stack settings. (Optional)
+ * @param   pOldStack   Old stack settings. (Optional)
+ */
+int __libc_Back_signalStack(__LIBC_PTHREAD pThrd, const stack_t *pStack, stack_t *pOldStack);
+
+/**
+ * Block or unblock signal deliveries of a thread.
+ *
+ * @returns 0 on success.
+ * @returns -1 and errno set to EINVAL on failure.
+ * @param   pThrd       Thread to apply this to.
+ * @param   iHow        Describes the action taken if pSigSetNew not NULL. Recognized
+ *                      values are SIG_BLOCK, SIG_UNBLOCK or SIG_SETMASK.
+ *
+ *                      SIG_BLOCK means to or the sigset pointed to by pSigSetNew with
+ *                          the signal mask for the current thread.
+ *                      SIG_UNBLOCK means to and the 0 complement of the sigset pointed
+ *                          to by pSigSetNew with the signal mask of the current thread.
+ *                      SIG_SETMASK means to set the signal mask of the current thread
+ *                          to the sigset pointed to by pSigSetNew.
+ *
+ * @param   pSigSetNew  Pointer to signal set which will be applied to the current
+ *                      threads signal mask according to iHow. If NULL no change
+ *                      will be made the the current threads signal mask.
+ * @param   pSigSetOld  Where to store the current threads signal mask prior to applying
+ *                      pSigSetNew to it. This parameter can be NULL.
+ */
+int __libc_Back_signalMask(__LIBC_PTHREAD pThrd, int iHow, const sigset_t * __restrict pSigSetNew, sigset_t * __restrict pSigSetOld);
+
+/** @} */
+
 __END_DECLS
 

trunk/src/emx/include/InnoTekLIBC/logstrict.h

@@ -177 +177 @@
 /** Mutex Semaphores. */
 #define __LIBC_LOG_GRP_MUTEX        13
-/** Signal APIs and events. */
+/** Signal APIs and Events. */
 #define __LIBC_LOG_GRP_SIGNAL       14
 /** Environment APIs. */
@@ -184 +184 @@
 #define __LIBC_LOG_GRP_MMAN         16
 
+/** Backend Signal APIs and Events. */
+#define __LIBC_LOG_GRP_BACK_SIGNAL  20
 /** Backend Memory Mananger APIs. */
 #define __LIBC_LOG_GRP_BACK_MMAN    21

trunk/src/emx/include/InnoTekLIBC/sharedpm.h

@@ -279 +279 @@
     /** Creation timestamp. */
     unsigned                    uTimestamp;
-    /** Incoming signal queue.
-     * This is a LIFO for speed and size. The receiving process will
-     * process them in the correct order of course.
+    /** Incoming signal queue (FIFO).
      * For signals which aren't queable only one signal can be queued.
      */
@@ -289 +287 @@
      */
     volatile unsigned           cSigsSent;
+    /** Indicates that the process is a full featured LIBC process.
+     * Untill this flag is set (atomically) it's not a good idea to
+     * queue signals on the process since it won't have a signal handler
+     * installed, and thus won't get to know about them.
+     */
+    volatile unsigned           fExeInited;
 
     /** Reserved pool pointer field with default value 0. */
@@ -649 +653 @@
 
 /**
+ * Marks the process as a full LIBC process.
+ *
+ * Up to this point it was just a process which LIBC happend to be loaded into.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   pSignal     Signal to queue.
+ * @param   pid         Pid to queue it on.
+ * @param   fQueued     Set if the signal type is queued.
+ */
+void    __libc_spmExeInited(void);
+
+/**
  * Queues a signal on another process.
  *

trunk/src/emx/include/sys/_sigset.h

@@ -35 +35 @@
  * @{
  */
+#define __SIGSET_CLONGS     2           /** Space for 64 signals. */
 #if __BSD_VISIBLE
-#define __SIGSET_CLONGS     2           /** Space for 64 signals. */
 #define __SIGSET_MAXSIGNALS 64          /** Maximum signals. */
 /** Check if the signal is valid. */
@@ -70 +70 @@
         (result)->__bitmap[1] = (set1)->__bitmap[1] | (set2)->__bitmap[1]; \
     } while (0)
-#endif
 /** @} */
+#endif /* BSD_VISIBLE */
 
 /**
@@ -83 +83 @@
 
 #endif
+

trunk/src/emx/include/sys/cdefs.h

@@ -14 +14 @@
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
@@ -35 +31 @@
  *
  *      @(#)cdefs.h     8.8 (Berkeley) 1/9/95
- * $FreeBSD: src/sys/sys/cdefs.h,v 1.69 2003/04/18 18:59:34 bde Exp $
+ * $FreeBSD: src/sys/sys/cdefs.h,v 1.81 2004/04/07 04:19:49 imp Exp $
  */
 
 /** @file
- * FreeBSD 5.1
+ * FreeBSD 5.2
  *
  * @changed bird: Toolkit compatibility (_CDEFS_H_ and __TCPROTO()).
@@ -58 +54 @@
 #define __BEGIN_DECLS
 #define __END_DECLS
+#endif
+
+/*
+ * Macro to test if we're using a specific version of gcc or later.
+ */
+#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
+#define __GNUC_PREREQ__(ma, mi) \
+        (__GNUC__ > (ma) || __GNUC__ == (ma) && __GNUC_MINOR__ >= (mi))
+#else
+#define __GNUC_PREREQ__(ma, mi) 0
 #endif
 
@@ -85 +91 @@
 #define __inline        inline          /* convert to C++ keyword */
 #else
-#ifndef __GNUC__
+#if !(defined(__GNUC__) || defined(__INTEL_COMPILER))
 #define __inline                        /* delete GCC keyword */
-#endif /* !__GNUC__ */
+#endif /* !(__GNUC__ || __INTEL_COMPILER) */
 #endif /* !__cplusplus */
 
@@ -95 +101 @@
 #define __STRING(x)     "x"
 
-#ifndef __GNUC__
+#if !(defined(__GNUC__) || defined(__INTEL_COMPILER))
 #define __const                         /* delete pseudo-ANSI C keywords */
 #define __inline
@@ -114 +120 @@
 #define volatile
 #endif  /* !NO_ANSI_KEYWORDS */
-#endif  /* !__GNUC__ */
+#endif  /* !(__GNUC__ || __INTEL_COMPILER) */
 #endif  /* !(__STDC__ || __cplusplus) */
 
@@ -134 +140 @@
 #define __section(x)
 #else
-#if __GNUC__ < 2 || __GNUC__ == 2 && __GNUC_MINOR__ < 5
+#if !__GNUC_PREREQ__(2, 5) && !defined(__INTEL_COMPILER)
 #define __dead2
 #define __pure2
 #define __unused
 #endif
-#if __GNUC__ == 2 && __GNUC_MINOR__ >= 5 && __GNUC_MINOR__ < 7
+#if __GNUC__ == 2 && __GNUC_MINOR__ >= 5 && __GNUC_MINOR__ < 7 && !defined(__INTEL_COMPILER)
 #define __dead2         __attribute__((__noreturn__))
 #define __pure2         __attribute__((__const__))
@@ -145 +151 @@
 /* XXX Find out what to do for __packed, __aligned and __section */
 #endif
-#if __GNUC__ == 2 && __GNUC_MINOR__ >= 7 || __GNUC__ == 3
+#if __GNUC_PREREQ__(2, 7)
 #define __dead2         __attribute__((__noreturn__))
 #define __pure2         __attribute__((__const__))
@@ -153 +159 @@
 #define __section(x)    __attribute__((__section__(x)))
 #endif
+#if defined(__INTEL_COMPILER)
+#define __dead2         __attribute__((__noreturn__))
+#define __pure2         __attribute__((__const__))
+#define __unused        __attribute__((__unused__))
+#define __packed        __attribute__((__packed__))
+#define __aligned(x)    __attribute__((__aligned__(x)))
+#define __section(x)    __attribute__((__section__(x)))
+#endif
+#endif
+
+#if __GNUC_PREREQ__(3, 1) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 800)
+#define __always_inline __attribute__((__always_inline__))
+#else
+#define __always_inline
+#endif
+
+#if __GNUC_PREREQ__(3, 3)
+#define __nonnull(x)    __attribute__((__nonnull__(x)))
+#else
+#define __nonnull(x)
 #endif
 
 /* XXX: should use `#if __STDC_VERSION__ < 199901'. */
-#if !(__GNUC__ == 2 && __GNUC_MINOR__ >= 7 || __GNUC__ >= 3)
+#if !__GNUC_PREREQ__(2, 7) && !defined(__INTEL_COMPILER)
 #define __func__        NULL
 #endif
 
-#if __GNUC__ >= 2 && !defined(__STRICT_ANSI__) || __STDC_VERSION__ >= 199901
+#if (defined(__INTEL_COMPILER) || (defined(__GNUC__) && __GNUC__ >= 2)) && !defined(__STRICT_ANSI__) || __STDC_VERSION__ >= 199901
 #define __LONG_LONG_SUPPORTED
 #endif
@@ -171 +197 @@
  */
 #if !(__GNUC__ == 2 && __GNUC_MINOR__ == 95)
-#if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901 /* bird: check if not defined. (-pedantic) */
+#if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901
 #define __restrict
 #else
 #define __restrict      restrict
 #endif
+#endif
+
+/*
+ * GNU C version 2.96 adds explicit branch prediction so that
+ * the CPU back-end can hint the processor and also so that
+ * code blocks can be reordered such that the predicted path
+ * sees a more linear flow, thus improving cache behavior, etc.
+ *
+ * The following two macros provide us with a way to utilize this
+ * compiler feature.  Use __predict_true() if you expect the expression
+ * to evaluate to true, and __predict_false() if you expect the
+ * expression to evaluate to false.
+ *
+ * A few notes about usage:
+ *
+ *      * Generally, __predict_false() error condition checks (unless
+ *        you have some _strong_ reason to do otherwise, in which case
+ *        document it), and/or __predict_true() `no-error' condition
+ *        checks, assuming you want to optimize for the no-error case.
+ *
+ *      * Other than that, if you don't know the likelihood of a test
+ *        succeeding from empirical or other `hard' evidence, don't
+ *        make predictions.
+ *
+ *      * These are meant to be used in places that are run `a lot'.
+ *        It is wasteful to make predictions in code that is run
+ *        seldomly (e.g. at subsystem initialization time) as the
+ *        basic block reordering that this affects can often generate
+ *        larger code.
+ */
+#if __GNUC_PREREQ__(2, 96)
+#define __predict_true(exp)     __builtin_expect((exp), 1)
+#define __predict_false(exp)    __builtin_expect((exp), 0)
+#else
+#define __predict_true(exp)     (exp)
+#define __predict_false(exp)    (exp)
 #endif
 
@@ -190 +252 @@
  * didn't permit keeping the keywords out of the application namespace).
  */
-#if __GNUC__ < 2 || __GNUC__ == 2 && __GNUC_MINOR__ < 7
+#if !__GNUC_PREREQ__(2, 7) && !defined(__INTEL_COMPILER)
 #define __printflike(fmtarg, firstvararg)
 #define __scanflike(fmtarg, firstvararg)
@@ -201 +263 @@
 
 /* Compiler-dependent macros that rely on FreeBSD-specific extensions. */
-#if defined(__FreeBSD_cc_version) && __FreeBSD_cc_version >= 300001 /* bird: check if defined to avoid -Wundef messages */
+#if defined(__FreeBSD_cc_version) && __FreeBSD_cc_version >= 300001 && defined(__GNUC__) && !defined(__INTEL_COMPILER) /* bird: check if defined to avoid -Wundef messages */
 #define __printf0like(fmtarg, firstvararg) \
             __attribute__((__format__ (__printf0__, fmtarg, firstvararg)))
@@ -208 +270 @@
 #endif
 
-#if 0 /* def __GNUC__ - bird: ELF specific, so skip everything */
+#if 0 /* defined(__GNUC__) || defined(__INTEL_COMPILER) - bird: ELF specific, so skip everything */
+#ifndef __INTEL_COMPILER
 #define __strong_reference(sym,aliassym)        \
         extern __typeof (sym) aliassym __attribute__ ((__alias__ (#sym)));
+#endif
 #ifdef __STDC__
 #define __weak_reference(sym,alias)     \
@@ -228 +292 @@
         __asm__(".previous")
 #endif  /* __STDC__ */
-#endif  /* __GNUC__ */
-
-#if 0 /*def __GNUC__ - ELF specific. */
+#endif  /* __GNUC__ || __INTEL_COMPILER */
+
+#if 0 /* defined(__GNUC__) || defined(__INTEL_COMPILER) - ELF specific. */
 #define __IDSTRING(name,string) __asm__(".ident\t\"" string "\"")
 #else
 /*
- * This doesn't work in header files. But it may be better than nothing.
- * The alternative is: #define __IDSTRING(name,string)  [nothing]
+ * The following definition might not work well if used in header files,
+ * but it should be better than nothing.  If you want a "do nothing"
+ * version, then it should generate some harmless declaration, such as:
+ *    #define __IDSTRING(name,string)   struct __hack
  */
 #define __IDSTRING(name,string) static const char name[] __unused = string
@@ -244 +310 @@
  * more recent ELF binutils, we use .ident allowing the ID to be stripped.
  * Usage:
- *      __FBSDID("$FreeBSD: src/sys/sys/cdefs.h,v 1.69 2003/04/18 18:59:34 bde Exp $");
+ *      __FBSDID("$FreeBSD: src/sys/sys/cdefs.h,v 1.81 2004/04/07 04:19:49 imp Exp $");
  */
 #ifndef __FBSDID
@@ -258 +324 @@
 #define __RCSID(s)      __IDSTRING(__CONCAT(__rcsid_,__LINE__),s)
 #else
-#define __RCSID(s)
+#define __RCSID(s)      struct __hack
 #endif
 #endif
@@ -266 +332 @@
 #define __RCSID_SOURCE(s)       __IDSTRING(__CONCAT(__rcsid_source_,__LINE__),s)
 #else
-#define __RCSID_SOURCE(s)
+#define __RCSID_SOURCE(s)       struct __hack
 #endif
 #endif
@@ -274 +340 @@
 #define __SCCSID(s)     __IDSTRING(__CONCAT(__sccsid_,__LINE__),s)
 #else
-#define __SCCSID(s)
+#define __SCCSID(s)     struct __hack
 #endif
 #endif
@@ -282 +348 @@
 #define __COPYRIGHT(s)  __IDSTRING(__CONCAT(__copyright_,__LINE__),s)
 #else
-#define __COPYRIGHT(s)
+#define __COPYRIGHT(s)  struct __hack
 #endif
 #endif
@@ -321 +387 @@
 
 /* Deal with IEEE Std. 1003.1-1990, in which _POSIX_C_SOURCE == 1. */
-#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE == 1 /* bird: check if defined to avoid -Wundef message. */
+#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE == 1
 #undef _POSIX_C_SOURCE          /* Probably illegal, but beyond caring now. */
 #define _POSIX_C_SOURCE         199009
@@ -327 +393 @@
 
 /* Deal with IEEE Std. 1003.2-1992, in which _POSIX_C_SOURCE == 2. */
-#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE == 2 /* bird: check if defined to avoid -Wundef message. */
+#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE == 2
 #undef _POSIX_C_SOURCE
 #define _POSIX_C_SOURCE         199209

trunk/src/emx/include/sys/signal.h

@@ -52 +52 @@
 #endif
 #define SIGILL    4     /** ANSI: Illegal instruction */
-#if __XSI_VISIBLE
+#if __XSI_VISIBLE  || __POSIX_VISIBLE >= 200112
 #define SIGTRAP   5     /** POSIX: Single step (debugging) */
 #endif
@@ -68 +68 @@
 #endif
 #define SIGSEGV  11     /** ANSI: Segmentation fault */
-#if __BSD_VISIBLE
+#if __BSD_VISIBLE || __POSIX_VISIBLE >= 200112
 #define SIGSYS   12     /** Invalid argument to system call */
 #endif
@@ -92 +92 @@
 #endif
 #if __XSI_VISIBLE
+#define SIGPOLL  23     /** ??: Input/output possible signal. (Same as SIGIO.) */
+#endif
+#if __XSI_VISIBLE || __POSIX_VISIBLE >= 200112
 #define SIGXCPU  24     /** BSD 4.2: Exceeded CPU time limit. */
 #define SIGXFSZ  25     /** BSD 4.2: Exceeded file size limit. */
+#endif
+#if __XSI_VISIBLE
 #define SIGVTALRM 26    /** BSD 4.2: Virtual time alarm. */
+#endif
+#if __XSI_VISIBLE || __POSIX_VISIBLE >= 200112
 #define SIGPROF  27     /** BSD 4.2: Profiling time alarm. */
 #endif
@@ -188 +195 @@
  * @{
  */
-/** Deliver signal on alternate stack. */
+/** Current on alternative stack. */
 #define SS_ONSTACK          0x00000001
 /** Do not take signal on alternate stack. */
@@ -422 +429 @@
 /** If set the signal was queue. */
 #define __LIBC_SI_QUEUED        0x00000001
+/** Internal signal generated by LIBC. */
+#define __LIBC_SI_INTERNAL      0x00000002
 /** @} */
 #endif
@@ -452 +461 @@
 };
 #define sa_handler      __sigaction_u.__sa_handler
+#define sa_sigaction    __sigaction_u.__sa_sigaction
 #endif
 

trunk/src/emx/src/lib/libc.def

@@ -1235 +1235 @@
     "___libc_Back_signalSendPGrp" @1257
     "___libc_Back_signalSendPid" @1258
+    "___libc_Back_signalAction" @1259
+    "___libc_Back_signalFreeWorker" @1260
+    "___libc_Back_signalStack" @1261
+    "___libc_Back_signalMask" @1262

trunk/src/emx/src/lib/process/kill.c

@@ -31 +31 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
+#include <InnoTekLIBC/backend.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>

trunk/src/emx/src/lib/process/raise.c

@@ -42 +42 @@
  * According to the standards this should only raise the signal in the
  * current thread, however, FreeBSD libc and GLIBC both forwards this
- * call to kill(). We do the same to be compatible.
+ * call to kill(). We do the same to be compatible. :-)
  *
  * @returns 0 on success.

trunk/src/emx/src/lib/process/sigaction.c

@@ -32 +32 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
+#include <string.h>
+#include <InnoTekLIBC/backend.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>
@@ -60 +61 @@
     struct sigaction    SigAct;
     struct sigaction    SigActOld = {{0}};
-    int                 rc;
 
     /*
@@ -82 +82 @@
         }
         if (    SigAct.__sigaction_u.__sa_handler == SIG_ERR
-            ||  SigAct.__sigaction_u.__sa_handler == SIG_ACK)
+            ||  SigAct.__sigaction_u.__sa_handler == SIG_ACK
+            ||  SigAct.__sigaction_u.__sa_handler == SIG_HOLD)
         {
             LIBC_ASSERTM_FAILED("Invalid sa_handler=%p\n", (void*)SigAct.__sigaction_u.__sa_handler);
@@ -89 +90 @@
         }
 
-        rc = 0;
+        /*
+         * Check if the address is around.
+         */
         if (    SigAct.__sigaction_u.__sa_handler != SIG_IGN
-            &&  SigAct.__sigaction_u.__sa_handler != SIG_DFL
-            &&  SigAct.__sigaction_u.__sa_handler != SIG_HOLD)
+            &&  SigAct.__sigaction_u.__sa_handler != SIG_DFL)
         {
-            rc += *(char *)SigAct.__sigaction_u.__sa_handler; /* check if executable address */
+            char ach[1];
+            memcpy(&ach, (void *)SigAct.__sigaction_u.__sa_handler, sizeof(ach));  /* check if address is around. */
         }
     }
-
-
-    /*
-     * Gain exclusive access to the signal stuff.
-     */
-    if (__libc_back_signalSemRequest())
-        LIBCLOG_RETURN_INT(-1);
 
     /*
      * Call backend worker.
      */
-    rc = __libc_back_signalAction(iSignalNo, pSigAct ? &SigAct : NULL, &SigActOld);
+    int rc = __libc_Back_signalAction(iSignalNo, pSigAct ? &SigAct : NULL, &SigActOld);
+    if (!rc)
+    {
+        if (pSigActOld)
+            *pSigActOld = SigActOld;
 
-    /*
-     * Release semaphore.
-     */
-    __libc_back_signalSemRelease();
-
-    /*
-     * Check for errors, store result and return.
-     */
-    if (rc)
-        LIBCLOG_RETURN_INT(-1);
-
-    if (pSigActOld)
-        *pSigActOld = SigActOld;
-
-    LIBCLOG_RETURN_MSG(0, "ret 0 (*pSigActOld=%p {sa_handler=%p, sa_mask={%#08lx%#08lx}, sa_flags=%#x}\n",
-                       (void *)pSigActOld,
-                       (void *)SigActOld.__sigaction_u.__sa_sigaction,
-                       SigActOld.sa_mask.__bitmap[0],
-                       SigActOld.sa_mask.__bitmap[1],
-                       SigActOld.sa_flags);
+        LIBCLOG_RETURN_MSG(0, "ret 0 (*pSigActOld=%p {sa_handler=%p, sa_mask={%#08lx%#08lx}, sa_flags=%#x}\n",
+                           (void *)pSigActOld,
+                           (void *)SigActOld.__sigaction_u.__sa_sigaction,
+                           SigActOld.sa_mask.__bitmap[0],
+                           SigActOld.sa_mask.__bitmap[1],
+                           SigActOld.sa_flags);
+    }
+    errno = -rc;
+    LIBCLOG_RETURN_INT(-1);
 }
 

trunk/src/emx/src/lib/process/sigaltstack.c

@@ -31 +31 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
 #include <InnoTekLIBC/thread.h>
+#include <InnoTekLIBC/backend.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>
@@ -38 +38 @@
 
 
+/**
+ * Changes and/or queries the alternative signal stack
+ * settings of the current thread.
+ *
+ * @returns 0 on success.
+ * @returns Negative error number (errno.h) on failure.
+ * @param   pThrd       Thread which signal stack to change and/or query.
+ * @param   pStack      New stack settings. (Optional)
+ * @param   pOldStack   Old stack settings. (Optional)
+ */
 int _STD(sigaltstack)(const stack_t *pStack, stack_t *pOldStack)
 {
@@ -46 +56 @@
                   pStack ? pStack->ss_size  : 0,
                   (void *)pOldStack);
-    __LIBC_THREAD  *pThrd = __libc_threadCurrent();
-    stack_t         OldStack = {0};
-    stack_t         Stack;
-    int             rc = 0;
 
     /*
-     * Validate input.
+     * Perform operation and return.
      */
-    if (pStack)
+    stack_t OldStack;
+    int rc = __libc_Back_signalStack(__libc_threadCurrent(), pStack, &OldStack);
+    if (!rc)
     {
-        if (pStack->ss_flags & ~SS_DISABLE)
-        {
-            LIBC_ASSERTM_FAILED("ss_flags=%#x is invalid\n", pStack->ss_flags);
-            errno = EINVAL;
-            LIBCLOG_RETURN_INT(-1);
-        }
-        if (pStack->ss_flags != SS_DISABLE)
-        {
-            if (!pStack->ss_sp)
-            {
-                LIBC_ASSERTM_FAILED("ss_sp=%p is NULL when SS_DISABLE is not set\n", pStack->ss_sp);
-                errno = EINVAL;
-                LIBCLOG_RETURN_INT(-1);
-            }
-            if (!pStack->ss_size < MINSIGSTKSZ)
-            {
-                LIBC_ASSERTM_FAILED("ss_size=%d is too small. minimum size is %d\n", pStack->ss_size, MINSIGSTKSZ);
-                errno = ENOMEM;
-                LIBCLOG_RETURN_INT(-1);
-            }
-        }
+        if (pOldStack)
+            *pOldStack = OldStack;
+        LIBCLOG_RETURN_MSG(0, "ret 0 (*pOldStack {ss_flags=%#x, ss_sp=%p, ss_size=%d}\n",
+                           OldStack.ss_flags, OldStack.ss_sp, OldStack.ss_size);
     }
 
-    /*
-     * Copy input.
-     */
-    if (pStack)
-        Stack = *pStack;
+    errno = -rc;
+    LIBCLOG_RETURN_INT(-1);
+}
 
-    /*
-     * Gain exclusive access to the signal stuff.
-     */
-    if (__libc_back_signalSemRequest())
-        LIBCLOG_RETURN_INT(-1);
-
-    /*
-     * Get the old stack.
-     */
-    OldStack.ss_flags = pThrd->pvSigStack ? 0 : SS_DISABLE;
-    if (pThrd->fSigStackActive)
-        OldStack.ss_flags |= SS_ONSTACK;
-    OldStack.ss_sp    = pThrd->pvSigStack;
-    OldStack.ss_size  = pThrd->cbSigStack;
-
-    /*
-     * Change the stack.
-     */
-    if (pStack)
-    {
-        if (!pThrd->fSigStackActive)
-        {
-            if (Stack.ss_flags == SS_ONSTACK)
-            {
-                pThrd->pvSigStack = Stack.ss_sp;
-                pThrd->cbSigStack = Stack.ss_size;
-            }
-            else
-            {
-                pThrd->pvSigStack = NULL;
-                pThrd->cbSigStack = 0;
-            }
-        }
-        else
-            rc = EPERM;
-    }
-
-    /*
-     * Release semaphore.
-     */
-    __libc_back_signalSemRelease();
-
-
-    /*
-     * Check for failure and return.
-     */
-    if (rc)
-    {
-        LIBC_ASSERTM_FAILED("Stack is in use\n");
-        errno = rc;
-        LIBCLOG_RETURN_INT(-1);
-    }
-
-    if (pOldStack)
-        *pOldStack = OldStack;
-
-    LIBCLOG_RETURN_MSG(0, "ret 0 (*pOldStack {ss_flags=%#x, ss_sp=%p, ss_size=%d}\n",
-                       OldStack.ss_flags, OldStack.ss_sp, OldStack.ss_size);
-}

trunk/src/emx/src/lib/process/sigprocmask.c

@@ -33 +33 @@
 #include <sys/_sigset.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
 #include <InnoTekLIBC/thread.h>
+#include <InnoTekLIBC/backend.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>
@@ -70 +70 @@
                   pSigSetNew ? pSigSetNew->__bitmap[1] : 0, pSigSetNew ? pSigSetNew->__bitmap[0] : 0,
                   (void *)pSigSetOld);
-    __LIBC_THREAD  *pThrd = __libc_threadCurrent();
-    sigset_t        SigSetNew;
-    sigset_t        SigSetOld;
-    sigset_t        SigSet;
 
     /*
-     * Validate input.
-     * ASSUMES SIG_BLOCK 1 and SIG_SETMASK 3.
+     * Perform operation.
      */
-    if (iHow < SIG_BLOCK || iHow > SIG_SETMASK)
+    sigset_t        SigSetOld;
+    int rc = __libc_Back_signalMask(__libc_threadCurrent(), iHow, pSigSetNew, &SigSetOld);
+    if (!rc)
     {
-        LIBC_ASSERTM_FAILED("iHow=%d is wrong\n", iHow);
-        errno = EINVAL;
-        LIBCLOG_RETURN_INT(-1);
+        if (pSigSetOld)
+            *pSigSetOld = SigSetOld;
+
+        LIBCLOG_RETURN_MSG(0, "ret 0 old={%08lx%08lx} new={%08lx%08lx}\n",
+                           SigSetOld.__bitmap[1], SigSetOld.__bitmap[0],
+                           SigSetNew.__bitmap[1], SigSetNew.__bitmap[0]);
     }
+    errno = -rc;
+    LIBCLOG_RETURN_INT(-1);
+}
 
-
-    /*
-     * Prepare action.
-     * We make copies on the stack so we will not crash accessing
-     * bogus stuff inside the signal mutex.
-     */
-    __SIGSET_EMPTY(&SigSetOld);         /* touch it. (paranoia) */
-    if (pSigSetNew)
-        SigSetNew = *pSigSetNew;
-    else
-        __SIGSET_EMPTY(&SigSetNew);
-
-    /*
-     * Gain exclusive access to the signal stuff.
-     */
-    if (__libc_back_signalSemRequest())
-        LIBCLOG_RETURN_INT(-1);
-
-    /*
-     * Save old set of blocked signals and apply any changes.
-     */
-    SigSetOld = pThrd->SigSetBlocked;
-    if (pSigSetNew)
-    {
-        switch (iHow)
-        {
-            case SIG_BLOCK:
-                __SIGSET_OR(&pThrd->SigSetBlocked, &pThrd->SigSetBlocked, &SigSetNew);
-                break;
-
-            case SIG_UNBLOCK:
-                __SIGSET_NOT(&SigSetNew);
-                __SIGSET_AND(&pThrd->SigSetBlocked, &pThrd->SigSetBlocked, &SigSetNew);
-                break;
-
-            case SIG_SETMASK:
-                pThrd->SigSetBlocked = SigSetNew;
-                break;
-        }
-
-        /*
-         * Check if we've unblocked anything and thus made it possible for
-         * pending signals to be delivered.
-         */
-        SigSetNew = pThrd->SigSetBlocked;
-        __SIGSET_AND(&SigSet, &SigSetOld, &SigSetNew);
-        if (!__SIGSET_ISEMPTY(&SigSetNew))
-        {
-            sigset_t    SigSetPending;
-            __SIGSET_OR(&SigSetPending, &pThrd->SigSetPending, &__libc_gSignalPending);
-            __SIGSET_AND(&SigSetPending, &SigSetPending, &SigSetNew);
-            if (!__SIGSET_ISEMPTY(&SigSetPending))
-                __libc_back_signalPokeThread(0);
-        }
-    }
-
-    /*
-     * Release semaphore.
-     */
-    __libc_back_signalSemRelease();
-
-    /*
-     * Copy old signal set if requested.
-     */
-    if (pSigSetOld)
-        *pSigSetOld = SigSetOld;
-
-    LIBCLOG_MSG("old={%08lx%08lx} new={%08lx%08lx}\n",
-                SigSetOld.__bitmap[1], SigSetOld.__bitmap[0],
-                SigSetNew.__bitmap[1], SigSetNew.__bitmap[0]);
-    LIBCLOG_RETURN_INT(0);
-}

trunk/src/emx/src/lib/sys/386/signal16bit.asm

@@ -76 +76 @@
 
     ; call 32-bit worker
-    movzx   eax, word ptr [esp + (4 * 5) + (2 * 4) + 4] ; sig_arg
-    movzx   edx, word ptr [esp + (4 * 5) + (2 * 4) + 6] ; sig_num
+    movzx   eax, word ptr [esp + (4 * 5) + (2 * 4) + 6] ; sig_arg
+    movzx   edx, word ptr [esp + (4 * 5) + (2 * 4) + 4] ; sig_num
     push    eax
     push    edx

trunk/src/emx/src/lib/sys/__init.c

@@ -171 +171 @@
         char **                       envp;
         /** Exception handler registration record (*_sys_xreg). */
-        EXCEPTIONREGISTRATIONRECORD   ExcpRegReg;
+        EXCEPTIONREGISTRATIONRECORD   ExcpRegRec;
         /** Argument vector. */
         char *                        apszArg[1];
@@ -180 +180 @@
     PPIB      ppib;
     int       cb;
-    ULONG     times;
 
     /*
@@ -225 +224 @@
 
     /*
-     * Install exception handler.
-     */
-    pStackFrame->ExcpRegReg.prev_structure   = END_OF_CHAIN;
-    pStackFrame->ExcpRegReg.ExceptionHandler = __libc_Back_exceptionHandler;
-    rc = DosSetExceptionHandler(&pStackFrame->ExcpRegReg);
-    if (rc != 0)
-        goto failure;
-
-    /* DosSetSignalExceptionFocus fails for PM programs, error code 303 */
-    DosSetSignalExceptionFocus(SIG_SETFOCUS, &times);
-
-    /*
-     * Install 16-bit signal handler.
-     */
-    rc = DosSetSigHandler((PFNSIGHANDLER)__libc_back_signalOS2V1Handler16bit, NULL, NULL, SIGA_ACCEPT, SIG_PFLG_C);
+     * Install exception handler, 16-bit signal handler and set signal focus.
+     */
+    rc = __libc_back_signalInitExe(&pStackFrame->ExcpRegRec);
     if (rc)
-    {
-        LIBC_ASSERTM_FAILED("DosSetSigHandler failed with rc=%d\n", rc);
-        goto failure;
-    }
-
+        goto failure;
+
+    /*
+     * Mark the process as a completely inited LIBC process.
+     */
+    __libc_spmExeInited();
 
     /* Return to the program. */

trunk/src/emx/src/lib/sys/__select.c

@@ -38 +38 @@
 #include "syscalls.h"
 
+
+static int __select_wait(struct timeval *tv)
+{
+    /*
+     * Wait.
+     */
+    FS_VAR();
+    FS_SAVE_LOAD();
+    int rc;
+    if (!tv)
+        rc = DosSleep(~0);
+    else
+    {
+        ULONG cMillies = tv->tv_sec * 1000 + tv->tv_usec / 1000;
+        if (!cMillies && tv->tv_usec)
+            cMillies = 1;
+        rc = DosSleep(cMillies);
+    }
+    FS_RESTORE();
+
+    /*
+     * Return.
+     */
+    if (!rc)
+        return 0;
+    errno = __libc_native2errno(rc);
+    return -1;
+}
+
 int __select(int nfds, struct fd_set *readfds, struct fd_set *writefds,
              struct fd_set *exceptfds, struct timeval *tv)
@@ -48 +77 @@
     int rc2 = -1;
     int i;
+
+    /*
+     * Wait operation?
+     */
+    if (!readfds && !writefds && !exceptfds)
+        return __select_wait(tv);
+
 
     /*

trunk/src/emx/src/lib/sys/b_signalSendPGrp.c

@@ -37 +37 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
+#include <InnoTekLIBC/backend.h>
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_BACK_SIGNAL
+#include <InnoTekLIBC/logstrict.h>
 #include "syscalls.h"
-#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
-#include <InnoTekLIBC/logstrict.h>
 
 

trunk/src/emx/src/lib/sys/b_signalSendPid.c

@@ -37 +37 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
+#include <InnoTekLIBC/backend.h>
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_BACK_SIGNAL
+#include <InnoTekLIBC/logstrict.h>
 #include "syscalls.h"
-#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
-#include <InnoTekLIBC/logstrict.h>
 
 
@@ -76 +76 @@
      */
     if (_sys_pid != pid)
-        rc = __libc_back_signalSendPidOther(pid, iSignalNo);
+        rc = __libc_back_signalSendPidOther(pid, iSignalNo, NULL);
     else
     {

trunk/src/emx/src/lib/sys/b_signalVerifyPGrp.c

@@ -29 +29 @@
 *   Header Files                                                               *
 *******************************************************************************/
+#include "libc-alias.h"
 #define INCL_BASE
 #define INCL_FSMACROS
@@ -35 +36 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
-#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
+#include <InnoTekLIBC/backend.h>
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_BACK_SIGNAL
 #include <InnoTekLIBC/logstrict.h>
 

trunk/src/emx/src/lib/sys/b_signalVerifyPid.c

@@ -29 +29 @@
 *   Header Files                                                               *
 *******************************************************************************/
+#include "libc-alias.h"
 #define INCL_BASE
 #define INCL_FSMACROS
@@ -35 +36 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
-#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
+#include <InnoTekLIBC/backend.h>
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_BACK_SIGNAL
 #include <InnoTekLIBC/logstrict.h>
 

trunk/src/emx/src/lib/sys/libcfork.c

@@ -1068 +1068 @@
      */
     _fmutex_release(&__libc_gmtxExec);
+    __libc_spmExeInited();
     LIBCLOG_RETURN_INT(0);
 }

trunk/src/emx/src/lib/sys/logstrict.c

@@ -448 +448 @@
             { 1, "future" },            /* 18 */
             { 1, "future" },            /* 19 */
-            { 1, "future" },            /* 20 */
+            { 1, "BACK_SIGNAL" },       /* 20 */
             { 1, "BACK_MMAN" },         /* 21 */
             { 1, "BACK_LDR" },          /* 22 */

trunk/src/emx/src/lib/sys/sharedpm.c

@@ -879 +879 @@
 
 /**
- * Queues a signal on another process.
+ * Marks the process as a full LIBC process.
+ *
+ * Up to this point it was just a process which LIBC happend to be loaded into.
  *
  * @returns 0 on success.
@@ -887 +889 @@
  * @param   fQueued     Set if the signal type is queued.
  */
+void    __libc_spmExeInited(void)
+{
+    __atomic_xchg(&gpSPMSelf->fExeInited, 1);
+    return 0;
+}
+
+
+/**
+ * Queues a signal on another process.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   pSignal     Signal to queue.
+ * @param   pid         Pid to queue it on.
+ * @param   fQueued     Set if the signal type is queued.
+ */
 int     __libc_spmSigQueue(siginfo_t *pSignal, pid_t pid, int fQueued)
 {
@@ -915 +933 @@
 
     /*
-     * Find pid.
+     * Find pid and check that it's capable of catching signals.
      */
     __LIBC_PSPMPROCESS pProcess = spmQueryProcessInState(pid, __LIBC_PROCSTATE_ALIVE);
-    if (pProcess)
+    if (pProcess && pProcess->fExeInited)
     {
         /*
@@ -948 +966 @@
                     __LIBC_PSPMSIGNAL pPrev = NULL;
                     for (pSig = gpSPMHdr->pSigFreeHead; pSig; pPrev = pSig, pSig = pSig->pNext)
+                    {
                         if (pSig->cb == sizeof(*pSig))
                         {
@@ -957 +976 @@
                             break;
                         }
+                    }
                 }
                 if (!pSig)
@@ -964 +984 @@
                         pSig->cb = sizeof(*pSig);
                 }
+
                 /*
                  * Copy the data and insert it into the queue.
@@ -972 +993 @@
                     pSig->pidSender = gpSPMSelf->pid;
                     pSig->Info      = *pSignal;
-
-                    /* insert */
+                    if (fQueued)
+                        pSig->Info.si_flags |= __LIBC_SI_QUEUED;
+                    else
+                        pSig->Info.si_flags &= ~__LIBC_SI_QUEUED;
+
+                    /* insert (FIFO) */
                     if (!pProcess->pSigHead)
                         pProcess->pSigHead = pSig;
@@ -1043 +1068 @@
 
     /*
-     * De-queue signals one-by-one.
+     * Walk thru the queued signals creating the pending signal set
+     * and signal count.
      */
     __LIBC_PSPMSIGNAL pSig = gpSPMSelf->pSigHead;
@@ -1075 +1101 @@
      * Validate input.
      */
-    if (sizeof(siginfo_t) > cbSignal)
+    if (cbSignal < sizeof(siginfo_t))
     {
         LIBC_ASSERTM_FAILED("Invalid siginfo_t size: cbSignal=%d sizeof(siginfo_t)=%d\n", cbSignal, sizeof(siginfo_t));
@@ -1098 +1124 @@
     {
         /*
-         * Find it.
+         * Walk to the next signal of the right sort (if any).
          */
         while (pSig && pSig->Info.si_signo != iSignalNo)
@@ -1129 +1155 @@
 
         /* unlink */
+        __LIBC_PSPMSIGNAL pSigNext = pSig->pNext;
         if (pSigPrev)
-            pSigPrev->pNext = pSig->pNext;
+            pSigPrev->pNext = pSigNext;
         else
-            gpSPMSelf->pSigHead = pSig->pNext;
+            gpSPMSelf->pSigHead = pSigNext;
 
         /* free */
-        __LIBC_PSPMSIGNAL pSigNext = pSig->pNext;
         if (gpSPMHdr->cSigFree < 32)
         {

trunk/src/emx/src/lib/sys/signals.c

@@ -77 +77 @@
 #include <string.h>
 #include <malloc.h>
+#include <386/builtin.h>
+#include <InnoTekLIBC/thread.h>
+#include <InnoTekLIBC/fork.h>
+#include <InnoTekLIBC/backend.h>
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_BACK_SIGNAL
+#include <InnoTekLIBC/logstrict.h>
 #include "syscalls.h"
-#include <386/builtin.h>
-#include <InnoTekLIBC/signals.h>
-#include <InnoTekLIBC/thread.h>
-#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
-#include <InnoTekLIBC/logstrict.h>
+#include "signals.h"
 
 
@@ -128 +130 @@
 /** Property: Anything can service this signal. */
 #define SPP_ANYTHRD     0x0400
+/** Property: Only thread 1 can service this signal. */
+#define SPP_THRDONE     0x0800
 /** Property: This signal can be queued. */
-#define SPP_QUEUED      0x0800
+#define SPP_QUEUED      0x1000
 /** Property: Signal action cannot be automatically reset in SysV fashion. */
-#define SPP_NORESET     0x1000
+#define SPP_NORESET     0x2000
 /** @} */
 
@@ -222 +226 @@
 static HEV              ghevWait;
 
+static const char gaszSignalNames[__SIGSET_MAXSIGNALS][12] =
+{
+    "SIG0",                             /* SIG0 */
+    "SIGHUP",                           /* SIGHUP    1     /-- POSIX: Hangup */
+    "SIGINT",                           /* SIGINT    2     /-- ANSI: Interrupt (Ctrl-C) */
+    "SIGQUIT",                          /* SIGQUIT   3     /-- POSIX: Quit */
+    "SIGILL",                           /* SIGILL    4     /-- ANSI: Illegal instruction */
+    "SIGTRAP",                          /* SIGTRAP   5     /-- POSIX: Single step (debugging) */
+    "SIGABRT",                          /* SIGABRT   6     /-- ANSI: abort () */
+    "SIGEMT",                           /* SIGEMT    7     /-- BSD: EMT instruction */
+    "SIGFPE",                           /* SIGFPE    8     /-- ANSI: Floating point */
+    "SIGKILL",                          /* SIGKILL   9     /-- POSIX: Kill process */
+    "SIGBUS",                           /* SIGBUS   10     /-- BSD 4.2: Bus error */
+    "SIGSEGV",                          /* SIGSEGV  11     /-- ANSI: Segmentation fault */
+    "SIGSYS",                           /* SIGSYS   12     /-- Invalid argument to system call */
+    "SIGPIPE",                          /* SIGPIPE  13     /-- POSIX: Broken pipe. */
+    "SIGALRM",                          /* SIGALRM  14     /-- POSIX: Alarm. */
+    "SIGTERM",                          /* SIGTERM  15     /-- ANSI: Termination, process killed */
+    "SIGURG",                           /* SIGURG   16     /-- POSIX/BSD: urgent condition on IO channel */
+    "SIGSTOP",                          /* SIGSTOP  17     /-- POSIX: Sendable stop signal not from tty. unblockable. */
+    "SIGTSTP",                          /* SIGTSTP  18     /-- POSIX: Stop signal from tty. */
+    "SIGCONT",                          /* SIGCONT  19     /-- POSIX: Continue a stopped process. */
+    "SIGCHLD",                          /* SIGCHLD  20     /-- POSIX: Death or stop of a child process. (EMX: 18) */
+    "SIGTTIN",                          /* SIGTTIN  21     /-- POSIX: To readers pgrp upon background tty read. */
+    "SIGTTOU",                          /* SIGTTOU  22     /-- POSIX: To readers pgrp upon background tty write. */
+    "SIGIO",                            /* SIGIO    23     /-- BSD: Input/output possible signal. */
+    "SIGXCPU",                          /* SIGXCPU  24     /-- BSD 4.2: Exceeded CPU time limit. */
+    "SIGXFSZ",                          /* SIGXFSZ  25     /-- BSD 4.2: Exceeded file size limit. */
+    "SIGVTALRM",                        /* SIGVTALRM 26    /-- BSD 4.2: Virtual time alarm. */
+    "SIGPROF",                          /* SIGPROF  27     /-- BSD 4.2: Profiling time alarm. */
+    "SIGWINCH",                         /* SIGWINCH 28     /-- BSD 4.3: Window size change (not implemented). */
+    "SIGBREAK",                         /* SIGBREAK 29     /-- OS/2: Break (Ctrl-Break). (EMX: 21) */
+    "SIGUSR1",                          /* SIGUSR1  30     /-- POSIX: User-defined signal #1 */
+    "SIGUSR2",                          /* SIGUSR2  31     /-- POSIX: User-defined signal #2 */
+    "SIGBREAK",                         /* SIGBREAK 32     /-- OS/2: Break (Ctrl-Break). (EMX: 21) */
+
+    "SIGRT0",                           /* SIGRTMIN +  0 */
+    "SIGRT1",                           /* SIGRTMIN +  1 */
+    "SIGRT2",                           /* SIGRTMIN +  2 */
+    "SIGRT3",                           /* SIGRTMIN +  3 */
+    "SIGRT4",                           /* SIGRTMIN +  4 */
+    "SIGRT5",                           /* SIGRTMIN +  5 */
+    "SIGRT6",                           /* SIGRTMIN +  6 */
+    "SIGRT7",                           /* SIGRTMIN +  7 */
+    "SIGRT8",                           /* SIGRTMIN +  8 */
+    "SIGRT9",                           /* SIGRTMIN +  9 */
+    "SIGRT10",                          /* SIGRTMIN + 10 */
+    "SIGRT11",                          /* SIGRTMIN + 11 */
+    "SIGRT12",                          /* SIGRTMIN + 12 */
+    "SIGRT13",                          /* SIGRTMIN + 13 */
+    "SIGRT14",                          /* SIGRTMIN + 14 */
+    "SIGRT15",                          /* SIGRTMIN + 15 */
+    "SIGRT16",                          /* SIGRTMIN + 16 */
+    "SIGRT17",                          /* SIGRTMIN + 17 */
+    "SIGRT18",                          /* SIGRTMIN + 18 */
+    "SIGRT19",                          /* SIGRTMIN + 19 */
+    "SIGRT20",                          /* SIGRTMIN + 20 */
+    "SIGRT21",                          /* SIGRTMIN + 21 */
+    "SIGRT22",                          /* SIGRTMIN + 22 */
+    "SIGRT23",                          /* SIGRTMIN + 23 */
+    "SIGRT24",                          /* SIGRTMIN + 24 */
+    "SIGRT25",                          /* SIGRTMIN + 25 */
+    "SIGRT26",                          /* SIGRTMIN + 26 */
+    "SIGRT27",                          /* SIGRTMIN + 27 */
+    "SIGRT28",                          /* SIGRTMIN + 28 */
+    "SIGRT29",                          /* SIGRTMIN + 29 */
+    "SIGRT30",                          /* SIGRTMIN + 30 == SIGRTMAX */
+};
+
 /** Signal Properties.
  * Describes the default actions of a signal.
@@ -234 +307 @@
     SPR_CONTINUE | SPA_NEXT_CORE | SPP_NORESET,                         /* SIGILL    4     /-- ANSI: Illegal instruction */
     SPR_CONTINUE | SPA_NEXT_KILL | SPP_NORESET,                         /* SIGTRAP   5     /-- POSIX: Single step (debugging) */
-    SPR_KILL     | SPA_CORE,                                            /* SIGABRT   6     /-- ANSI: abort () */
+    SPR_CONTINUE | SPA_CORE,                                            /* SIGABRT   6     /-- ANSI: abort () */
     SPR_CONTINUE | SPA_CORE    | SPP_ANYTHRD,                           /* SIGEMT    7     /-- BSD: EMT instruction */
     SPR_CONTINUE | SPA_NEXT_CORE,                                       /* SIGFPE    8     /-- ANSI: Floating point */
@@ -245 +318 @@
     SPR_CONTINUE | SPA_NEXT_KILL | SPP_ANYTHRD,                         /* SIGTERM  15     /-- ANSI: Termination, process killed */
     SPR_CONTINUE | SPA_IGNORE,                                          /* SIGURG   16     /-- POSIX/BSD: urgent condition on IO channel */
-    SPR_CONTINUE | SPA_STOP | SPP_ANYTHRD | SPP_NOBLOCK | SPP_NOCATCH,  /* SIGSTOP  17     /-- POSIX: Sendable stop signal not from tty. unblockable. */
-    SPR_CONTINUE | SPA_STOPTTY | SPP_ANYTHRD,                           /* SIGTSTP  18     /-- POSIX: Stop signal from tty. */
-    SPR_CONTINUE | SPA_RESUME  | SPP_ANYTHRD,                           /* SIGCONT  19     /-- POSIX: Continue a stopped process. */
+    SPR_CONTINUE | SPA_STOP | SPP_THRDONE | SPP_NOBLOCK | SPP_NOCATCH,  /* SIGSTOP  17     /-- POSIX: Sendable stop signal not from tty. unblockable. */
+    SPR_CONTINUE | SPA_STOPTTY | SPP_THRDONE,                           /* SIGTSTP  18     /-- POSIX: Stop signal from tty. */
+    SPR_CONTINUE | SPA_RESUME  | SPP_THRDONE,                           /* SIGCONT  19     /-- POSIX: Continue a stopped process. */
     SPR_CONTINUE | SPA_IGNORE  | SPP_ANYTHRD | SPP_QUEUED,              /* SIGCHLD  20     /-- POSIX: Death or stop of a child process. (EMX: 18) */
-    SPR_CONTINUE | SPA_STOPTTY | SPP_ANYTHRD,                           /* SIGTTIN  21     /-- POSIX: To readers pgrp upon background tty read. */
-    SPR_CONTINUE | SPA_STOPTTY | SPP_ANYTHRD,                           /* SIGTTOU  22     /-- POSIX: To readers pgrp upon background tty write. */
+    SPR_CONTINUE | SPA_STOPTTY | SPP_THRDONE,                           /* SIGTTIN  21     /-- POSIX: To readers pgrp upon background tty read. */
+    SPR_CONTINUE | SPA_STOPTTY | SPP_THRDONE,                           /* SIGTTOU  22     /-- POSIX: To readers pgrp upon background tty write. */
     SPR_CONTINUE | SPA_IGNORE  | SPP_ANYTHRD,                           /* SIGIO    23     /-- BSD: Input/output possible signal. */
     SPR_CONTINUE | SPA_KILL,                                            /* SIGXCPU  24     /-- BSD 4.2: Exceeded CPU time limit. */
@@ -294 +367 @@
     SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 30 == SIGRTMAX */
 };
+
 
 /** The signal actions for all signals in the system.
@@ -459 +533 @@
 static unsigned     gcSigQueuedFree = sizeof(gpaSigQueuedPreAlloced) / sizeof(gpaSigQueuedPreAlloced[0]);
 
+/** Flag indicating that this LIBC instance have installed the signal handler.
+ * This is used during fork so that the child will behave like the parent. */
+static int gfOS2V1Handler = 0;
+
 
 /*******************************************************************************
@@ -473 +551 @@
 static int              signalDeliver(__LIBC_PTHREAD pThrd, int iSignalNo, void *pvXcptParams);
 static void             signalTerminate(int iSignalNo) __dead2;
+static void             signalTerminateAbnormal(int iSignalNo) __dead2;
+static int              signalTerminateHex(char *pszBuf, unsigned u);
 static int              signalJobStop(int iSignalNo);
 static int              signalJobResume(void);
-static void             signalPokeThread(__LIBC_PTHREAD pThrdPoke);
 static int              signalActionWorker(__LIBC_PTHREAD pCur, void *pvParam);
 static unsigned         signalTimestamp(void);
+static int              signalForkChild(__LIBC_PFORKHANDLE pForkHandle, __LIBC_FORKOP enmOperation);
 
 
@@ -521 +601 @@
     FS_RESTORE();
     LIBCLOG_RETURN_INT(-1);
+}
+
+
+/**
+ * Main/exe init - install exception and signals handlers, and set signal focus.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   pvRegRec    Pointer to the exception registartion record to use.
+ */
+int __libc_back_signalInitExe(void *pvRegRec)
+{
+    LIBCLOG_ENTER("\n");
+
+    /*
+     * Exception handler.
+     */
+    PEXCEPTIONREGISTRATIONRECORD pRegRec = (PEXCEPTIONREGISTRATIONRECORD)pvRegRec;
+    pRegRec->prev_structure   = END_OF_CHAIN;
+    pRegRec->ExceptionHandler = __libc_Back_exceptionHandler;
+    int rc = DosSetExceptionHandler(pRegRec);
+
+    /*
+     * Signal handling.
+     */
+    rc = DosSetSigHandler((PFNSIGHANDLER)__libc_back_signalOS2V1Handler16bit, NULL, NULL, SIGA_ACCEPT, SIG_PFLG_A);
+    if (!rc)
+    {
+        gfOS2V1Handler = 1;
+        ULONG cTimes = 0;
+        DosSetSignalExceptionFocus(SIG_SETFOCUS, &cTimes); /* (Will fail with rc 303 for PM apps - which we ignore.) */
+        LIBCLOG_RETURN_INT(0);
+    }
+    LIBC_ASSERTM_FAILED("DosSetSigHandler failed with rc=%d\n", rc);
+    rc = -__libc_native2errno(rc);
+    LIBCLOG_RETURN_INT(rc);
 }
 
@@ -665 +781 @@
 
 /**
+ * Worker called after __libc_Back_signalRaise() was called with a
+ * preallocated signal queue entry. This function will make sure
+ * we're not ending up with too many heap allocated packets in the
+ * free list.
+ */
+void __libc_Back_signalFreeWorker(void)
+{
+    LIBCLOG_ENTER("\n");
+    if (gcSigQueuedFree > sizeof(gpaSigQueuedPreAlloced) * 2 / sizeof(gpaSigQueuedPreAlloced[0]))
+    {
+        if (!__libc_back_signalSemRequest())
+        {
+            /*
+             * Free nodes which was allocated from the heap until we're below the water line.
+             */
+            PSIGQUEUED pSigPrev = NULL;
+            PSIGQUEUED pSig = gpSigQueuedFree;
+            int cToMany = gcSigQueuedFree - sizeof(gpaSigQueuedPreAlloced) * 2 / sizeof(gpaSigQueuedPreAlloced[0]);
+            while (cToMany > 0)
+            {
+                if (pSig->enmHowFree == enmHowFree_HeapFree)
+                {
+                    /* unlink */
+                    PSIGQUEUED pSigNext = pSig->pNext;
+                    if (pSigPrev)
+                        pSigPrev->pNext = pSigNext;
+                    else
+                        gpSigQueuedFree = pSigNext;
+
+                    /* free */
+                    free(pSig);
+
+                    /* next */
+                    pSig = pSigNext;
+                }
+                else
+                {
+                    pSigPrev = pSig;
+                    pSig = pSig->pNext;
+                }
+            }
+            __libc_back_signalSemRelease();
+        }
+    }
+    LIBCLOG_RETURN_VOID();
+}
+
+
+/**
  * Raises a signal in the current process.
  *
@@ -682 +847 @@
 int __libc_Back_signalRaise(int iSignalNo, siginfo_t *pSigInfo, void *pvXcptOrQueued, unsigned fFlags)
 {
-    LIBCLOG_ENTER("iSignalNo=%d pSigInfo=%p pvXcptOrQueued=%p fFlags=%#x\n",
-                  iSignalNo, (void *)pSigInfo, (void *)pvXcptOrQueued, fFlags);
+    LIBCLOG_ENTER("iSignalNo=%d pSigInfo=%p{.si_signo=%d, .si_errno=%d, .si_code=%#x, .si_timestamp=%#x, .si_flags=%#x .si_pid=%#x, .si_tid=%#x, .si_uid=%d, .si_status=%d, .si_addr=%p, .si_value=%p, .si_band=%ld, .si_fd=%d} pvXcptOrQueued=%p fFlags=%#x\n",
+                  iSignalNo, (void *)pSigInfo,
+                  pSigInfo ? pSigInfo->si_signo : 0,
+                  pSigInfo ? pSigInfo->si_errno : 0,
+                  pSigInfo ? pSigInfo->si_code : 0,
+                  pSigInfo ? pSigInfo->si_timestamp : 0,
+                  pSigInfo ? pSigInfo->si_flags : 0,
+                  pSigInfo ? pSigInfo->si_pid : 0,
+                  pSigInfo ? pSigInfo->si_tid : 0,
+                  pSigInfo ? pSigInfo->si_uid : 0,
+                  pSigInfo ? pSigInfo->si_status : 0,
+                  pSigInfo ? pSigInfo->si_addr : 0,
+                  pSigInfo ? pSigInfo->si_value.sigval_ptr : 0,
+                  pSigInfo ? pSigInfo->si_band : 0,
+                  pSigInfo ? pSigInfo->si_fd : 0,
+                  (void *)pvXcptOrQueued, fFlags);
 
     /*
@@ -689 +868 @@
      */
     LIBC_ASSERTM(!__libc_back_signalSemIsOwner(), "Thread owns the signal semaphore!!! Bad boy!!\n");
-    if (__SIGSET_SIG_VALID(iSignalNo) || iSignalNo == 0)
+    if (!__SIGSET_SIG_VALID(iSignalNo) || iSignalNo == 0)
     {
         LIBC_ASSERTM_FAILED("Invalid signal %d\n", iSignalNo);
@@ -740 +919 @@
         LIBCLOG_MSG("we're toast!\n");
         DosWrite(HFILE_STDERR, szMsg, sizeof(szMsg) - 1, &cb);
-        signalTerminate(iSignalNo);
+        signalTerminateAbnormal(iSignalNo);
     }
 
@@ -793 +972 @@
         ||  (   gaSignalActions[iSignalNo].__sigaction_u.__sa_handler == SIG_DFL
              && (gafSignalProperties[iSignalNo] & SPA_MASK) == SPA_IGNORE)
+        ||  (   iSignalNo == SIGCHLD
+             && pSigInfo
+             && (gaSignalActions[SIGCHLD].sa_flags & SA_NOCLDSTOP)
+             && (pSigInfo->si_flags & __LIBC_SI_INTERNAL)
+             && (pSigInfo->si_code == CLD_STOPPED || pSigInfo->si_code == CLD_CONTINUED))
         )
     {
@@ -819 +1003 @@
          */
         pThrdSig = pThrd;
+    }
+    else if (gafSignalProperties[iSignalNo] & SPP_THRDONE)
+    {
+        /*
+         * Must schedule this signal on thread one.
+         */
+        pThrdSig = __libc_threadLookup(1);
     }
     else
@@ -851 +1042 @@
             pThrdSig->enmStatus = enmLIBCThreadStatus_unknown;
             if (pThrdSig != pThrd)
-                signalPokeThread(pThrdSig);
+                __libc_back_signalPokeThread(pThrdSig);
             LIBCLOG_MSG("wokeup sigwait in thread %d on signal %d.\n", pThrdSig->tid, iSignalNo);
         }
@@ -859 +1050 @@
              * Not waited for, so just queue it if possible and mark it pending.
              */
-            if (    (fFlags & __LIBC_BSRF_QUEUED)
+            if (    pSigInfo
+                ||  (fFlags & __LIBC_BSRF_QUEUED)
                 ||  (gafSignalProperties[iSignalNo] & SPP_QUEUED))
             {
@@ -884 +1076 @@
                     if (    (fFlags & __LIBC_BSRF_HARDWARE)
                         ||  iSignalNo == SIGKILL)
-                    {
+                    {   /* insert at head */
                         pSigQueued->pPrev = NULL;
                         pSigQueued->pNext = pThrdSig->SigQueue.pHead;
                         if (pThrdSig->SigQueue.pHead)
-                            pThrdSig->SigQueue.pHead = pThrdSig->SigQueue.pHead->pPrev = pSigQueued;
+                            pThrdSig->SigQueue.pHead->pPrev = pSigQueued;
                         else
-                            pThrdSig->SigQueue.pHead = pThrdSig->SigQueue.pTail = pSigQueued;
+                            pThrdSig->SigQueue.pTail = pSigQueued;
+                        pThrdSig->SigQueue.pHead = pSigQueued;
                     }
                     else
-                    {
+                    {   /* insert at tail */
                         pSigQueued->pNext = NULL;
                         pSigQueued->pPrev = pThrdSig->SigQueue.pTail;
                         if (pThrdSig->SigQueue.pTail)
-                            pThrdSig->SigQueue.pTail = pThrdSig->SigQueue.pTail->pNext = pSigQueued;
+                            pThrdSig->SigQueue.pTail->pNext = pSigQueued;
                         else
-                            pThrdSig->SigQueue.pTail = pThrdSig->SigQueue.pHead = pSigQueued;
+                            pThrdSig->SigQueue.pHead = pSigQueued;
+                        pThrdSig->SigQueue.pTail = pSigQueued;
                     }
                     LIBCLOG_MSG("enqueued signal %d.\n", iSignalNo);
                 }
-                else
-                {   /* arg! out of nodes :/ */
+                /*
+                 * No available nodes - ignore this situation if queueing isn't compulsory.
+                 */
+                else if (   (fFlags & __LIBC_BSRF_QUEUED)
+                         || (gafSignalProperties[iSignalNo] & SPP_QUEUED))
+                {
                     LIBC_ASSERTM_FAILED("Out of queue nodes! iSignalNo=%d\n", iSignalNo);
                     rc = -EAGAIN;
@@ -917 +1115 @@
                 __SIGSET_SET(&pThrd->SigSetPending, iSignalNo);
                 if (pThrdSig != pThrd)
-                    signalPokeThread(pThrdSig);
+                    __libc_back_signalPokeThread(pThrdSig);
                 LIBCLOG_MSG("setting %d pending on thread %d's and poking it.\n", pThrdSig->tid, iSignalNo);
             }
@@ -928 +1126 @@
          * Queue it if required and then mark it pending.
          */
-        if (    (fFlags & __LIBC_BSRF_QUEUED)
+        if (    pSigInfo
+            ||  (fFlags & __LIBC_BSRF_QUEUED)
             ||  (gafSignalProperties[iSignalNo] & SPP_QUEUED))
         {
@@ -959 +1158 @@
                 LIBCLOG_MSG("enqueued signal %d.\n", iSignalNo);
             }
-            else
-            {   /* arg! out of nodes :/ */
+            /*
+             * No available nodes - ignore this situation if queueing isn't compulsory.
+             */
+            else if (   (fFlags & __LIBC_BSRF_QUEUED)
+                     || (gafSignalProperties[iSignalNo] & SPP_QUEUED))
+            {
                 rc = -EAGAIN;
                 LIBC_ASSERTM_FAILED("Out of queue nodes! iSignalNo=%d\n", iSignalNo);
@@ -1061 +1264 @@
      * Process queued signals first (to get a more correct order).
      */
-    sigset_t    SigDone;
-    __SIGSET_EMPTY(&SigDone);
+    sigset_t    SigSetDone;
+    __SIGSET_EMPTY(&SigSetDone);
     PSIGQUEUED pSig = gpSigQueueHead;
     while (pSig)
     {
         int iSignalNo = pSig->SigInfo.si_signo;
-        if (!__SIGSET_ISSET(&SigDone, iSignalNo))
+        if (!__SIGSET_ISSET(&SigSetDone, iSignalNo))
         {
             __LIBC_PTHREAD pThrdSig = signalScheduleThread(iSignalNo, pThrd);
             if (!pThrdSig)
-                __SIGSET_SET(&SigDone, iSignalNo);
+                __SIGSET_SET(&SigSetDone, iSignalNo);
             else
             {
@@ -1077 +1280 @@
                 PSIGQUEUED pSigNext = pSig->pNext;
                 if (pSig->pPrev)
-                    pSig->pPrev->pNext = pSig->pNext;
+                    pSig->pPrev->pNext = pSigNext;
                 else
-                    gpSigQueueHead     = pSig->pNext;
-                if (pSig->pNext)
+                    gpSigQueueHead     = pSigNext;
+                if (pSigNext)
                     pSig->pNext->pPrev = pSig->pPrev;
                 else
@@ -1103 +1306 @@
      * Process pending signals (which was not queued).
      */
-    int iSignalNo = 0;
-    while (iSignalNo++ < __SIGSET_MAXSIGNALS)
-    {
-        if (    !__SIGSET_ISSET(&SigDone, iSignalNo)
-            &&  __SIGSET_ISSET(&__libc_gSignalPending, iSignalNo))
-        {
-            __LIBC_PTHREAD pThrdSig = signalScheduleThread(iSignalNo, pThrd);
-            if (pThrdSig)
+    sigset_t    SigSetTodo = __libc_gSignalPending;
+    if (!__SIGSET_ISEMPTY(&SigSetTodo))
+    {
+        __SIGSET_NOT(&SigSetDone);
+        __SIGSET_AND(&SigSetTodo, &SigSetTodo, &SigSetDone);
+        if (!__SIGSET_ISEMPTY(&SigSetTodo))
+        {
+            int iSignalNo = 0;
+            while (++iSignalNo < __SIGSET_MAXSIGNALS)
             {
-                signalScheduleToThread(pThrd, pThrdSig, iSignalNo, NULL);
-                __SIGSET_CLEAR(&__libc_gSignalPending, iSignalNo);
-                __libc_threadDereference(pThrdSig);
+                if (__SIGSET_ISSET(&SigSetTodo, iSignalNo))
+                {
+                    __LIBC_PTHREAD pThrdSig = signalScheduleThread(iSignalNo, pThrd);
+                    if (pThrdSig)
+                    {
+                        signalScheduleToThread(pThrd, pThrdSig, iSignalNo, NULL);
+                        __SIGSET_CLEAR(&__libc_gSignalPending, iSignalNo);
+                        __libc_threadDereference(pThrdSig);
+                    }
+                }
             }
         }
@@ -1138 +1349 @@
 {
     LIBCLOG_ENTER("pThrd=%p pThrdSig=%p {.tid=%#x} iSignalNo=%d pSig=%p\n", (void *)pThrd, (void *)pThrdSig, pThrdSig->tid, iSignalNo, (void *)pSig);
+
     /*
      * If we've got a queue node, queue it.
@@ -1148 +1360 @@
             pThrdSig->SigQueue.pTail->pNext = pSig;
         else
-            pThrdSig->SigQueue.pTail = pThrdSig->SigQueue.pHead = pSig;
+            pThrdSig->SigQueue.pHead = pSig;
+        pThrdSig->SigQueue.pTail = pSig;
     }
 
@@ -1156 +1369 @@
     __SIGSET_SET(&pThrd->SigSetPending, iSignalNo);
     if (pThrdSig != pThrd)
-        signalPokeThread(pThrdSig);
+        __libc_back_signalPokeThread(pThrdSig);
     LIBCLOG_MSG("setting %d pending on thread %d's and poking it.\n", pThrdSig->tid, iSignalNo);
     LIBCLOG_RETURN_VOID();
@@ -1288 +1501 @@
      */
     if (    pCur->fSigBeingPoked
-        ||  pCur != (__LIBC_PTHREAD)pvParam)
+        ||  pCur == (__LIBC_PTHREAD)pvParam)
         return 0;
 
@@ -1294 +1507 @@
      * See if there are pending signals that can be delivered.
      */
-    sigset_t    SigSet = pCur->SigSetPending;
-    __SIGSET_AND(&SigSet, &SigSet, &pCur->SigSetBlocked);
-    if (!__SIGSET_EMPTY(&SigSet))
-        __libc_back_signalPokeThread(pCur->tid);
+    sigset_t    SigSetPending = pCur->SigSetBlocked;
+    __SIGSET_NOT(&SigSetPending);
+    __SIGSET_AND(&SigSetPending, &SigSetPending, &pCur->SigSetPending);
+    if (!__SIGSET_ISEMPTY(&SigSetPending))
+        __libc_back_signalPokeThread(pCur);
 
     return 0;
@@ -1331 +1545 @@
          * Anything pending?
          */
-        __sigset_t  SigDeliver = pThrd->SigSetPending;
-        __SIGSET_AND(&SigDeliver, &SigDeliver, &pThrd->SigSetBlocked);
+        sigset_t    SigDeliver = pThrd->SigSetBlocked;
+        __SIGSET_NOT(&SigDeliver);
+        __SIGSET_AND(&SigDeliver, &SigDeliver, &pThrd->SigSetPending);
         if (__SIGSET_ISEMPTY(&SigDeliver))
             break;
@@ -1341 +1556 @@
          *   1. SIGKILL
          *   2. Realtime signals. (queued)
-         *   3. SIGCHLD
-         *   4. SIGCONT
-         *   5. Ascending from pending mask.
+         *   3. SIGTERM
+         *   4. SIGABRT
+         *   5. SIGCHLD
+         *   6. SIGCONT
+         *   7. Ascending from pending mask.
          *
          * Note that 0 and 1 may be violating the POSIX specs.
@@ -1357 +1574 @@
                 if (iSignalNo > SIGRTMAX)
                 {
-                    iSignalNo = SIGCHLD;
-                    if (!__SIGSET_ISSET(&SigDeliver, SIGCHLD))
+                    iSignalNo = SIGTERM;
+                    if (!__SIGSET_ISSET(&SigDeliver, SIGTERM))
                     {
-                        iSignalNo = SIGCONT;
-                        if (!__SIGSET_ISSET(&SigDeliver, SIGCONT))
+                        iSignalNo = SIGABRT;
+                        if (!__SIGSET_ISSET(&SigDeliver, SIGABRT))
                         {
-                            iSignalNo = 1;
-                            while (iSignalNo < SIGRTMIN && !__SIGSET_ISSET(&SigDeliver, iSignalNo))
-                                iSignalNo++;
-                            if (iSignalNo >= SIGRTMIN)
+                            iSignalNo = SIGCHLD;
+                            if (!__SIGSET_ISSET(&SigDeliver, SIGCHLD))
                             {
-                                LIBC_ASSERTM_FAILED("Internal error!!!\n");
-                                LIBCLOG_RETURN_INT(__LIBC_BSRR_CONTINUE);
+                                iSignalNo = SIGCONT;
+                                if (!__SIGSET_ISSET(&SigDeliver, SIGCONT))
+                                {
+                                    iSignalNo = 1;
+                                    while (iSignalNo < SIGRTMIN && !__SIGSET_ISSET(&SigDeliver, iSignalNo))
+                                        iSignalNo++;
+                                    if (iSignalNo >= SIGRTMIN)
+                                    {
+                                        LIBC_ASSERTM_FAILED("Internal error!!!\n");
+                                        LIBCLOG_RETURN_INT(__LIBC_BSRR_CONTINUE);
+                                    }
+                                }
                             }
                         }
@@ -1413 +1638 @@
                 break;
             }
+            /* next */
+            pSig = pSig->pNext;
         }
 
@@ -1457 +1684 @@
                  */
                 case SPA_NEXT_KILL:
+                case SPA_KILL:
+                    signalTerminate(iSignalNo);
+                case SPA_CORE:
                 case SPA_NEXT_CORE:
-                case SPA_KILL:
-                case SPA_CORE:
-                    signalTerminate(iSignalNo);
+                    signalTerminateAbnormal(iSignalNo);
                     break;
 
@@ -1545 +1773 @@
                 *pStack-- = (uintptr_t)pvCtx;
                 *pStack-- = (uintptr_t)&SigInfo;
-                *pStack-- = iSignalNo;
+                *pStack   = iSignalNo;
                 pTib->tib_pstack      = pThrd->pvSigStack;
                 pTib->tib_pstacklimit = (char *)pThrd->pvSigStack + pThrd->cbSigStack;
@@ -1552 +1780 @@
                 __libc_back_signalSemRelease();
                 __asm__ __volatile__ (
-                    "movl %%esp, %0\n\t"
+                    "mov  %%esp, %0\n\t"
                     "movl %1, %%esp\n\t"
                     "call *%2\n\t"
-                    "movl 12(%%esp), %%esp\n\t"
+                    "mov 12(%%esp), %%esp\n\t"
                     : "=m" (*(uintptr_t *)((char *)pThrd->pvSigStack + pThrd->cbSigStack - sizeof(uintptr_t)))
-                    : "a" (pStack),
+                    : "c" (pStack),
                       "d" (SigAction.__sigaction_u.__sa_sigaction)
-                    : "ecx" );
+                    : "eax" );
 
                 /* Restore tib and release the stack. */
@@ -1601 +1829 @@
     } /* forever */
 
+    LIBC_ASSERT(__libc_back_signalSemIsOwner());
+    __libc_back_signalSemRelease();
     LIBCLOG_RETURN_INT(rcRet);
 }
 
-
 /**
  * Cause immediate process termination because of the given signal.
@@ -1612 +1841 @@
 static void signalTerminate(int iSignalNo)
 {
-    /** @todo implement process termination by signal properly! */
+    LIBCLOG_ENTER("iSignalNo=%d\n", iSignalNo);
+
+    /*
+     * Set the exit reason in SPM and exit process.
+     */
+    __libc_spmTerm(__LIBC_EXIT_REASON_SIGNAL_BASE + iSignalNo, 127);
+    LIBCLOG_MSG("Calling DosExit(,127)\n");
+    for (;;)
+        DosExit(EXIT_THREAD, 127);
+}
+
+/**
+ * Cause immediate process termination because of the given signal.
+ *
+ * @param   iSignalNo   Signal causing the termination.
+ */
+static void signalTerminateAbnormal(int iSignalNo)
+{
+    LIBCLOG_ENTER("iSignalNo=%d\n", iSignalNo);
+    /*
+     * Set the exit reason in SPM.
+     */
+    __libc_spmTerm(__LIBC_EXIT_REASON_SIGNAL_BASE + iSignalNo, 127);
+
     /*
      * Before we go crazy here, let's release the semaphore.
@@ -1623 +1875 @@
     //    DosReleaseMutexSem(ghmtxSignals);
 
+    /*
+     * Terminate the exception handler chain to avoid recursive trouble.
+     */
+    FS_VAR();
+    FS_SAVE_LOAD();
+    PTIB pTib;
+    PPIB pPib;
+    DosGetInfoBlocks(&pTib, &pPib);
+    pTib->tib_pexchain = END_OF_CHAIN;
+
+    /*
+     * Write message to stderr.
+     */
+    ULONG   cb;
+    if (iSignalNo == SIGABRT)
+    {
+        static const char szMsg[] = "\n\rAbnormal program termination";
+        DosWrite(HFILE_STDERR, szMsg, sizeof(szMsg) - 1, &cb);
+    }
+    else
+    {
+        static const char szMsg[] = "\n\rProcess terminated by ";
+        DosWrite(HFILE_STDERR, szMsg, sizeof(szMsg) - 1, &cb);
+
+        const char *psz = "unknown signal";
+        if (iSignalNo < sizeof(gaszSignalNames) / sizeof(gaszSignalNames[0]))
+            psz = gaszSignalNames[iSignalNo];
+        for (cb = 0; psz[cb];)
+            cb++;
+        DosWrite(HFILE_STDERR, psz, cb, &cb);
+    }
+
+    /* pid */
+    static const char szMsgPid[] = " - pid=0x";
+    DosWrite(HFILE_STDERR, szMsgPid, sizeof(szMsgPid) - 1, &cb);
+    char szHexNum[12];
+    cb = signalTerminateHex(szHexNum, pPib->pib_ulpid);
+    DosWrite(HFILE_STDERR, szHexNum, cb, &cb);
+
+    /* tid */
+    static const char szMsgTid[] = " - tid=0x";
+    DosWrite(HFILE_STDERR, szMsgTid, sizeof(szMsgTid) - 1, &cb);
+    cb = signalTerminateHex(szHexNum, pTib->tib_ptib2->tib2_ultid);
+    DosWrite(HFILE_STDERR, szHexNum, cb, &cb);
+
+    /* executable name. */
+    static char szExeName[CCHMAXPATH];
+    if (!DosQueryModuleName(pPib->pib_hmte, sizeof(szExeName), &szExeName[0]))
+    {
+        static const char szHypen[] = " - ";
+        DosWrite(HFILE_STDERR, szHypen, sizeof(szHypen) - 1, &cb);
+
+        for (cb = 0; szExeName[cb];)
+            cb++;
+        DosWrite(HFILE_STDERR, szExeName, cb, &cb);
+    }
+
+    /* final newline */
+    static const char szNewLine[] = "\r\n";
+    DosWrite(HFILE_STDERR, szNewLine, sizeof(szNewLine) - 1, &cb);
+
+    /*
+     * Terminate the process.
+     */
+    LIBCLOG_MSG("Calling DosExit(,127)\n");
     for (;;)
         DosExit(EXIT_THREAD, 127);
@@ -1628 +1945 @@
 
 /**
+ * Termination time hex formatter.
+ *
+ * @returns number of bytes formatted.
+ * @param   pszBuf  Where to store the formatted number.
+ * @param   u       Number to format.
+ */
+static int signalTerminateHex(char *pszBuf, unsigned u)
+{
+    static const char szHex[17] = "0123456789abcdef";
+    if (u <= 0xff)
+    {
+        pszBuf[0] = szHex[u >> 4];
+        pszBuf[1] = szHex[u & 0xf];
+        pszBuf[2] = '\0';
+        return 2;
+    }
+    else if (u <= 0xffff)
+    {
+        pszBuf[0] = szHex[u >> 12];
+        pszBuf[1] = szHex[(u >> 8) & 0xf];
+        pszBuf[2] = szHex[(u >> 4) & 0xf];
+        pszBuf[3] = szHex[u & 0xf];
+        pszBuf[4] = '\0';
+        return 4;
+    }
+    else
+    {
+        pszBuf[0] = szHex[u >> 28];
+        pszBuf[1] = szHex[(u >> 24) & 0xf];
+        pszBuf[2] = szHex[(u >> 20) & 0xf];
+        pszBuf[3] = szHex[(u >> 16) & 0xf];
+        pszBuf[4] = szHex[(u >> 12) & 0xf];
+        pszBuf[5] = szHex[(u >>  8) & 0xf];
+        pszBuf[6] = szHex[(u >>  4) & 0xf];
+        pszBuf[7] = szHex[u & 0xf];
+        pszBuf[8] = '\0';
+        return 8;
+    }
+}
+
+/**
  * Stop the process (job control emulation).
  *
@@ -1634 +1992 @@
 static int signalJobStop(int iSignalNo)
 {
-    /** @todo Job control: tell parent and ensure that thread 1 is frozen and unfrozen. */
+    LIBC_ASSERTM(__libc_threadCurrent()->tid == 1, "Invalid thread %d\n", __libc_threadCurrent()->tid);
+
+    /*
+     * Signal parent.
+     */
+    siginfo_t   SigInfo = {0};
+    SigInfo.si_signo    = SIGCHLD;
+    SigInfo.si_pid      = _sys_pid;
+    SigInfo.si_code     = CLD_STOPPED;
+    SigInfo.si_flags    = __LIBC_SI_INTERNAL;
+    __libc_back_signalSendPidOther(_sys_ppid, SIGCHLD, &SigInfo);
+
+    /*
+     * Wait for interruption (outside semaphores of course).
+     */
+    __libc_back_signalSemRelease();
     DosWaitEventSem(ghevWait, SEM_INDEFINITE_WAIT);
-    return 0;
+    return __libc_back_signalSemRequest();
 }
 
@@ -1646 +2019 @@
 static int signalJobResume(void)
 {
-    /** @todo Job control: tell parent and ensure that thread 1 is unfrozen. */
+    LIBC_ASSERTM(__libc_threadCurrent()->tid == 1, "Invalid thread %d\n", __libc_threadCurrent()->tid);
+
+    /*
+     * Signal parent.
+     */
+    siginfo_t   SigInfo = {0};
+    SigInfo.si_signo    = SIGCHLD;
+    SigInfo.si_pid      = _sys_pid;
+    SigInfo.si_code     = CLD_CONTINUED;
+    SigInfo.si_flags    = __LIBC_SI_INTERNAL;
+    __libc_back_signalSendPidOther(_sys_ppid, SIGCHLD, &SigInfo);
     return 0;
 }
@@ -1658 +2041 @@
  * @return 0 on success.
  * @return -errno on failure.
+ * @param   pid         Target pid.
  * @param   iSignalNo   Signal number to send.
- */
-int __libc_back_signalSendPidOther(pid_t pid, int iSignalNo)
-{
-    LIBCLOG_ENTER("pid=%d iSignalNo=%d\n", pid, iSignalNo);
+ * @param   pSigInfo    Signal info (optional).
+ */
+int __libc_back_signalSendPidOther(pid_t pid, int iSignalNo, siginfo_t *pSigInfo)
+{
+    LIBCLOG_ENTER("pid=%d iSignalNo=%d pSigInfo=%p\n", pid, iSignalNo, (void *)pSigInfo);
     int     rc;
     int     rcOS2;
@@ -1670 +2055 @@
      * Send the signal.
      */
-    switch (iSignalNo)
-    {
-        /*
-         * SIGKILL means kill process.
-         */
-        case SIGKILL:
-            FS_SAVE_LOAD();
-            rcOS2 = DosKillProcess(DKP_PROCESS, pid);
-            FS_RESTORE();
-            switch (rcOS2)
-            {
-                case NO_ERROR:
-                    LIBCLOG_RETURN_INT(0);
-
-                case ERROR_INVALID_PROCID:
-                    rc = -ESRCH;
-                    break;
-                default:
-                    rc = -EPERM;
-                    break;
-            }
-            LIBCLOG_RETURN_MSG(rc, "ret %d (DosKillProcess rcOS2=%d)\n", rc, rcOS2);
-
-        /*
-         * We can send these the normal way to decentants.
-         */
-        case SIGINT:
-        case SIGBREAK:
-            FS_SAVE_LOAD();
-            rcOS2 = DosSendSignalException(pid, iSignalNo == SIGINT ? XCPT_SIGNAL_INTR : XCPT_SIGNAL_BREAK);
-            FS_RESTORE();
-            switch (rcOS2)
-            {
-                case NO_ERROR:
-                    LIBCLOG_RETURN_INT(0);
-
-                case ERROR_INVALID_PROCID:
-                    LIBCLOG_RETURN_INT(-ESRCH);
-            }
-            /* try flag it */
-            break;
-
-        default:
-            break;
+    if (pSigInfo)
+    {
+        switch (iSignalNo)
+        {
+            /*
+             * SIGKILL means kill process.
+             */
+            case SIGKILL:
+                FS_SAVE_LOAD();
+                rcOS2 = DosKillProcess(DKP_PROCESS, pid);
+                FS_RESTORE();
+                switch (rcOS2)
+                {
+                    case NO_ERROR:
+                        LIBCLOG_RETURN_INT(0);
+
+                    case ERROR_INVALID_PROCID:
+                        rc = -ESRCH;
+                        break;
+                    default:
+                        rc = -EPERM;
+                        break;
+                }
+                LIBCLOG_RETURN_MSG(rc, "ret %d (DosKillProcess rcOS2=%d)\n", rc, rcOS2);
+
+            /*
+             * We can send these the normal way to decentants.
+             */
+            case SIGINT:
+            case SIGBREAK:
+                FS_SAVE_LOAD();
+                rcOS2 = DosSendSignalException(pid, iSignalNo == SIGINT ? XCPT_SIGNAL_INTR : XCPT_SIGNAL_BREAK);
+                FS_RESTORE();
+                switch (rcOS2)
+                {
+                    case NO_ERROR:
+                        LIBCLOG_RETURN_INT(0);
+
+                    case ERROR_INVALID_PROCID:
+                        LIBCLOG_RETURN_INT(-ESRCH);
+                }
+                /* try flag it */
+                break;
+
+            default:
+                break;
+        }
     }
 
@@ -1723 +2111 @@
      */
     siginfo_t SigInfo = {0};
-    SigInfo.si_signo    = iSignalNo;
-    SigInfo.si_pid      = _sys_pid;
-    __LIBC_PTHREAD pThrd = __libc_threadCurrentNoAuto();
+    if (pSigInfo)
+        SigInfo = *pSigInfo;
+    SigInfo.si_signo        = iSignalNo;
+    if (SigInfo.si_pid)
+        SigInfo.si_pid      = _sys_pid;
+    __LIBC_PTHREAD pThrd    = __libc_threadCurrentNoAuto();
     if (pThrd)
-        SigInfo.si_tid  = pThrd->tid;
-    SigInfo.si_timestamp= signalTimestamp();
+        SigInfo.si_tid      = pThrd->tid;
+    if (SigInfo.si_timestamp)
+        SigInfo.si_timestamp= signalTimestamp();
     if (gafSignalProperties[iSignalNo] & SPP_QUEUED)
-        SigInfo.si_flags |= __LIBC_SI_QUEUED;
+        SigInfo.si_flags   |= __LIBC_SI_QUEUED;
 
     rc = __libc_spmSigQueue(&SigInfo, pid, SigInfo.si_flags & __LIBC_SI_QUEUED);
@@ -1895 +2287 @@
  * evaluate pending signals.
  *
- * @param   tid     Thread to poke. 0 means current thread.
- */
-void        __libc_back_signalPokeThread(int tid)
-{
-    LIBC_ASSERTM(__libc_back_signalSemIsOwner(), "Thread must own signal sem!\n");
-
-    /*
-     * Get thread structure of target thread.
-     */
-    __LIBC_PTHREAD pThrdPoke = __libc_threadLookup(tid);
-    if (pThrdPoke)
-    {
-        signalPokeThread(pThrdPoke);
-        __libc_threadDereference(pThrdPoke);
-    }
-}
-
-
-/**
- * Pokes a thread in the current process, forcing it to
- * evaluate pending signals.
- *
  * @param   pThrdPoke       Thread to poke.
  */
-static void     signalPokeThread(__LIBC_PTHREAD pThrdPoke)
-{
+void     __libc_back_signalPokeThread(__LIBC_PTHREAD pThrdPoke)
+{
+    LIBCLOG_ENTER("pThrdPoke=%p {.tid=%#x}\n", (void *)pThrdPoke, pThrdPoke->tid);
     LIBC_ASSERTM(__libc_back_signalSemIsOwner(), "Thread must own signal sem!\n");
 
@@ -1933 +2304 @@
             LIBC_ASSERTM_FAILED("DosKillThread(%d) -> rc=%d\n", pThrdPoke->tid, rc);
     }
+
+    LIBCLOG_RETURN_VOID();
 }
 
@@ -1984 +2357 @@
  * sigaction worker; queries and/or sets the action for a signal.
  *
+ * @returns 0 on success.
+ * @returns -Negative errno on failure.
+ * @param   iSignalNo   Signal number.
+ * @param   pSigAct     Pointer to new signal action.
+ *                      If NULL no update is done.
+ * @param   pSigActOld  Where to store the old signal action.
+ *                      If NULL nothing is attempted stored.
+ */
+int         __libc_Back_signalAction(int iSignalNo, const struct sigaction *pSigAct, struct sigaction *pSigActOld)
+{
+    LIBCLOG_ENTER("iSignalNo=%d pSigAct=%p {sa_handler=%p, sa_mask={%#08lx %#08lx}, sa_flags=%#x} pSigActOld=%p\n",
+                  iSignalNo, (void *)pSigAct,
+                  pSigAct ? (void*)pSigAct->__sigaction_u.__sa_sigaction : NULL,
+                  pSigAct ? pSigAct->sa_mask.__bitmap[0] : 0,
+                  pSigAct ? pSigAct->sa_mask.__bitmap[1] : 0,
+                  pSigAct ? pSigAct->sa_flags : 0,
+                  (void *)pSigActOld);
+
+    /*
+     * Take the semaphore
+     */
+    LIBC_ASSERT(!__libc_back_signalSemIsOwner());
+    int rc = __libc_back_signalSemRequest();
+    if (!rc)
+    {
+        rc = __libc_back_signalAction(iSignalNo, pSigAct, pSigActOld);
+        __libc_back_signalSemRelease();
+    }
+
+    LIBCLOG_RETURN_INT(rc);
+}
+
+
+/**
+ * sigaction worker; queries and/or sets the action for a signal.
+ *
  * The caller MUST own the signal semaphore when calling this function.
  *
  * @returns 0 on success.
- * @returns -1 on failure, errno set.
+ * @returns Negative error code (errno.h) on failure.
  * @param   iSignalNo   Signal number.
  * @param   pSigAct     Pointer to new signal action.
@@ -2003 +2412 @@
                   pSigAct ? pSigAct->sa_flags : 0,
                   (void *)pSigActOld);
+
+    /*
+     * Assert state.
+     */
+    LIBC_ASSERTM(__libc_back_signalSemIsOwner(), "Thread does not own the signal semaphore!!!\n");
+
+    /*
+     * Check input.
+     */
+    if (!__SIGSET_SIG_VALID(iSignalNo))
+        LIBCLOG_RETURN_INT(-EINVAL);
+
+    /*
+     * Query.
+     */
+    if (pSigActOld)
+        *pSigActOld = gaSignalActions[iSignalNo];
+
+    /*
+     * Set.
+     */
     int rc = 0;
-
-    /*
-     * Assert state.
-     */
-    LIBC_ASSERTM(__libc_back_signalSemIsOwner(), "Thread does not own the signal semaphore!!!\n");
-
-    /*
-     * Check input.
-     */
-    if (!__SIGSET_SIG_VALID(iSignalNo))
-    {
-        errno = EINVAL;
-        LIBCLOG_RETURN_INT(-1);
-    }
-
-    /*
-     * Query.
-     */
-    if (pSigActOld)
-    {
-        *pSigActOld = gaSignalActions[iSignalNo];
-    }
-
-    /*
-     * Set.
-     */
     if (pSigAct)
     {
@@ -2039 +2443 @@
         {
             if (    pSigAct->__sigaction_u.__sa_handler != SIG_ERR
-                &&  pSigAct->__sigaction_u.__sa_handler != SIG_ACK)
+                &&  pSigAct->__sigaction_u.__sa_handler != SIG_ACK
+                &&  pSigAct->__sigaction_u.__sa_handler != SIG_HOLD
+                &&  pSigAct->__sigaction_u.__sa_handler != NULL)
             {
                 /*
@@ -2045 +2451 @@
                  */
                 gaSignalActions[iSignalNo] = *pSigAct;
+                __SIGSET_CLEAR(&gaSignalActions[iSignalNo].sa_mask, SIGKILL);
+                __SIGSET_CLEAR(&gaSignalActions[iSignalNo].sa_mask, SIGSTOP);
 
                 /*
@@ -2059 +2467 @@
             {
                 LIBC_ASSERTM_FAILED("Invalid sa_handler=%p\n", (void *)pSigAct->__sigaction_u.__sa_handler);
-                errno = EINVAL;
+                rc = -EINVAL;
             }
         }
@@ -2065 +2473 @@
         {
             LIBC_ASSERTM_FAILED("Invalid sa_flags=%#x\n", pSigAct->sa_flags);
-            errno = EINVAL;
-        }
-
+            rc = -EINVAL;
+        }
     }
 
@@ -2168 +2575 @@
 }
 
+
+
+_FORK_CHILD1(0x0000000f, signalForkChild)
+
+/**
+ * Fork callback which initializes 16-bit signal handler in the child process.
+ *
+ * @returns 0 on success.
+ * @returns -errno on failure.
+ * @param   pForkHandle     Pointer to fork handle.
+ * @param   enmOperation    Fork operation.
+ */
+static int signalForkChild(__LIBC_PFORKHANDLE pForkHandle, __LIBC_FORKOP enmOperation)
+{
+    LIBCLOG_ENTER("pForkHandle=%p enmOperation=%d\n", (void *)pForkHandle, enmOperation);
+    int     rc;
+    switch (enmOperation)
+    {
+        /*
+         * Install the 16-bit signal handler if we were the LIBC having that installed
+         * in the parent process.
+         */
+        case __LIBC_FORK_OP_FORK_CHILD:
+            rc = 0;
+            if (gfOS2V1Handler)
+            {
+                rc = DosSetSigHandler((PFNSIGHANDLER)__libc_back_signalOS2V1Handler16bit, NULL, NULL, SIGA_ACCEPT, SIG_PFLG_A);
+                if (rc)
+                {
+                    LIBC_ASSERTM_FAILED("DosSetSigHandler failed with rc=%d\n", rc);
+                    rc = -__libc_native2errno(rc);
+                }
+                ULONG cTimes = 0;
+                DosSetSignalExceptionFocus(SIG_SETFOCUS, &cTimes);
+            }
+            break;
+
+        default:
+            rc = 0;
+            break;
+    }
+
+    LIBCLOG_RETURN_INT(rc);
+}
+
+