Changeset 1629

Timestamp:

Nov 14, 2004, 6:28:02 AM (21 years ago)

Author:

bird

Message:

Signals, processes and stuff.

Location:

trunk/src/emx/src/lib

Files:

• libc.def (modified) (3 diffs, 1 prop)
• libc.smak (modified) (4 diffs, 1 prop)
• misc/getegid.c (modified) (1 diff, 1 prop)
• misc/geteuid.c (modified) (1 diff, 1 prop)
• misc/getgid.c (modified) (1 diff, 1 prop)
• misc/getgrgid.c (deleted)
• misc/getpwnam.c (deleted)
• misc/getpwuid.c (deleted)
• misc/getuid.c (modified) (1 diff, 1 prop)
• misc/setegid.c (added)
• misc/seteuid.c (added)
• misc/setgid.c (modified) (1 diff, 1 prop)
• misc/setregid.c (added)
• misc/setresgid.c (added)
• misc/setresuid.c (added)
• misc/setreuid.c (added)
• misc/setrgid.c (added)
• misc/setruid.c (added)
• misc/setuid.c (modified) (1 diff, 1 prop)
• misc/sysconf.c (modified) (1 diff, 1 prop)
• process/kill.c (modified) (1 diff, 1 prop)
• sys/b_processCredentials.c (added)
• sys/b_processWait.c (modified) (3 diffs, 1 prop)
• sys/b_signalQueue.c (modified) (2 diffs, 1 prop)
• sys/b_signalSendPGrp.c (deleted)
• sys/b_signalSendPid.c (modified) (5 diffs, 1 prop)
• sys/b_signalSuspend.c (modified) (1 diff, 1 prop)
• sys/b_signalVerifyPGrp.c (deleted)
• sys/b_signalVerifyPid.c (deleted)
• sys/filehandles.c (modified) (4 diffs, 1 prop)
• sys/sharedpm.c (modified) (46 diffs, 1 prop)
• sys/signals.c (modified) (9 diffs, 1 prop)
• sys/signals.h (modified) (1 diff, 1 prop)

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

@@ -686 +686 @@
     "__std_geteuid" @708
     "__std_getgid" @709
-    "__std_getgrgid" @710
+;fixme    "__std_getgrgid" @710
     "__std_getgrnam" @711
     "__std_getgroups" @712
@@ -696 +696 @@
     "__std_getpid" @718
     "__std_getppid" @719
-;    "__std_getpw" @720
+;fixme    "__std_getpw" @720
     "__std_getpwent" @721
-    "__std_getpwnam" @722
-    "__std_getpwuid" @723
+;fixme    "__std_getpwnam" @722
+;fixme    "__std_getpwuid" @723
     "__std_getrlimit" @724
     "__std_gets" @725
@@ -1230 +1230 @@
     "__std_sigwait" @1252
     "__std_sigwaitinfo" @1253
-    "___libc_Back_signalVerifyPGrp" @1254
-    "___libc_Back_signalVerifyPid" @1255
-    "___libc_Back_signalRaise" @1256
-    "___libc_Back_signalSendPGrp" @1257
-    "___libc_Back_signalSendPid" @1258
-    "___libc_Back_signalAction" @1259
-    "___libc_Back_signalFreeWorker" @1260
-    "___libc_Back_signalStack" @1261
-    "___libc_Back_signalMask" @1262
-    "___libc_Back_signalInterrupt" @1263
-    "___libc_Back_signalPending" @1264
-    "___libc_Back_signalSuspend" @1265
-    "___libc_Back_signalWait" @1266
+    "__std_sigqueue" @1254
+    "__std_sigset" @1255
+    "_getgrgid" @1256
+    "_getpwnam" @1257
+    "_getpwuid" @1258
+    "___libc_Back_processGetEffGid" @1259
+    "___libc_Back_processGetEffUid" @1260
+    "___libc_Back_processGetGid" @1261
+    "___libc_Back_processGetUid" @1262
+    "___libc_Back_processSetGid" @1263
+    "___libc_Back_processSetGidAll" @1264
+    "___libc_Back_processSetUid" @1265
+    "___libc_Back_processSetUidAll" @1266
+    "___libc_Back_processWait" @1267
+    "___libc_Back_signalAction" @1268
+    "___libc_Back_signalInterrupt" @1269
+    "___libc_Back_signalMask" @1270
+    "___libc_Back_signalPending" @1271
+    "___libc_Back_signalQueue" @1272
+    "___libc_Back_signalRaise" @1273
+    "___libc_Back_signalSendPGrp" @1274
+    "___libc_Back_signalSendPid" @1275
+    "___libc_Back_signalStack" @1276
+    "___libc_Back_signalSuspend" @1277
+    "___libc_Back_signalWait" @1278
+    "__std_setegid" @1279
+    "__std_seteuid" @1280
+    "__std_setregid" @1281
+    "__std_setresgid" @1282
+    "__std_setresuid" @1283
+    "__std_setreuid" @1284
+    "__std_setrgid" @1285
+    "__std_setruid" @1286
+    "__std_waitid" @1287

trunk/src/emx/src/lib/libc.smak

@@ -32 +32 @@
 .INSDIR = lib/
 .TKEEP  := 1
-include mklib.smak
+#include mklib.smak
 
 
@@ -38 +38 @@
 .TKIND  := aout log
 .TKEEP  := 1
-include mklib.smak
+#include mklib.smak
 
 # Build libc.a last since LIBC.DLL needs .OBJS from libc.a
@@ -312 +312 @@
 all: libc-dll
 libc-dll: emxbind emxexp app alias libc libos2 libos2@omf liblazyimp liblazyimp@omf libend \
-                        $(LIBC.DIRS) $(LIBC.DLL) $(LIBC.IMPLIB) \
+                        $(LIBC.DIRS) $(LIBC.DLL) $(LIBC.IMPLIB) 
+disabled.0 = \
                         $(LIBC.LOG.DIRS) $(LIBC.LOG.DLL) \
                         $(LIBC.PRF.DIRS) $(LIBC.PRF.DLL) \
@@ -320 +321 @@
 INS.FILES       += $(INS)lib/$(notdir $(LIBC.DLL)) \
   $(INS)lib/$(notdir $(LIBC.DLL:.dll=.map)) \
-  $(addprefix $(INS)lib/,$(notdir $(LIBC.IMPLIB))) \
+  $(addprefix $(INS)lib/,$(notdir $(LIBC.IMPLIB)))
+disabled.1 = \
   $(INS)lib/$(notdir $(LIBC.LOG.DLL)) \
   $(INS)lib/$(notdir $(LIBC.LOG.DLL).map) \

trunk/src/emx/src/lib/misc/getegid.c

@@ -1 @@
-/* getegid.c (emx+gcc) -- Copyright (c) 1994-1995 by Eberhard Mattes */
+/* $Id: $ */
+/** @file
+ *
+ * LIBC - getegid().
+ *
+ * Copyright (c) 2004 knut st. osmundsen <bird@innotek.de>
+ *
+ *
+ * This file is part of InnoTek LIBC.
+ *
+ * InnoTek LIBC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * InnoTek LIBC 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with InnoTek LIBC; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
 
+
+/*******************************************************************************
+*   Header Files                                                               *
+*******************************************************************************/
 #include "libc-alias.h"
+#include <errno.h>
 #include <unistd.h>
-#include <sys/types.h>
+#include <InnoTekLIBC/backend.h>
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_PROCESS
+#include <InnoTekLIBC/logstrict.h>
 
-gid_t _STD(getegid) (void)
+/**
+ * Gets the effective group id of the current process.
+ * @returns Effecitve group id.
+ */
+gid_t _STD(getegid)(void)
 {
-  return 0;
+    LIBCLOG_ENTER("\n");
+    gid_t gid = __libc_Back_processGetEffGid();
+    LIBCLOG_RETURN_INT(gid);
 }

trunk/src/emx/src/lib/misc/geteuid.c

@@ -1 @@
-/* geteuid.c (emx+gcc) -- Copyright (c) 1994-1995 by Eberhard Mattes */
+/* $Id: $ */
+/** @file
+ *
+ * LIBC - geteuid().
+ *
+ * Copyright (c) 2004 knut st. osmundsen <bird@innotek.de>
+ *
+ *
+ * This file is part of InnoTek LIBC.
+ *
+ * InnoTek LIBC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * InnoTek LIBC 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with InnoTek LIBC; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
 
+
+/*******************************************************************************
+*   Header Files                                                               *
+*******************************************************************************/
 #include "libc-alias.h"
+#include <errno.h>
 #include <unistd.h>
-#include <sys/types.h>
+#include <InnoTekLIBC/backend.h>
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_PROCESS
+#include <InnoTekLIBC/logstrict.h>
 
-uid_t _STD(geteuid) (void)
+/**
+ * Gets the effective group id of the current process.
+ *
+ * @returns Effective group id.
+ */
+uid_t _STD(geteuid)(void)
 {
-  return 0;
+    LIBCLOG_ENTER("\n");
+    uid_t uid = __libc_Back_processGetEffUid();
+    LIBCLOG_RETURN_INT(uid);
 }
+

trunk/src/emx/src/lib/misc/getgid.c

@@ -1 @@
-/* getgid.c (emx+gcc) -- Copyright (c) 1994-1995 by Eberhard Mattes */
+/* $Id: $ */
+/** @file
+ *
+ * LIBC - getgid().
+ *
+ * Copyright (c) 2004 knut st. osmundsen <bird@innotek.de>
+ *
+ *
+ * This file is part of InnoTek LIBC.
+ *
+ * InnoTek LIBC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * InnoTek LIBC 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with InnoTek LIBC; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
 
+
+/*******************************************************************************
+*   Header Files                                                               *
+*******************************************************************************/
 #include "libc-alias.h"
+#include <errno.h>
 #include <unistd.h>
-#include <sys/types.h>
+#include <InnoTekLIBC/backend.h>
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_PROCESS
+#include <InnoTekLIBC/logstrict.h>
 
-gid_t _STD(getgid) (void)
+/**
+ * Gets the real group id of the current process.
+ * @returns Real group id.
+ */
+gid_t _STD(getgid)(void)
 {
-  return 0;
+    LIBCLOG_ENTER("\n");
+    gid_t gid = __libc_Back_processGetGid();
+    LIBCLOG_RETURN_INT(gid);
 }

trunk/src/emx/src/lib/misc/getuid.c

@@ -1 @@
-/* getuid.c (emx+gcc) -- Copyright (c) 1994-1995 by Eberhard Mattes */
+/* $Id: $ */
+/** @file
+ *
+ * LIBC - getuid().
+ *
+ * Copyright (c) 2004 knut st. osmundsen <bird@innotek.de>
+ *
+ *
+ * This file is part of InnoTek LIBC.
+ *
+ * InnoTek LIBC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * InnoTek LIBC 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with InnoTek LIBC; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
 
+
+/*******************************************************************************
+*   Header Files                                                               *
+*******************************************************************************/
 #include "libc-alias.h"
+#include <errno.h>
 #include <unistd.h>
-#include <sys/types.h>
+#include <InnoTekLIBC/backend.h>
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_PROCESS
+#include <InnoTekLIBC/logstrict.h>
 
-uid_t _STD(getuid) (void)
+/**
+ * Gets the real group id of the current process.
+ *
+ * @returns Real group id.
+ */
+uid_t _STD(getuid)(void)
 {
-  return 0;
+    LIBCLOG_ENTER("\n");
+    uid_t uid = __libc_Back_processGetUid();
+    LIBCLOG_RETURN_INT(uid);
 }
+

trunk/src/emx/src/lib/misc/setgid.c

@@ -1 @@
-/* setgid.c (emx+gcc) -- Copyright (c) 1994-1995 by Eberhard Mattes */
+/* $Id: $ */
+/** @file
+ *
+ * LIBC - setgid().
+ *
+ * Copyright (c) 2004 knut st. osmundsen <bird@innotek.de>
+ *
+ *
+ * This file is part of InnoTek LIBC.
+ *
+ * InnoTek LIBC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * InnoTek LIBC 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with InnoTek LIBC; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
 
+
+/*******************************************************************************
+*   Header Files                                                               *
+*******************************************************************************/
 #include "libc-alias.h"
+#include <errno.h>
 #include <unistd.h>
-#include <errno.h>
-#include <sys/types.h>
+#include <InnoTekLIBC/backend.h>
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_PROCESS
+#include <InnoTekLIBC/logstrict.h>
 
-int _STD(setgid) (gid_t gid)
+/**
+ * Sets the real group id of the current process.
+ * If there user is privilegde all three group ids will be set.
+ *
+ * Non privilegde users may only set it to the real group id or the saved group id.
+ *
+ * @returns 0 on success.
+ * @returns -1 and errno on error.
+ * @param   gid     The new real group id.
+ *                  For superusers also the new effective and saved group id.
+ */
+int _STD(setgid)(gid_t gid)
 {
-  if (gid != 0)
-    {
-      errno = EINVAL;
-      return -1;
-    }
-  return 0;
+    LIBCLOG_ENTER("gid=%d (%#x)\n", gid, gid);
+    int rc = __libc_Back_processSetGid(gid);
+    if (!rc)
+        LIBCLOG_RETURN_INT(0);
+    errno = -rc;
+    LIBCLOG_RETURN_INT(-1);
 }
+

trunk/src/emx/src/lib/misc/setuid.c

@@ -1 @@
-/* setuid.c (emx+gcc) -- Copyright (c) 1994-1995 by Eberhard Mattes */
+/* $Id: $ */
+/** @file
+ *
+ * LIBC - setuid().
+ *
+ * Copyright (c) 2004 knut st. osmundsen <bird@innotek.de>
+ *
+ *
+ * This file is part of InnoTek LIBC.
+ *
+ * InnoTek LIBC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * InnoTek LIBC 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with InnoTek LIBC; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
 
+
+/*******************************************************************************
+*   Header Files                                                               *
+*******************************************************************************/
 #include "libc-alias.h"
+#include <errno.h>
 #include <unistd.h>
-#include <errno.h>
-#include <sys/types.h>
+#include <InnoTekLIBC/backend.h>
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_PROCESS
+#include <InnoTekLIBC/logstrict.h>
 
-int _STD(setuid) (uid_t uid)
+/**
+ * Sets the real user id of the current process.
+ * If there user is privilegde all three user ids will be set.
+ *
+ * Non privilegde users may only set it to the real user id or the saved user id.
+ *
+ * @returns 0 on success.
+ * @returns -1 and errno on error.
+ * @param   uid     The new real users id.
+ *                  For superusers also the new effective and saved user id.
+ */
+int _STD(setuid)(uid_t uid)
 {
-  if (uid != 0)
-    {
-      errno = EINVAL;
-      return -1;
-    }
-  return 0;
+    LIBCLOG_ENTER("uid=%d (%#x)\n", uid, uid);
+    int rc = __libc_Back_processSetUid(uid);
+    if (!rc)
+        LIBCLOG_RETURN_INT(0);
+    errno = -rc;
+    LIBCLOG_RETURN_INT(-1);
 }
+

trunk/src/emx/src/lib/misc/sysconf.c

@@ -11 +11 @@
 long _STD(sysconf) (int name)
 {
-  switch (name)
+    switch (name)
     {
-    case _SC_ARG_MAX:
-      return _POSIX_ARG_MAX;
+        case _SC_ARG_MAX:
+            return _POSIX_ARG_MAX;
 
-    case _SC_CHILD_MAX:
-      return _POSIX_CHILD_MAX;
+        case _SC_CHILD_MAX:
+            return _POSIX_CHILD_MAX;
 
-    case _SC_CLK_TCK:
-      /* On emx, CLK_TCK is a constant.  On other systems, it may a
-         macro which calls sysconf (_SC_CLK_TCK). */
+        case _SC_CLK_TCK:
+            /* On emx, CLK_TCK is a constant.  On other systems, it may a
+               macro which calls sysconf (_SC_CLK_TCK). */
 
-      return CLK_TCK;
+            return CLK_TCK;
 
-    case _SC_NGROUPS_MAX:
-      return _POSIX_NGROUPS_MAX;
+        case _SC_NGROUPS_MAX:
+            return _POSIX_NGROUPS_MAX;
 
-    case _SC_OPEN_MAX:
-      return _POSIX_OPEN_MAX;
+        case _SC_OPEN_MAX:
+            return _POSIX_OPEN_MAX;
 
-    case _SC_STREAM_MAX:
-      return _POSIX_STREAM_MAX;
+        case _SC_STREAM_MAX:
+            return _POSIX_STREAM_MAX;
 
-    case _SC_TZNAME_MAX:
-      return _POSIX_TZNAME_MAX;
+        case _SC_TZNAME_MAX:
+            return _POSIX_TZNAME_MAX;
 
-    case _SC_JOB_CONTROL:
-      return -1;
+        case _SC_JOB_CONTROL:
+            return -1;
 
-    case _SC_SAVED_IDS:
-      return -1;
+        case _SC_SAVED_IDS:
+            return -1;
 
-    case _SC_VERSION:
-      return _POSIX_VERSION;
+        case _SC_VERSION:
+            return _POSIX_VERSION;
 
-    default:
-      errno = EINVAL;
-      return -1;
+        case _SC_SIGQUEUE_MAX:
+            return _POSIX_SIGQUEUE_MAX;
+
+        default:
+            errno = EINVAL;
+            return -1;
     }
 }

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

@@ -72 +72 @@
 
     /*
-     * Validate the process specification.
+     * Call backend to do the rest.
      */
     if (pid > 0)
-        rc = __libc_Back_signalVerifyPid(pid);
+        rc = __libc_Back_signalSendPid(pid, iSignalNo);
     else /* (pid <= 0) */
-        rc = __libc_Back_signalVerifyPGrp(-pid);
+        rc = __libc_Back_signalSendPGrp(-pid, iSignalNo);
     if (!rc)
-    {
-        /*
-         * The pid is valid, if iSignalNo is 0 then we're done.
-         */
-        if (!iSignalNo)
-            LIBCLOG_RETURN_INT(0);
-
-        /*
-         * Send signals.
-         */
-        if (pid > 0)
-            rc = __libc_Back_signalSendPid(pid, iSignalNo);
-        else
-            rc = __libc_Back_signalSendPGrp(-pid, iSignalNo);
-        if (!rc)
-            LIBCLOG_RETURN_INT(0);
-    }
-    /* failure */
+        LIBCLOG_RETURN_INT(0);
     errno = -rc;
     LIBCLOG_RETURN_INT(-1);

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

@@ -373 +373 @@
      * (and besides it's deadly important to do it!)
      */
-    __LIBC_EXIT_REASON  enmReason;
-    int                 iExitCode;
-    if (!__libc_spmReapChild(pid, &iExitCode, &enmReason))
+    __LIBC_SPMCHILDNOTIFY Notify = {NULL, sizeof(Notify), 0};
+    if (!__libc_spmQueryChildNotification(pid, &Notify))
     {
         /*
@@ -382 +381 @@
          */
         LIBCLOG_MSG2("SPM Child %#lx (%ld) for reason %d and with code %d (%#x).\n",
-                     pid, pid, enmReason, iExitCode, iExitCode);
-
-        switch (enmReason)
+                     pid, pid, Notify.enmDeathReason, Notify.iExitCode, Notify.iExitCode);
+
+        switch (Notify.enmDeathReason)
         {
             case __LIBC_EXIT_REASON_EXIT:
                 pWait->uCode    = CLD_EXITED;
-                pWait->uStatus  = W_EXITCODE(iExitCode, 0);
+                pWait->uStatus  = W_EXITCODE(Notify.iExitCode, 0);
                 break;
 
             case __LIBC_EXIT_REASON_HARDERROR:
                 pWait->uCode    = CLD_KILLED;
-                pWait->uStatus  = W_EXITCODE(iExitCode, SIGBUS);
+                pWait->uStatus  = W_EXITCODE(Notify.iExitCode, SIGBUS);
                 break;
 
@@ -399 +398 @@
             case __LIBC_EXIT_REASON_XCPT:
                 pWait->uCode    = CLD_DUMPED;
-                pWait->uStatus  = W_EXITCODE(iExitCode, SIGSEGV);
+                pWait->uStatus  = W_EXITCODE(Notify.iExitCode, SIGSEGV);
                 break;
 
             case __LIBC_EXIT_REASON_KILL:
                 pWait->uCode    = CLD_KILLED;
-                pWait->uStatus  = W_EXITCODE(iExitCode, SIGKILL);
+                pWait->uStatus  = W_EXITCODE(Notify.iExitCode, SIGKILL);
                 break;
 
             default:
-                if (    enmReason >= __LIBC_EXIT_REASON_SIGNAL_BASE
-                    &&  enmReason <= __LIBC_EXIT_REASON_SIGNAL_MAX)
+                if (    Notify.enmDeathReason >= __LIBC_EXIT_REASON_SIGNAL_BASE
+                    &&  Notify.enmDeathReason <= __LIBC_EXIT_REASON_SIGNAL_MAX)
                 {
                     pWait->uCode    = CLD_KILLED;
-                    pWait->uStatus  = W_EXITCODE(iExitCode, enmReason - __LIBC_EXIT_REASON_SIGNAL_BASE);
+                    pWait->uStatus  = W_EXITCODE(Notify.iExitCode, Notify.enmDeathReason - __LIBC_EXIT_REASON_SIGNAL_BASE);
                     break;
                 }
                 /* fall thru */
             case __LIBC_EXIT_REASON_NONE:
-                LIBCLOG_MSG2("Unknown death reason %d\n", enmReason);
+                LIBCLOG_MSG2("Unknown death reason %d\n", Notify.enmDeathReason);
                 break;
         }

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

@@ -52 +52 @@
 {
     LIBCLOG_ENTER("pid=%d iSignalNo=%d SigVal=%p\n", pid, iSignalNo, SigVal.sigval_ptr);
-    int                 rc;
 
     /*
@@ -66 +65 @@
      * Verify pid.
      */
-    rc = __libc_Back_signalVerifyPid(pid);
-    if (!rc && iSignalNo)
+    siginfo_t   SigInfo = {0};
+    SigInfo.si_flags   |= __LIBC_SI_QUEUED;
+    SigInfo.si_value    = SigVal;
+    SigInfo.si_signo    = iSignalNo;
+    int rc;
+    if (pid == _sys_pid)
     {
-        siginfo_t   SigInfo = {0};
-        SigInfo.si_flags   |= __LIBC_SI_QUEUED;
-        SigInfo.si_value    = SigVal;
-        SigInfo.si_signo    = iSignalNo;
-        if (pid == _sys_pid)
+        if (iSignalNo)
             rc = __libc_back_signalQueueSelf(iSignalNo, &SigInfo);
-        else
-            rc = __libc_back_signalSendPidOther(pid, iSignalNo, &SigInfo);
+        else /* permission only */
+            rc = 0;
     }
+    else
+        rc = __libc_back_signalSendPidOther(pid, iSignalNo, &SigInfo);
 
     /*

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

@@ -40 +40 @@
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_BACK_SIGNAL
 #include <InnoTekLIBC/logstrict.h>
+#include "signals.h"
 #include "syscalls.h"
 
@@ -46 +47 @@
  * Send a signal to a process.
  *
+ * Special case for iSignalNo equal to 0, where no signal is sent but permissions to
+ * do so is checked.
+ *
  * @returns 0 on if signal sent.
  * @returns -errno on failure.
@@ -51 +55 @@
  * @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.
+ *                      If 0 no signal is sent, but error handling is done as if.
  */
 int     __libc_Back_signalSendPid(pid_t pid, int iSignalNo)
@@ -61 +65 @@
      * Validate input.
      */
-    if (!__SIGSET_SIG_VALID(iSignalNo))
+    if (!__SIGSET_SIG_VALID(iSignalNo) && iSignalNo != 0)
     {
         LIBC_ASSERTM_FAILED("Invalid signal no. %d\n", iSignalNo);
         LIBCLOG_RETURN_INT(-EINVAL);
     }
-    if (pid < 0)
+    if (pid <= 0)
     {
         LIBC_ASSERTM_FAILED("Invalid pid %d\n", pid);
@@ -79 +83 @@
     else
     {
-        rc = __libc_Back_signalRaise(iSignalNo, NULL, NULL, 0);
-        if (rc > 0)
+        if (iSignalNo != 0)
+        {
+            rc = __libc_Back_signalRaise(iSignalNo, NULL, NULL, 0);
+            if (rc > 0)
+                rc = 0;
+        }
+        else /* permission check, succeeded. */
             rc = 0;
     }

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

@@ -41 +41 @@
 /**
  * Suspends the current thread till a signal have been handled.
- * The signal semaphore is owned.
+ *
+ * @returns Negative error code (errno) on failure. (always fails)
+ * @param   pSigSet     Temporary signal mask for the thread.
  */
 int         __libc_Back_signalSuspend(const sigset_t *pSigSet)

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

@@ -178 +178 @@
             unsigned    i = 0;
             unsigned    c = u.pHdr->cHandles;
-            unsigned    iFH = u.pHdr->fhStart;
+            unsigned    iFH = u.pHdr->StartFH;
             switch (u.pHdr->uchType)
             {
@@ -359 +359 @@
             {
                 u.pStds->Hdr.uchType = __LIBC_SPM_INH_FHB_TYPE_STANDARD;
-                u.pStds->Hdr.fhStart = iFH;
+                u.pStds->Hdr.StartFH = iFH;
                 /* walk file handles. */
                 for (i = 0; ; )
@@ -384 +384 @@
                 u.pSockets->Hdr.uchType = enmType == enmFH_Socket44
                     ? __LIBC_SPM_INH_FHB_TYPE_SOCKET_44 : __LIBC_SPM_INH_FHB_TYPE_SOCKET_43;
-                u.pSockets->Hdr.fhStart = iFH;
+                u.pSockets->Hdr.StartFH = iFH;
                 /* walk file handles. */
                 for (i = 0; ; )
@@ -430 +430 @@
     u.pHdr->uchType  = __LIBC_SPM_INH_FHB_TYPE_END;
     u.pHdr->cHandles = 0;
-    u.pHdr->fhStart  = ~0;
+    u.pHdr->StartFH  = ~0;
     cb = (uintptr_t)(u.pHdr + 1) - (uintptr_t)pRet;
     *pcb = (cb + 3) & ~3;               /* (This is safe.) */

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

@@ -119 +119 @@
 static __LIBC_PSPMPROCESS spmQueryProcessInState(pid_t pid, __LIBC_SPMPROCSTAT enmState);
 static unsigned spmTimestamp(void);
-static __LIBC_PSPMPROCESS spmRegisterSelf(pid_t pid, pid_t pidParent);
+static __LIBC_PSPMPROCESS spmRegisterSelf(pid_t pid, pid_t pidParent, pid_t sid);
 static __LIBC_PSPMPROCESS spmAllocProcess(void);
 static void spmFreeProcess(__LIBC_PSPMPROCESS pProcess);
+static __LIBC_PSPMCHILDNOTIFY spmAllocChildNotify(void);
+static void spmFreeChildNotify(__LIBC_PSPMCHILDNOTIFY pNotify);
+static int spmSigQueueProcess(__LIBC_PSPMPROCESS pProcess, int iSignalNo, siginfo_t *pSigInfo, int fQueued, int fQueueAnyway);
+static __LIBC_PSPMSIGNAL spmAllocSignal(void);
+static void spmFreeSignal(__LIBC_PSPMSIGNAL pSig);
 static void *spmAlloc(size_t cbSize);
 static void *spmAllocSub(size_t cbSize);
@@ -170 +175 @@
          * Our selves.
          */
-        if (gpSPMSelf)
+        if (    gpSPMSelf
+            &&  gpSPMSelf->pTerm
+            &&  gpSPMSelf->pTerm->enmDeathReason == __LIBC_EXIT_REASON_NONE)
         {
             /* update exit code and reason. */
-            if (gpSPMSelf->iExitCode == 0)
-                gpSPMSelf->iExitCode = iExitCode;
-            if (gpSPMSelf->enmDeathReason == __LIBC_EXIT_REASON_NONE)
-                gpSPMSelf->enmDeathReason = enmDeathReason;
+            gpSPMSelf->pTerm->iExitCode = iExitCode;
+            gpSPMSelf->pTerm->enmDeathReason = enmDeathReason;
         }
 
@@ -191 +196 @@
 
 /**
- * Gets the exit code and reason of death for a specific child process
- * which is believed to have died.
+ * Query about notifications from a specific child process.
+ * The notifications are related to death, the cause and such.
  *
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
  * @param   pid                 Process id.
- * @param   pendDeathReason     Where to store the death reason.
- * @param   piExitCode          Where to store the exit code.
- */
-int __libc_spmReapChild(pid_t pid, __LIBC_EXIT_REASON *penmDeathReason, int *piExitCode)
-{
-    LIBCLOG_ENTER("pid=%#x (%d) penmDeathReason=%p piExitCode=%p\n", pid, pid, (void *)penmDeathReason, (void *)piExitCode);
+ * @param   pNotify             Where to store the notification from the child.
+ */
+int __libc_spmQueryChildNotification(pid_t pid, __LIBC_PSPMCHILDNOTIFY pNotifyOut)
+{
+    LIBCLOG_ENTER("pid=%#x (%d) pNotifyOut=%p\n", pid, pid, (void *)pNotifyOut);
     __LIBC_SPMXCPTREGREC    RegRec;
-    int                     iExitCode = 0;
-    __LIBC_EXIT_REASON      enmDeathReason = 0;
+    __LIBC_SPMCHILDNOTIFY   NotifyTmp = {0};
 
     /*
@@ -216 +219 @@
          * Try find the process, it gotta be a zombie.
          */
-        __LIBC_PSPMPROCESS pProcess = spmQueryProcessInState(pid, __LIBC_PROCSTATE_ZOMBIE);
-        if (pProcess)
-        {
-            iExitCode = pProcess->iExitCode;
-            enmDeathReason = pProcess->enmDeathReason;
-
-            /* reap it */
-            if (pProcess->cReferences > 0)
-                pProcess->cReferences--;
-            if (pProcess->cReferences <= 0)
-                spmFreeProcess(pProcess);
-        }
-        else
-            rc = -ESRCH;
+        rc = -ESRCH;
+        __LIBC_PSPMCHILDNOTIFY pPrev = NULL;
+        __LIBC_PSPMCHILDNOTIFY pNotify = gpSPMSelf->pChildNotifyHead;
+        while (pNotify)
+        {
+            if (pNotify->pid == pid)
+            {
+                /*
+                 * Copy the data to temporary storage.
+                 */
+                if (pNotify->cb >= sizeof(NotifyTmp))
+                    NotifyTmp = *pNotify;
+                else
+                    memcpy(&NotifyTmp, pNotify, pNotify->cb);
+                NotifyTmp.pNext = NULL;
+
+                /*
+                 * Unlink and free it.
+                 */
+                if (gpSPMSelf->ppChildNotifyTail == &pNotify->pNext)
+                {
+                    if (pPrev)
+                        gpSPMSelf->ppChildNotifyTail = &pPrev->pNext;
+                    else
+                        gpSPMSelf->ppChildNotifyTail = &gpSPMSelf->pChildNotifyHead;
+                    *gpSPMSelf->ppChildNotifyTail = NULL;
+                }
+                else
+                {
+                    if (pPrev)
+                        pPrev->pNext = pNotify->pNext;
+                    else
+                        gpSPMSelf->pChildNotifyHead = pNotify->pNext;
+                }
+
+                spmFreeChildNotify(pNotify);
+                rc = 0;
+                break;
+            }
+
+            /* next */
+            pPrev = pNotify;
+            pNotify = pNotify->pNext;
+        }
 
         /*
-         * We're done, free the mutex and store the results.
+         * We're done, release the mutex and store the results.
          */
         spmReleaseMutex(&RegRec);
-        *penmDeathReason = enmDeathReason;
-        *piExitCode = iExitCode;
+        *pNotify = NotifyTmp;
     }
 
@@ -274 +306 @@
 
     /*
-     * Check if we've already registered.
+     * Check if we've already registered (we're allways registred).
      * If we have we'll simply return.
      */
@@ -282 +314 @@
     {
         __LIBC_SPMXCPTREGREC    RegRec;
-        PTIB                    pTib;
-        PPIB                    pPib;
-        FS_VAR()
-        FS_SAVE_LOAD();
-        DosGetInfoBlocks(&pTib, &pPib);
         if (spmRequestMutexErrno(&RegRec))
             LIBCLOG_RETURN_P(NULL);
@@ -292 +319 @@
             pProcess = gpSPMSelf;
         else
-            pProcess = spmRegisterSelf(pPib->pib_ulpid, pPib->pib_ulppid);
+        {
+            PTIB                    pTib;
+            PPIB                    pPib;
+            PLINFOSEG               pLIS = GETLINFOSEG();
+            FS_VAR()
+            FS_SAVE_LOAD();
+            DosGetInfoBlocks(&pTib, &pPib);
+            pProcess = spmRegisterSelf(pPib->pib_ulpid, pPib->pib_ulppid, pLIS->sgCurrent);
+            FS_RESTORE();
+        }
         spmReleaseMutex(&RegRec);
-        FS_RESTORE();
     }
 
@@ -458 +493 @@
          * Initialize the new process block.
          */
-        pProcess->uVersion      = SPM_VERSION;
-        pProcess->cReferences   = 1;
-        pProcess->pid           = -1;
-        pProcess->pidParent     = pidParent;
-        pProcess->enmState      = __LIBC_PROCSTATE_EMBRYO;
-        pProcess->uTimestamp    = spmTimestamp();
-        pProcess->cPoolPointers = 2; /** @todo define for this! */
+        pProcess->uVersion          = SPM_VERSION;
+        pProcess->cReferences       = 1;
+        pProcess->enmState          = __LIBC_PROCSTATE_EMBRYO;
+        pProcess->pid               = -1;
+        pProcess->pidParent         = pidParent;
+        pProcess->uid               = gpSPMSelf->uid;
+        pProcess->euid              = gpSPMSelf->euid;
+        pProcess->svuid             = gpSPMSelf->svuid;
+        pProcess->gid               = gpSPMSelf->gid;
+        pProcess->egid              = gpSPMSelf->egid;
+        pProcess->svgid             = gpSPMSelf->svgid;
+        memcpy(&pProcess->agidGroups[0], &gpSPMSelf->agidGroups[0], sizeof(pProcess->agidGroups));
+        pProcess->uTimestamp        = spmTimestamp();
+        //pProcess->cSPMOpens         = 0;
+        pProcess->fExeInited        = 1;
+        //pProcess->uMiscReserved     = 0;
+        //pProcess->pvModuleHead      = NULL;
+        pProcess->ppvModuleTail     = &pProcess->pvModuleHead;
+        //pProcess->pvForkHandle      = NULL;
+        //pProcess->pSigHead          = NULL;
+        //pProcess->cSigsSent         = 0;
+        pProcess->sid               = gpSPMSelf->sid;
+        pProcess->pgrp              = gpSPMSelf->pgrp;
+        //pProcess->uSigReserved1     = 0; //gpSPMSelf->uSigReserved1;
+        //pProcess->uSigReserved2     = 0; //gpSPMSelf->uSigReserved2;
+        __LIBC_PSPMCHILDNOTIFY pTerm= spmAllocChildNotify();
+        if (pTerm)
+        {
+            pTerm->cb               = sizeof(*pTerm);
+            pTerm->enmDeathReason   = __LIBC_EXIT_REASON_NONE;
+            pTerm->iExitCode        = 0;
+            pTerm->pid              = -1;
+            pTerm->pNext            = NULL;
+            pProcess->pTerm         = pTerm;
+        }
+        //pProcess->pChildNotifyHead  = NULL;
+        pProcess->ppChildNotifyTail = &pProcess->pChildNotifyHead;
+        //pProcess->auReserved        = {0};
+        pProcess->cPoolPointers     = __LIBC_SPMPROCESS_POOLPOINTERS;
+        //pProcess->pInherit          = NULL;
+        //pProcess->pInheritLocked    = NULL;
 
         /* link into list. */
@@ -631 +700 @@
 
 /**
+ * Gets the specified Id.
+ *
+ * @returns Requested Id.
+ * @param   enmId       Identification to get.
+ */
+unsigned __libc_spmGetId(__LIBC_SPMID enmId)
+{
+    LIBCLOG_ENTER("enmId=%d\n", enmId);
+    __LIBC_SPMXCPTREGREC    RegRec;
+
+    /*
+     * Obtain semaphore.
+     */
+    int rc = spmRequestMutex(&RegRec);
+    if (!rc)
+        LIBCLOG_RETURN_INT(-1);
+
+    unsigned id;
+    switch (enmId)
+    {
+        case __LIBC_SPMID_PID:      id = gpSPMSelf->pid; break;
+        case __LIBC_SPMID_PPID:     id = gpSPMSelf->pidParent; break;
+        case __LIBC_SPMID_SID:      id = gpSPMSelf->sid; break;
+        case __LIBC_SPMID_PGRP:     id = gpSPMSelf->pgrp; break;
+        case __LIBC_SPMID_UID:      id = gpSPMSelf->uid; break;
+        case __LIBC_SPMID_EUID:     id = gpSPMSelf->euid; break;
+        case __LIBC_SPMID_SVUID:    id = gpSPMSelf->svuid; break;
+        case __LIBC_SPMID_GID:      id = gpSPMSelf->gid; break;
+        case __LIBC_SPMID_EGID:     id = gpSPMSelf->egid; break;
+        case __LIBC_SPMID_SVGID:    id = gpSPMSelf->svgid; break;
+        default:
+            id = -1;
+            break;
+    }
+
+    /*
+     * Done.
+     */
+    spmReleaseMutex(&RegRec);
+    LIBCLOG_RETURN_INT(id);
+}
+
+/**
+ * Sets the effective user id of the current process.
+ * If the caller is superuser real and saved user id are also set.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno) on failure.
+ * @param   uid         New effective user id.
+ *                      For superusers this is also the new real and saved user id.
+ */
+int __libc_spmSetUid(uid_t uid)
+{
+    LIBCLOG_ENTER("uid=%d (%#x)\n", uid, uid);
+    __LIBC_SPMXCPTREGREC    RegRec;
+
+    /*
+     * Obtain semaphore.
+     */
+    int rc = spmRequestMutex(&RegRec);
+    if (!rc)
+        LIBCLOG_RETURN_INT(rc);
+
+    /*
+     * Are we supervisor?
+     */
+    if (!gpSPMSelf->euid)
+    {
+        gpSPMSelf->uid = uid;
+        gpSPMSelf->euid = uid;
+        gpSPMSelf->svuid = uid;
+    }
+    else
+    {
+        if (uid == gpSPMSelf->uid || uid == gpSPMSelf->svuid)
+            gpSPMSelf->euid = uid;
+        else
+            rc = -EPERM;
+    }
+
+    /*
+     * Done.
+     */
+    spmReleaseMutex(&RegRec);
+    LIBCLOG_RETURN_INT(rc);
+}
+
+/**
+ * Sets the real, effective and saved user ids of the current process.
+ * Unprivilegde users can only set them to the real user id, the
+ * effective user id or the saved user id.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno) on failure.
+ * @param   ruid    New real user id. Ignore if -1.
+ * @param   euid    New effective user id. Ignore if -1.
+ * @param   svuid   New Saved user id. Ignore if -1.
+ */
+int __libc_spmSetUidAll(uid_t ruid, uid_t euid, uid_t svuid)
+{
+    LIBCLOG_ENTER("ruid=%d (%#x) euid=%d (%#x) svuid=%d (%#x)\n", ruid, ruid, euid, euid, svuid, svuid);
+    __LIBC_SPMXCPTREGREC    RegRec;
+
+    /*
+     * Obtain semaphore.
+     */
+    int rc = spmRequestMutex(&RegRec);
+    if (!rc)
+        LIBCLOG_RETURN_INT(rc);
+
+    /*
+     * Are we supervisor?
+     */
+    if (   !gpSPMSelf->euid
+        || (    ( ruid == -1 ||  ruid == gpSPMSelf->uid ||  ruid == gpSPMSelf->euid ||  ruid == gpSPMSelf->svuid)
+            &&  ( euid == -1 ||  euid == gpSPMSelf->uid ||  euid == gpSPMSelf->euid ||  euid == gpSPMSelf->svuid)
+            &&  (svuid == -1 || svuid == gpSPMSelf->uid || svuid == gpSPMSelf->euid || svuid == gpSPMSelf->svuid)))
+    {
+        if (ruid != -1)
+            gpSPMSelf->uid = ruid;
+        if (euid != -1)
+           gpSPMSelf->euid = euid;
+        if (svuid != -1)
+            gpSPMSelf->svuid = svuid;
+    }
+    else
+        rc = -EPERM;
+
+    /*
+     * Done.
+     */
+    spmReleaseMutex(&RegRec);
+    LIBCLOG_RETURN_INT(rc);
+}
+
+/**
+ * Sets the effective group id of the current process.
+ * If the caller is superuser real and saved group id are also set.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno) on failure.
+ */
+int __libc_spmSetGid(gid_t gid)
+{
+    LIBCLOG_ENTER("gid=%d (%#x)\n", gid, gid);
+    __LIBC_SPMXCPTREGREC    RegRec;
+
+    /*
+     * Obtain semaphore.
+     */
+    int rc = spmRequestMutex(&RegRec);
+    if (!rc)
+        LIBCLOG_RETURN_INT(rc);
+
+    /*
+     * Are we supervisor?
+     */
+    if (!gpSPMSelf->euid)
+    {
+        gpSPMSelf->gid = gid;
+        gpSPMSelf->egid = gid;
+        gpSPMSelf->svgid = gid;
+    }
+    else
+    {
+        if (gid == gpSPMSelf->gid || gid == gpSPMSelf->svgid)
+            gpSPMSelf->egid = gid;
+        else
+            rc = -EPERM;
+    }
+
+    /*
+     * Done.
+     */
+    spmReleaseMutex(&RegRec);
+    LIBCLOG_RETURN_INT(rc);
+}
+
+
+/**
+ * Sets the real, effective and saved group ids of the current process.
+ * Unprivilegde users can only set them to the real group id, the
+ * effective group id or the saved group id.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno) on failure.
+ * @param   rgid    New real group id. Ignore if -1.
+ * @param   egid    New effective group id. Ignore if -1.
+ * @param   svgid   New Saved group id. Ignore if -1.
+ */
+int __libc_spmSetGidAll(gid_t rgid, gid_t egid, gid_t svgid)
+{
+    LIBCLOG_ENTER("rgid=%d (%#x) egid=%d (%#x) svgid=%d (%#x)\n", rgid, rgid, egid, egid, svgid, svgid);
+    __LIBC_SPMXCPTREGREC    RegRec;
+
+    /*
+     * Obtain semaphore.
+     */
+    int rc = spmRequestMutex(&RegRec);
+    if (!rc)
+        LIBCLOG_RETURN_INT(rc);
+
+    /*
+     * Are we supervisor?
+     */
+    if (   !gpSPMSelf->euid
+        || (    ( rgid == -1 ||  rgid == gpSPMSelf->gid ||  rgid == gpSPMSelf->egid ||  rgid == gpSPMSelf->svgid)
+            &&  ( egid == -1 ||  egid == gpSPMSelf->gid ||  egid == gpSPMSelf->egid ||  egid == gpSPMSelf->svgid)
+            &&  (svgid == -1 || svgid == gpSPMSelf->gid || svgid == gpSPMSelf->egid || svgid == gpSPMSelf->svgid)))
+    {
+        if (rgid != -1)
+            gpSPMSelf->gid = rgid;
+        if (egid != -1)
+           gpSPMSelf->egid = egid;
+        if (svgid != -1)
+            gpSPMSelf->svgid = svgid;
+    }
+    else
+        rc = -EPERM;
+
+    /*
+     * Done.
+     */
+    spmReleaseMutex(&RegRec);
+    LIBCLOG_RETURN_INT(rc);
+}
+
+
+/**
  * Locks the LIBC shared memory for short exclusive access.
  * The call must call __libc_spmUnlock() as fast as possible and make
@@ -940 +1238 @@
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
- * @param   pSignal     Signal to queue.
+ */
+void    __libc_spmExeInited(void)
+{
+    __atomic_xchg(&gpSPMSelf->fExeInited, 1);
+}
+
+
+/**
+ * Queues a signal on another process.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   pSigInfo    Signal to queue.
  * @param   pid         Pid to queue it on.
  * @param   fQueued     Set if the signal type is queued.
  */
-void    __libc_spmExeInited(void)
-{
-    __atomic_xchg(&gpSPMSelf->fExeInited, 1);
-}
-
-
-/**
- * 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)
-{
-    LIBCLOG_ENTER("pSignal=%p:{.si_signo=%d,..} pid=%d fQueued=%d\n", (void *)pSignal, pSignal->si_signo, pid, fQueued);
+int     __libc_spmSigQueue(int iSignalNo, siginfo_t *pSigInfo, pid_t pid, int fQueued)
+{
+    LIBCLOG_ENTER("pSigInfo=%p:{.si_signo=%d,..} pid=%#x (%d) fQueued=%d\n", (void *)pSigInfo, pSigInfo->si_signo, pid, pid, fQueued);
 
     /*
@@ -967 +1262 @@
      * This is mostly because we wanna crash before we take the sem.
      */
-    if (pSignal->si_signo <= 0 || pSignal->si_signo > SIGRTMAX)
-    {
-        LIBC_ASSERTM_FAILED("Invalid signal number %d\n", pSignal->si_signo);
+    if (iSignalNo < 0 || iSignalNo > SIGRTMAX)
+    {
+        LIBC_ASSERTM_FAILED("Invalid signal number %d\n", pSigInfo->si_signo);
         LIBCLOG_RETURN_INT(-EINVAL);
     }
-    if (pSignal->auReserved[(sizeof(pSignal->auReserved) / sizeof(pSignal->auReserved[0])) - 1])
-    {
-        LIBC_ASSERTM_FAILED("Reserved field is not zero!\n");
-        LIBCLOG_RETURN_INT(-EINVAL);
+    if (pSigInfo)
+    {
+        if (pSigInfo->si_signo != iSignalNo)
+        {
+            LIBC_ASSERTM_FAILED("Signal Number doesn't match the signal info!\n");
+            LIBCLOG_RETURN_INT(-EINVAL);
+        }
+        if (pSigInfo->auReserved[(sizeof(pSigInfo->auReserved) / sizeof(pSigInfo->auReserved[0])) - 1])
+        {
+            LIBC_ASSERTM_FAILED("Reserved field is not zero!\n");
+            LIBCLOG_RETURN_INT(-EINVAL);
+        }
     }
 
@@ -991 +1294 @@
     __LIBC_PSPMPROCESS pProcess = spmQueryProcessInState(pid, __LIBC_PROCSTATE_ALIVE);
     if (pProcess && pProcess->fExeInited)
-    {
-        /*
-         * Check if already pending.
-         */
-        __LIBC_PSPMSIGNAL   pSig = NULL;
-        if (!fQueued)
-        {
-            pSig = pProcess->pSigHead;
-            int iSignal = pSignal->si_signo;
-            for (pSig = pProcess->pSigHead; pSig; pSig = pSig->pNext)
-                if (pSig->Info.si_signo == iSignal)
-                    break;
-        }
-        if (!pSig)
-        {
-            /*
-             * Check that we're not exceeding any per process or system limits.
-             */
-            if (    (   gpSPMHdr->cSigActive < gpSPMHdr->cSigMaxActive
-                     && gpSPMSelf->cSigsSent < _POSIX_SIGQUEUE_MAX)
-                || pSignal->si_signo == SIGCHLD)
+        rc = spmSigQueueProcess(pProcess, iSignalNo, pSigInfo, fQueued, 0);
+    else
+        rc = -ESRCH;
+
+    /*
+     * Release sem and be gone.
+     */
+    spmReleaseMutex(&RegRec);
+    LIBCLOG_RETURN_INT(rc);
+}
+
+/**
+ * Queues a signal on another process.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   iSignalNo   The signal to send. If 0 only permissions are checked.
+ * @param   pSigInfo     Signal to queue. If NULL only permissions are checked.
+ * @param   pgrp        Process group to queue a signal on.
+ * @param   fQueued     Set if the signal type is queued.
+ * @param   pfnCallback Pointer to callback function to post process signaled processes.
+ *                      The callback must be _very_ careful. No crashing or blocking!
+ * @param   pvUser      User argument specified to pfnCallback.
+ */
+int     __libc_spmSigQueuePGrp(int iSignalNo, siginfo_t *pSigInfo, pid_t pgrp, int fQueued, __LIBC_PFNSPMSIGNALED pfnCallback, void *pvUser)
+{
+    LIBCLOG_ENTER("iSignalNo=%d pSigInfo=%p:{.si_signo=%d,..} pgrp=%#x (%d) fQueued=%d pfnCallback=%p pvUser=%p\n",
+                  iSignalNo, (void *)pSigInfo, pSigInfo->si_signo, pgrp, pgrp, fQueued, (void *)pfnCallback, pvUser);
+
+    /*
+     * Validate intput.
+     * This is mostly because we wanna crash before we take the sem.
+     */
+    if (iSignalNo < 0 || iSignalNo > SIGRTMAX)
+    {
+        LIBC_ASSERTM_FAILED("Invalid signal number %d\n", pSigInfo->si_signo);
+        LIBCLOG_RETURN_INT(-EINVAL);
+    }
+    if (pSigInfo)
+    {
+        if (pSigInfo->si_signo != iSignalNo)
+        {
+            LIBC_ASSERTM_FAILED("Signal Number doesn't match the signal info!\n");
+            LIBCLOG_RETURN_INT(-EINVAL);
+        }
+        if (pSigInfo->auReserved[(sizeof(pSigInfo->auReserved) / sizeof(pSigInfo->auReserved[0])) - 1])
+        {
+            LIBC_ASSERTM_FAILED("Reserved field is not zero!\n");
+            LIBCLOG_RETURN_INT(-EINVAL);
+        }
+    }
+
+    /*
+     * Request sem.
+     */
+    __LIBC_SPMXCPTREGREC    RegRec;
+    int rc = spmRequestMutex(&RegRec);
+    if (rc)
+        LIBCLOG_RETURN_INT(rc);
+
+    /*
+     * Signal this process group?
+     */
+    if (!pgrp)
+        pgrp = gpSPMSelf->pgrp;
+    if (pgrp == gpSPMSelf->pgrp)
+        LIBCLOG_MSG("Signalling our own process group, %#x (%d).\n", pgrp, pgrp);
+
+    /*
+     * Enumerate all alive processes and process the processes in the specified group.
+     */
+    unsigned            cSent = 0;
+    __LIBC_PSPMPROCESS  pProcess = gpSPMHdr->apHeads[__LIBC_PROCSTATE_ALIVE];
+    for (; pProcess; pProcess = pProcess->pNext)
+    {
+        if (    pProcess->pgrp != pgrp
+            && !pProcess->fExeInited)
+        {
+            /* try queue the signal */
+            int rc2 = spmSigQueueProcess(pProcess, iSignalNo, pSigInfo, fQueued, 1 /* send anyway */);
+            if (!rc2)
             {
-                /*
-                 * Allocate a signal packet.
-                 */
-                if (gpSPMHdr->pSigFreeHead)
+                cSent++;
+                if (pfnCallback)
                 {
-                    __LIBC_PSPMSIGNAL pPrev = NULL;
-                    for (pSig = gpSPMHdr->pSigFreeHead; pSig; pPrev = pSig, pSig = pSig->pNext)
-                    {
-                        if (pSig->cb == sizeof(*pSig))
-                        {
-                            if (pPrev)
-                                pPrev->pNext = pSig->pNext;
-                            else
-                                gpSPMHdr->pSigFreeHead = pSig->pNext;
-                            gpSPMHdr->cSigFree--;
-                            break;
-                        }
-                    }
-                }
-                if (!pSig)
-                {
-                    pSig = spmAlloc(sizeof(*pSig));
-                    if (pSig)
-                        pSig->cb = sizeof(*pSig);
-                }
-
-                /*
-                 * Copy the data and insert it into the queue.
-                 */
-                if (pSig)
-                {
-                    pSig->pNext     = NULL;
-                    pSig->pidSender = gpSPMSelf->pid;
-                    pSig->Info      = *pSignal;
-                    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;
-                    else
-                    {
-                        __LIBC_PSPMSIGNAL pSigLast = pProcess->pSigHead;
-                        while (pSigLast->pNext)
-                            pSigLast = pSigLast->pNext;
-                        pSigLast->pNext = pSig;
-                    }
-
-                    /* update statistics */
-                    if (pProcess != gpSPMSelf)
-                        gpSPMSelf->cSigsSent++;
-                    gpSPMHdr->cSigActive++;
-                }
-                else
-                {
-                    LIBCLOG_MSG("Out of memory! Cannot allocate %d bytes for a signal packet!\n", sizeof(*pSig));
-                    rc = -EAGAIN;
+                    /* callback the caller. */
+                    rc2 = pfnCallback(iSignalNo, pProcess, pvUser);
+                    if (rc2 < 0 && !rc)
+                        rc = rc2;
                 }
             }
-            else
-            {
-                LIBCLOG_MSG("Limit reached: cSigActive=%d cSigMaxActive=%d cSigsSent=%d (max %d)\n",
-                            gpSPMHdr->cSigActive, gpSPMHdr->cSigMaxActive, pProcess->cSigsSent, _POSIX_SIGQUEUE_MAX);
-                rc = -EAGAIN;
-            }
-        }
-        else
-            LIBCLOG_MSG("Signal %d is already pending on pid %d. (ts=%x,pid=%d)\n",
-                        pSignal->si_signo, pid, pSig->Info.si_timestamp, pSig->Info.si_pid);
-    }
-    else
-        rc = -ESRCH;
+            else if (!rc)
+                rc = rc2;
+        }
+    } /* for each alive process. */
+
+    /*
+     * Adjust error codes.
+     */
+    if (!rc)
+    {
+        if (!cSent)
+            rc = -ESRCH;
+    }
+    else if (rc == -EPERM && cSent > 0)
+        rc = 0;
 
     /*
@@ -1094 +1407 @@
     LIBCLOG_RETURN_INT(rc);
 }
+
 
 /**
@@ -1216 +1530 @@
 
         /* free */
-        if (gpSPMHdr->cSigFree < 32)
-        {
-            pSig->pNext = gpSPMHdr->pSigFreeHead;
-            gpSPMHdr->pSigFreeHead = pSig;
-            gpSPMHdr->cSigFree++;
-        }
-        else
-            spmFree(pSig);
+        spmFreeSignal(pSig);
 
         /*
@@ -1236 +1543 @@
     LIBCLOG_RETURN_INT(rc);
 }
-
 
 
@@ -1322 +1628 @@
             DosGetInfoBlocks(&pTib, &pPib);
             gpSPMSelf = __libc_spmQueryProcessInState(pPib->pib_ulpid, __LIBC_PROCSTATE_ALIVE);
-            LIBC_ASSERTM(gpSPMSelf, "Couldn't find our self after fork - impossibled! pid=%ld ppid=%ld\n", pPib->pib_ulpid, pPib->pib_ulppid);
+            LIBC_ASSERTM(gpSPMSelf, "Couldn't find our self after fork - impossibled! pid=%lx (%ld) ppid=%lx (%ld)\n",
+                         pPib->pib_ulpid, pPib->pib_ulpid, pPib->pib_ulppid, pPib->pib_ulppid);
             LIBC_ASSERTM(gpSPMSelf->cReferences >= 2, "cReferences=%d!\n", gpSPMSelf->cReferences);
             gpSPMSelf->cReferences--;
@@ -1364 +1671 @@
  * stack available. If there isn't a crash is usually the
  * result.
+ * @internal
  */
 static int spmRequestMutexStackChecker(void)
 {
-    char *pch = alloca(2048);
+    char volatile *pch = alloca(2048);
     if (!pch)
         return -1;
@@ -1378 +1686 @@
  * Requests the shared mutex semphore and checks that we're
  * successfully initialized.
- * @internal
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
+ * @internal
  */
 static int spmRequestMutex(__LIBC_PSPMXCPTREGREC pRegRec)
@@ -1490 +1798 @@
 }
 
+#if 0 /* unused */
+/**
+ * Checks if the caller is the mutex owner.
+ * @returns 0 if not owner.
+ * @returns 1 if owner.
+ */
+static int spmIsMutexOwner(void)
+{
+    if (gcNesting != 1)
+        return 0;
+
+    PTIB pTib;
+    PPIB pPib;
+    DosGetInfoBlocks(&pTib, &pPib);
+    PID pid;
+    TID tid;
+    ULONG cNestings = 0;
+    int rc = DosQueryMutexSem(ghmtxSPM, &pid, &tid, &cNestings);
+    return !rc && pid == pPib->pib_ulpid && tid == pTib->tib_ptib2->tib2_ultid;
+}
+#endif /* unused */
 
 /**
@@ -1511 +1840 @@
      */
     LIBC_ASSERT(sizeof(*gpSPMHdr) < SPM_PROCESS_SIZE);
-    LIBC_ASSERT(offsetof(__LIBC_SPMHEADER, pTcpip) == 72);
-    LIBC_ASSERT(offsetof(__LIBC_SPMHEADER, cSigMaxActive) == 124);
+    LIBC_ASSERT(offsetof(__LIBC_SPMHEADER, pTcpip) == 56);
+    LIBC_ASSERT(offsetof(__LIBC_SPMHEADER, pChildNotifyFreeHead) == 52);
+    LIBC_ASSERT(offsetof(__LIBC_SPMHEADER, hevNotify) == 112);
+    LIBC_ASSERT(offsetof(__LIBC_SPMHEADER, cSigMaxActive) == 108);
     LIBC_ASSERT(offsetof(__LIBC_SPMPROCESS, cReferences) == 12);
-    LIBC_ASSERT(offsetof(__LIBC_SPMPROCESS, pvForkHandle) == 48);
-    LIBC_ASSERT(offsetof(__LIBC_SPMPROCESS, cPoolPointers) == 160);
-    LIBC_ASSERT(offsetof(__LIBC_SPMPROCESS, pInheritLocked) == 168);
+    LIBC_ASSERT(offsetof(__LIBC_SPMPROCESS, pvForkHandle) == 140);
+    LIBC_ASSERT(offsetof(__LIBC_SPMPROCESS, cPoolPointers) == 224);
+    LIBC_ASSERT(offsetof(__LIBC_SPMPROCESS, pInheritLocked) == 232);
 
     /*
@@ -1626 +1957 @@
                     gpSPMHdr->pSigFreeHead = pSignal;
                 }
+                /* Create notification semaphore. */
+                rc = DosCreateEventSem(NULL, &gpSPMHdr->hevNotify, DC_SEM_SHARED, FALSE);
+                LIBC_ASSERTM(!rc, "DosCreateEventSem rc=%d\n", rc);
+                rc = 0; /* ignore */
             }
         }
@@ -1635 +1970 @@
              * Register the current process and increment open counter.
              */
-            spmRegisterSelf(pPib->pib_ulpid, pPib->pib_ulppid);
+            PLINFOSEG pLIS = GETLINFOSEG();
+            spmRegisterSelf(pPib->pib_ulpid, pPib->pib_ulppid, pLIS->sgCurrent);
             if (gpSPMSelf)
                 gpSPMSelf->cSPMOpens++;
@@ -1751 +2087 @@
         {
             /* sanity */
-            LIBC_ASSERTM(pProcess->enmState == __LIBC_PROCSTATE_EMBRYO, "Found non embryo process in embryo list! enmState=%d pid=%d\n",
-                         pProcess->enmState, pProcess->pid);
-            LIBC_ASSERTM(pProcess->cReferences <= 1, "Invalid reference count of a process in the embryo list! cReferences=%d pid=%d\n",
-                         pProcess->cReferences, pProcess->pid);
+            LIBC_ASSERTM(pProcess->enmState == __LIBC_PROCSTATE_EMBRYO, "Found non embryo process in embryo list! enmState=%d pid=%#x (%d)\n",
+                         pProcess->enmState, pProcess->pid, pProcess->pid);
+            LIBC_ASSERTM(pProcess->cReferences <= 1, "Invalid reference count of a process in the embryo list! cReferences=%d pid=%#x (%d)\n",
+                         pProcess->cReferences, pProcess->pid, pProcess->pid);
 
             /* our child? */
@@ -1792 +2128 @@
                 pProcess->cSPMOpens--;
 
+            /*
+             * if we have a child termination notification structure we'll
+             * send that to the parent (if we have one).
+             */
+            __LIBC_PSPMCHILDNOTIFY pTerm = pProcess->pTerm;
+            if (pTerm)
+            {
+                __LIBC_PSPMPROCESS pParent = spmQueryProcessInState(pProcess->pidParent, __LIBC_PROCSTATE_ALIVE);
+                if (pParent)
+                {
+                    *pParent->ppChildNotifyTail = pTerm;
+                    pParent->ppChildNotifyTail = &pTerm->pNext;
+                    pTerm->pNext = NULL;
+                    DosPostEventSem(gpSPMHdr->hevNotify);
+                }
+                else
+                    spmFreeChildNotify(pTerm);
+                pProcess->pTerm = NULL;
+            }
+
             /* free our selves or become a zombie. */
             spmZombieOrFree(pProcess);
@@ -1839 +2195 @@
     else if (pProcess->enmState != __LIBC_PROCSTATE_ZOMBIE)
     {
-        LIBCLOG_MSG("Making process %p a zombie (pid=%04x pidParent=%04x cReferences=%d enmState=%d)\n",
-                    (void *)pProcess, pProcess->pid, pProcess->pidParent, pProcess->cReferences, pProcess->enmState);
-
-        /* free data a zombie won't be needing. */
+        LIBCLOG_MSG("Making process %p a zombie (pid=%#x (%d) pidParent=%#x (%d) cReferences=%d enmState=%d)\n",
+                    (void *)pProcess, pProcess->pid, pProcess->pid, pProcess->pidParent, pProcess->pidParent,
+                    pProcess->cReferences, pProcess->enmState);
+
+        /*
+         * Free data a zombie won't be needing.
+         */
+        /* inherited data */
         if (pProcess->pInherit)
         {
             spmFree(pProcess->pInherit);
             pProcess->pInherit = NULL;
+        }
+
+        /* signals */
+        __LIBC_PSPMSIGNAL pSig = pProcess->pSigHead;
+        pProcess->pSigHead = NULL;
+        while (pSig)
+        {
+            __LIBC_PSPMSIGNAL pFree = pSig;
+            pSig = pSig->pNext;
+            spmFreeSignal(pFree);
+        }
+
+        /* child notifications. */
+        __LIBC_PSPMCHILDNOTIFY pNotify = pProcess->pChildNotifyHead;
+        pProcess->pChildNotifyHead = NULL;
+        while (pNotify)
+        {
+            __LIBC_PSPMCHILDNOTIFY pFree = pNotify;
+            pNotify = pNotify->pNext;
+            spmFreeChildNotify(pFree);
         }
 
@@ -1881 +2261 @@
 static __LIBC_PSPMPROCESS spmQueryProcessInState(pid_t pid, __LIBC_SPMPROCSTAT enmState)
 {
-    LIBCLOG_ENTER("pid=%d enmState=%d\n", pid, enmState);
+    LIBCLOG_ENTER("pid=%#x (%d) enmState=%d\n", pid, pid, enmState);
     __LIBC_PSPMPROCESS      pProcess;
 
@@ -1923 +2303 @@
  * @param   pid         Pid of this process.
  * @param   pidParent   Pid of parent process.
- */
-static __LIBC_PSPMPROCESS spmRegisterSelf(pid_t pid, pid_t pidParent)
-{
-    LIBCLOG_ENTER("pid=%d pidParent=%d\n", pid, pidParent);
+ * @param   sid         Session Id.
+ */
+static __LIBC_PSPMPROCESS spmRegisterSelf(pid_t pid, pid_t pidParent, pid_t sid)
+{
+    LIBCLOG_ENTER("pid=%#x (%d) pidParent=%#x (%d) sid=%#x (%d)\n", pid, pid, pidParent, pidParent, sid, sid);
     __LIBC_PSPMPROCESS pProcess;
     __LIBC_PSPMPROCESS pProcessBest;
@@ -1944 +2325 @@
         LIBC_ASSERTM((uintptr_t)pProcess - (uintptr_t)gpSPMHdr < gpSPMHdr->cb,
                      "Invalid pointer %p in EMBRYO list\n", (void *)pProcess);
-        LIBC_ASSERTM(pProcess->enmState == __LIBC_PROCSTATE_EMBRYO, "Found non embryo process in embryo list! enmState=%d pid=%d\n",
-                     pProcess->enmState, pProcess->pid);
-        LIBC_ASSERTM(pProcess->cReferences <= 1, "Invalid reference count of a process in the embryo list! cReferences=%d pid=%d\n",
-                     pProcess->cReferences, pProcess->pid);
+        LIBC_ASSERTM(pProcess->enmState == __LIBC_PROCSTATE_EMBRYO, "Found non embryo process in embryo list! enmState=%d pid=%#x (%d)\n",
+                     pProcess->enmState, pProcess->pid, pProcess->pid);
+        LIBC_ASSERTM(pProcess->cReferences <= 1, "Invalid reference count of a process in the embryo list! cReferences=%d pid=%#x (%d)\n",
+                     pProcess->cReferences, pProcess->pid, pProcess->pid);
 
         /* our daddy? daddy updated it with our pid? */
@@ -1967 +2348 @@
             ||  pProcess->pNext == pProcess)
         {
-            LIBC_ASSERTM(pProcess->pNext != gpSPMHdr->apHeads[__LIBC_PROCSTATE_EMBRYO], "Circular list! pid=%d\n", pProcess->pid);
-            LIBC_ASSERTM(pProcess->pNext != pProcess, "Circular list with self! pid=%d\n", pProcess->pid);
+            LIBC_ASSERTM(pProcess->pNext != gpSPMHdr->apHeads[__LIBC_PROCSTATE_EMBRYO], "Circular list! pid=%#x (%d)\n", pProcess->pid, pProcess->pid);
+            LIBC_ASSERTM(pProcess->pNext != pProcess, "Circular list with self! pid=%#x (%d)\n", pProcess->pid, pProcess->pid);
             pProcess->pNext = NULL;
         }
@@ -1976 +2357 @@
     {
         pProcess = pProcessBest;
-        LIBCLOG_MSG("Found my embryo %p (pidParent=%04x pid=%04x cReferences=%d uTimestamp=%04x)\n",
+        LIBCLOG_MSG("Found my embryo %p (pidParent=%#x pid=%#x cReferences=%d uTimestamp=%04x)\n",
                     (void *)pProcess, pProcess->pidParent, pProcess->pid, pProcess->cReferences, pProcess->uTimestamp);
 
@@ -1982 +2363 @@
         pProcess->cReferences++;
         pProcess->pid = pid;
-
-        /* link out. */
+        pProcess->sid = sid;
+
+        /* unlink. */
         if (pProcess->pNext)
             pProcess->pNext->pPrev = pProcess->pPrev;
@@ -2013 +2395 @@
         LIBC_ASSERTM((uintptr_t)pProcess - (uintptr_t)gpSPMHdr < gpSPMHdr->cb,
                      "Invalid pointer %p in ALIVE list\n", (void *)pProcess);
-        LIBC_ASSERTM(pProcess->enmState == __LIBC_PROCSTATE_ALIVE, "Found non alive process in alive list! enmState=%d pid=%d\n",
-                     pProcess->enmState, pProcess->pid);
-
-        /* is this me? */
+        LIBC_ASSERTM(pProcess->enmState == __LIBC_PROCSTATE_ALIVE, "Found non alive process in alive list! enmState=%d pid=%#x (%d)\n",
+                     pProcess->enmState, pProcess->pid, pProcess->pid);
+
+        /* is this really me? */
         if (    pProcess->pid == pid
             &&  pProcess->pidParent == pidParent)
@@ -2032 +2414 @@
             ||  pProcess->pNext == pProcess)
         {
-            LIBC_ASSERTM(pProcess->pNext != gpSPMHdr->apHeads[__LIBC_PROCSTATE_ALIVE], "Circular list! pid=%d\n", pProcess->pid);
-            LIBC_ASSERTM(pProcess->pNext != pProcess, "Circular list with self! pid=%d\n", pProcess->pid);
+            LIBC_ASSERTM(pProcess->pNext != gpSPMHdr->apHeads[__LIBC_PROCSTATE_ALIVE], "Circular list! pid=%#x (%d)\n", pProcess->pid, pProcess->pid);
+            LIBC_ASSERTM(pProcess->pNext != pProcess, "Circular list with self! pid=%#x (%d)\n", pProcess->pid, pProcess->pid);
             pProcess->pNext = NULL;
         }
@@ -2047 +2429 @@
          * Initialize the new process block.
          */
-        pProcess->uVersion      = SPM_VERSION;
-        pProcess->cReferences   = 1;
-        pProcess->pid           = pid;
-        pProcess->pidParent     = pidParent;
-        pProcess->enmState      = __LIBC_PROCSTATE_ALIVE;
-        pProcess->uTimestamp    = spmTimestamp();
-        pProcess->cPoolPointers = 2; /** @todo define for this! */
+        pProcess->uVersion          = SPM_VERSION;
+        pProcess->cReferences       = 1;
+        pProcess->enmState          = __LIBC_PROCSTATE_EMBRYO;
+        pProcess->pid               = pid;
+        pProcess->pidParent         = pidParent;
+        //pProcess->uid               = 0;
+        //pProcess->euid              = 0;
+        //pProcess->svuid             = 0;
+        //pProcess->gid               = 0;
+        //pProcess->egid              = 0;
+        //pProcess->svgid             = 0;
+        //bzero(&pProcess->agidGroups[0], sizeof(pProcess->agidGroups));
+        pProcess->uTimestamp        = spmTimestamp();
+        //pProcess->cSPMOpens         = 0;
+        pProcess->fExeInited        = 1;
+        //pProcess->uMiscReserved     = 0;
+        //pProcess->pvModuleHead      = NULL;
+        pProcess->ppvModuleTail     = &pProcess->pvModuleHead;
+        //pProcess->pvForkHandle      = NULL;
+        //pProcess->pSigHead          = NULL;
+        //pProcess->cSigsSent         = 0;
+        pProcess->sid               = sid;
+        pProcess->pgrp              = pid;
+        //pProcess->uSigReserved1     = 0; //gpSPMSelf->uSigReserved1;
+        //pProcess->uSigReserved2     = 0; //gpSPMSelf->uSigReserved2;
+        __LIBC_PSPMCHILDNOTIFY pTerm= spmAllocChildNotify();
+        if (pTerm)
+        {
+            pTerm->cb               = sizeof(*pTerm);
+            pTerm->enmDeathReason   = __LIBC_EXIT_REASON_NONE;
+            pTerm->iExitCode        = 0;
+            pTerm->pid              = pid;
+            pTerm->pNext            = NULL;
+            pProcess->pTerm         = pTerm;
+        }
+        //pProcess->pChildNotifyHead  = NULL;
+        pProcess->ppChildNotifyTail = &pProcess->pChildNotifyHead;
+        //pProcess->auReserved        = {0};
+        pProcess->cPoolPointers     = __LIBC_SPMPROCESS_POOLPOINTERS;
+        //pProcess->pInherit          = NULL;
+        //pProcess->pInheritLocked    = NULL;
 
         /* link into list. */
@@ -2107 +2523 @@
             else
                 gpSPMHdr->apHeads[__LIBC_PROCSTATE_ZOMBIE] = NULL;
-            LIBCLOG_MSG("Reaping zombie %p (pid=%04x pidParent=%04x cRefrences=%d)\n",
+            LIBCLOG_MSG("Reaping zombie %p (pid=%#x pidParent=%#x cRefrences=%d)\n",
                         (void *)pProcess, pProcess->pid, pProcess->pidParent, pProcess->cReferences);
         }
@@ -2124 +2540 @@
 static void spmFreeProcess(__LIBC_PSPMPROCESS pProcess)
 {
-    LIBCLOG_ENTER("pProcess=%p:{pid=%04x pidParent=%04x cReferences=%d enmState=%d pvForkHandle=%p pNext=%p pPrev=%p}\n",
+    LIBCLOG_ENTER("pProcess=%p:{pid=%#x pidParent=%#x cReferences=%d enmState=%d pvForkHandle=%p pNext=%p pPrev=%p}\n",
                   (void *)pProcess, pProcess->pid, pProcess->pidParent, pProcess->cReferences, pProcess->enmState,
                   pProcess->pvForkHandle, (void *)pProcess->pNext, (void *)pProcess->pPrev);
+    /*
+     * Free signals.
+     */
+    __LIBC_PSPMSIGNAL pSig = pProcess->pSigHead;
+    pProcess->pSigHead = NULL;
+    while (pSig)
+    {
+        __LIBC_PSPMSIGNAL pFree = pSig;
+        pSig = pSig->pNext;
+        spmFreeSignal(pFree);
+    }
+
+    /*
+     * Free child notifications.
+     */
+    __LIBC_PSPMCHILDNOTIFY pNotify = pProcess->pChildNotifyHead;
+    pProcess->pChildNotifyHead = NULL;
+    while (pNotify)
+    {
+        __LIBC_PSPMCHILDNOTIFY pFree = pNotify;
+        pNotify = pNotify->pNext;
+        spmFreeChildNotify(pFree);
+    }
 
     /*
@@ -2168 +2607 @@
 
 /**
+ * Allocate a suicide note, erm, child termination notification.
+ *
+ * @returns Pointer to allocated notifcation struct. The cb member is filled in.
+ * @returns NULL on failure.
+ */
+static __LIBC_PSPMCHILDNOTIFY spmAllocChildNotify(void)
+{
+    LIBCLOG_ENTER("\n");
+
+    /*
+     * Search the free list for a node of matching size.
+     */
+    __LIBC_PSPMCHILDNOTIFY pPrev = NULL;
+    __LIBC_PSPMCHILDNOTIFY pNotify = gpSPMHdr->pChildNotifyFreeHead;
+    while (pNotify)
+    {
+        if (pNotify->cb == sizeof(*pNotify))
+        {
+            /* unlink and return. */
+            if (pPrev)
+                pPrev->pNext = pNotify->pNext;
+            else
+                gpSPMHdr->pChildNotifyFreeHead = pNotify->pNext;
+            pNotify->pNext = NULL;
+            LIBCLOG_RETURN_P(pNotify);
+        }
+    }
+
+    /*
+     * Restore to allocating one from the pool.
+     */
+    pNotify = spmAlloc(sizeof(*pNotify));
+    if (pNotify)
+    {
+        pNotify->pNext = NULL;
+        pNotify->cb = sizeof(*pNotify);
+    }
+
+    LIBCLOG_RETURN_P(pNotify);
+}
+
+
+/**
+ * Free a child (termination) notification.
+ *
+ * @param pNotify       The notification structure to free.
+ */
+static void spmFreeChildNotify(__LIBC_PSPMCHILDNOTIFY pNotify)
+{
+    LIBCLOG_ENTER("pNotify=%p\n", (void *)pNotify);
+    pNotify->pNext = gpSPMHdr->pChildNotifyFreeHead;
+    gpSPMHdr->pChildNotifyFreeHead = pNotify;
+    LIBCLOG_RETURN_VOID();
+}
+
+
+/**
+ * Queues a signal on a process.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   pProcess        Process to queue the signal on.
+ * @param   iSignalNo       Signal to send. If 0 only permission checks are performed.
+ * @param   pSigInfo         Signal to queue. If NULL only permission checks are performed.
+ * @param   fQueued         Set if the signal type is queued.
+ * @param   fQueueAnyway    If set the normal signal limits are bypassed.
+ */
+static int spmSigQueueProcess(__LIBC_PSPMPROCESS pProcess, int iSignalNo, siginfo_t *pSigInfo, int fQueued, int fQueueAnyway)
+{
+    LIBCLOG_ENTER("pProcess=%p {.pid=%#x, .pgrp=%#x, .sid=%#x,...} iSignalNo=%d pSigInfo=%p fQueue=%d fQueueAnyway=%d\n",
+                  (void *)pProcess, pProcess->pid, pProcess->pgrp, pProcess->sid, iSignalNo, (void *)pSigInfo, fQueued, fQueueAnyway);
+
+    /*
+     * Check permissions.
+     * (This is close, but not quite it.)
+     */
+    if (    pProcess != gpSPMSelf                                                   /* our selves are ok. */
+        &&  pProcess->euid != 0                                                     /* Root can do anything. */
+        &&  (iSignalNo != SIGCONT || pProcess->sid != gpSPMSelf->sid)               /* SIGCONT to everyone in the session. */
+        &&  pProcess->uid != gpSPMSelf->euid && pProcess->svuid != gpSPMSelf->euid  /* Same as our efficient uid is ok. */
+        &&  pProcess->uid != gpSPMSelf->uid  && pProcess->svuid != gpSPMSelf->uid   /* Same as our uid is ok. */
+        )
+        return -EPERM;
+
+    /* This could be a permission check call, if so, we're done now. */
+    if (!pSigInfo || !iSignalNo)
+        return 0;
+
+    /*
+     * Check if already pending.
+     */
+    __LIBC_PSPMSIGNAL   pSig = NULL;
+    if (!fQueued)
+    {
+        pSig = pProcess->pSigHead;
+        int iSignal = pSigInfo->si_signo;
+        for (pSig = pProcess->pSigHead; pSig; pSig = pSig->pNext)
+            if (pSig->Info.si_signo == iSignal)
+                break;
+    }
+    int rc = 0;
+    if (!pSig)
+    {
+        /*
+         * Check that we're not exceeding any per process or system limits (unless told to do so).
+         */
+        if (    (   gpSPMHdr->cSigActive < gpSPMHdr->cSigMaxActive
+                 && gpSPMSelf->cSigsSent < _POSIX_SIGQUEUE_MAX)
+            || fQueueAnyway
+            || pSigInfo->si_signo == SIGCHLD)
+        {
+            /*
+             * Allocate a signal packet.
+             */
+            pSig = spmAllocSignal();
+            if (pSig)
+            {
+                /*
+                 * Copy the data and insert it into the queue.
+                 */
+                pSig->pNext     = NULL;
+                pSig->pidSender = gpSPMSelf->pid;
+                pSig->Info      = *pSigInfo;
+                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;
+                else
+                {
+                    __LIBC_PSPMSIGNAL pSigLast = pProcess->pSigHead;
+                    while (pSigLast->pNext)
+                        pSigLast = pSigLast->pNext;
+                    pSigLast->pNext = pSig;
+                }
+
+                /* update statistics */
+                if (pProcess != gpSPMSelf)
+                    gpSPMSelf->cSigsSent++;
+                gpSPMHdr->cSigActive++;
+            }
+            else
+            {
+                LIBCLOG_MSG("Out of memory! Cannot allocate %d bytes for a signal packet!\n", sizeof(*pSig));
+                rc = -EAGAIN;
+            }
+        }
+        else
+        {
+            LIBCLOG_MSG("Limit reached: cSigActive=%d cSigMaxActive=%d cSigsSent=%d (max %d)\n",
+                        gpSPMHdr->cSigActive, gpSPMHdr->cSigMaxActive, pProcess->cSigsSent, _POSIX_SIGQUEUE_MAX);
+            rc = -EAGAIN;
+        }
+    }
+    else
+        LIBCLOG_MSG("Signal %d is already pending on pid %#x (%d). (ts=%x,pid=%#x (%d))\n",
+                    pSigInfo->si_signo, pProcess->pid, pProcess->pid, pSig->Info.si_timestamp, pSig->Info.si_pid, pSig->Info.si_pid);
+    return rc;
+}
+
+
+/**
+ * Allocates a signal structure.
+ *
+ * @returns Pointer to allocated signal structure.
+ * @returns NULL on failure.
+ */
+static __LIBC_PSPMSIGNAL spmAllocSignal(void)
+{
+    LIBCLOG_ENTER("\n");
+
+    /*
+     * Old structures.
+     */
+    __LIBC_PSPMSIGNAL pSig;
+    if (gpSPMHdr->pSigFreeHead)
+    {
+        __LIBC_PSPMSIGNAL pPrev = NULL;
+        for (pSig = gpSPMHdr->pSigFreeHead; pSig; pPrev = pSig, pSig = pSig->pNext)
+        {
+            if (pSig->cb == sizeof(*pSig))
+            {
+                if (pPrev)
+                    pPrev->pNext = pSig->pNext;
+                else
+                    gpSPMHdr->pSigFreeHead = pSig->pNext;
+                gpSPMHdr->cSigFree--;
+                LIBCLOG_RETURN_P(pSig);
+            }
+        }
+    }
+
+    /*
+     * New structure.
+     */
+    pSig = spmAlloc(sizeof(*pSig));
+    if (pSig)
+        pSig->cb = sizeof(*pSig);
+
+    LIBCLOG_RETURN_P(pSig);
+}
+
+
+/**
+ * Frees a signal
+ *
+ * @param   pSig        Signal structure to free.
+ */
+static void spmFreeSignal(__LIBC_PSPMSIGNAL pSig)
+{
+    LIBCLOG_ENTER("pSig=%p\n", (void *)pSig);
+    if (gpSPMHdr->cSigFree < 32)
+    {
+        pSig->pNext = gpSPMHdr->pSigFreeHead;
+        gpSPMHdr->pSigFreeHead = pSig;
+        gpSPMHdr->cSigFree++;
+    }
+    else
+        spmFree(pSig);
+    LIBCLOG_RETURN_VOID();
+}
+
+
+/**
  * Allocate memory in SPM pool of given size.
  *
@@ -2207 +2873 @@
 
         /*
-         * Free embryos which are more than 15 seconds old.
+         * Free embryos which are more than 5 min old.
          */
         uTimestamp = spmTimestamp();
@@ -2219 +2885 @@
                 SPM_ASSERT_PTR_NULL(pProcess->pPrev);
                 if (    pProcess->cReferences == 0
-                    &&  uTimestamp - pProcess->uTimestamp >= 15*1000)
+                    &&  uTimestamp - pProcess->uTimestamp >= 5*60*1000)
                 {
                     __LIBC_PSPMPROCESS      pProcessNext = pProcess->pNext;
-                    LIBCLOG_MSG("Reaping embryo %p pidParent=%04x pid=%08x pForkHandle=%p uTimestamp=%08x (now=%08x) pNext=%p pPrev=%p\n",
+                    LIBCLOG_MSG("Reaping embryo %p pidParent=%#x pid=%#x pForkHandle=%p uTimestamp=%08x (now=%08x) pNext=%p pPrev=%p\n",
                                 (void *)pProcess, pProcess->pidParent, pProcess->pid, pProcess->pvForkHandle, pProcess->uTimestamp, uTimestamp,
                                 (void *)pProcess->pNext, (void *)pProcess->pPrev);
@@ -2245 +2911 @@
             LIBC_ASSERTM(pProcess->enmState == __LIBC_PROCSTATE_FREE, "enmState=%d pProcess=%p\n",
                          pProcess->enmState, (void *)pProcess);
-            LIBCLOG_MSG("Reaping free process %p (pid=%04x pidParent=%04x)\n",
+            LIBCLOG_MSG("Reaping free process %p (pid=%#x pidParent=%#x)\n",
                         (void *)pProcess, pProcess->pid, pProcess->pidParent);
 
@@ -2258 +2924 @@
 
         /*
-         * Free up inherit data of processes which have been around for more than 15 seconds.
+         * Free up inherit data of processes which have been around for more than 5 min.
          */
         for (pProcess = gpSPMHdr->apHeads[__LIBC_PROCSTATE_ALIVE]; pProcess; pProcess = pProcess->pNext)
@@ -2266 +2932 @@
             SPM_ASSERT_PTR_NULL(pProcess->pPrev);
             if (    pProcess->pInherit
-                &&  uTimestamp - pProcess->uTimestamp >= 15*1000)
+                &&  uTimestamp - pProcess->uTimestamp >= 5*60*1000)
             {
                 void *pv = (void *)__atomic_xchg((unsigned *)(void *)&gpSPMSelf->pInherit, 0);
-                LIBCLOG_MSG("Reaping inherit data (%p) of process %p (pid=%04x pidParent=%04x)\n",
+                LIBCLOG_MSG("Reaping inherit data (%p) of process %p (pid=%#x pidParent=%#x)\n",
                             pv, (void *)pProcess, pProcess->pid, pProcess->pidParent);
                 spmFree(pv);
             }
+        }
+
+        /*
+         * Free up termination structures.
+         */
+        __LIBC_PSPMCHILDNOTIFY pNotify;
+        for (pNotify = gpSPMHdr->pChildNotifyFreeHead; pNotify;)
+        {
+            LIBCLOG_MSG("Reaping notification record %p (cb=%d pid=%#x iExitCode=%d enmDeathReason=%d)\n",
+                        (void *)pNotify, pNotify->cb, pNotify->pid, pNotify->iExitCode, pNotify->enmDeathReason);
+            __LIBC_PSPMCHILDNOTIFY pFree = pNotify;
+            pNotify = pNotify->pNext;
+            pFree->pNext = NULL;
+            spmFree(pFree);
         }
 
@@ -2279 +2959 @@
          */
         pv = spmAllocSub(cbSize);
+        if (!pv)
+        {
+            LIBCLOG_MSG("SPM IS *STILL* LOW ON MEMORY!!! cbFree=%d cb=%d (cbSize=%d)\n", gpSPMHdr->cbFree, gpSPMHdr->cb, cbSize);
+
+            /*
+             * Free embryos which are more than 15 seconds old.
+             */
+            uTimestamp = spmTimestamp();
+            pProcess = gpSPMHdr->apHeads[__LIBC_PROCSTATE_EMBRYO];
+            if (pProcess)
+            {
+                do
+                {
+                    SPM_ASSERT_PTR_NULL(pProcess);
+                    SPM_ASSERT_PTR_NULL(pProcess->pNext);
+                    SPM_ASSERT_PTR_NULL(pProcess->pPrev);
+                    if (    pProcess->cReferences == 0
+                        &&  uTimestamp - pProcess->uTimestamp >= 15*1000)
+                    {
+                        __LIBC_PSPMPROCESS      pProcessNext = pProcess->pNext;
+                        LIBCLOG_MSG("Reaping embryo %p pidParent=%#x pid=%#x pForkHandle=%p uTimestamp=%08x (now=%08x) pNext=%p pPrev=%p\n",
+                                    (void *)pProcess, pProcess->pidParent, pProcess->pid, pProcess->pvForkHandle, pProcess->uTimestamp, uTimestamp,
+                                    (void *)pProcess->pNext, (void *)pProcess->pPrev);
+                        spmFreeProcess(pProcess);
+                        pProcess = pProcessNext;
+                        continue;
+                    }
+
+                    /* next */
+                    pProcess = pProcess->pNext;
+                } while (pProcess);
+            }
+
+            /*
+             * Free up inherit data of processes which have been around for more than 15 seconds.
+             */
+            for (pProcess = gpSPMHdr->apHeads[__LIBC_PROCSTATE_ALIVE]; pProcess; pProcess = pProcess->pNext)
+            {
+                SPM_ASSERT_PTR_NULL(pProcess);
+                SPM_ASSERT_PTR_NULL(pProcess->pNext);
+                SPM_ASSERT_PTR_NULL(pProcess->pPrev);
+                if (    pProcess->pInherit
+                    &&  uTimestamp - pProcess->uTimestamp >= 15*1000)
+                {
+                    void *pv = (void *)__atomic_xchg((unsigned *)(void *)&gpSPMSelf->pInherit, 0);
+                    LIBCLOG_MSG("Reaping inherit data (%p) of process %p (pid=%#x pidParent=%#x)\n",
+                                pv, (void *)pProcess, pProcess->pid, pProcess->pidParent);
+                    spmFree(pv);
+                }
+            }
+
+            /*
+             * Free preallocated signals.
+             */
+            while (gpSPMHdr->cSigFree > 4 && gpSPMHdr->pSigFreeHead)
+            {
+                __LIBC_PSPMSIGNAL pSig = gpSPMHdr->pSigFreeHead;
+                gpSPMHdr->pSigFreeHead = pSig->pNext;
+                gpSPMHdr->cSigFree--;
+                pSig->pNext = NULL;
+                spmFree(pSig);
+            }
+        }
     }
 
@@ -2668 +3411 @@
         LIBCLOG_REL("SPM Exception! Owner of the mutex!\n");
     else
-        LIBCLOG_REL("SPM Exception! Not owner of the mutex! owner: tid=%ld pid=%ld cNesting=%ld\n", tid, pid, cNesting);
+        LIBCLOG_REL("SPM Exception! Not owner of the mutex! owner: tid=%lx (%ld) pid=%lx (%ld) cNesting=%ld\n",
+                    tid, tid, pid, pid, cNesting);
 
     /*
@@ -2775 +3519 @@
         /* check head backpointer. */
         if (SPM_VALID_PTR(gpSPMHdr->apHeads[i]) && gpSPMHdr->apHeads[i]->pPrev)
-            CHECK_FAILED("Invalid list head in list %i. pPrev != NULL. pPrev=%p pProcess=%p pid=%#06x\n",
+            CHECK_FAILED("Invalid list head in list %i. pPrev != NULL. pPrev=%p pProcess=%p pid=%#x\n",
                          i, (void *)gpSPMHdr->apHeads[i]->pPrev, (void *)gpSPMHdr->apHeads[i], gpSPMHdr->apHeads[i]->pid);
 
@@ -2789 +3533 @@
                 break;
             CHECK_LOG("pProcess=%08x enmState=%d cReferences=%d pid=%#06x pidParent=%#06x pInherit=%08x cSPMOpens=%d pNext=%08x pPrev=%08x\n",
-                            (uintptr_t)pProcess, pProcess->enmState, pProcess->cReferences, pProcess->pid, pProcess->pidParent,
-                            (uintptr_t)pProcess->pInherit, pProcess->cSPMOpens, (uintptr_t)pProcess->pNext, (uintptr_t)pProcess->pPrev);
+                      (uintptr_t)pProcess, pProcess->enmState, pProcess->cReferences, pProcess->pid, pProcess->pidParent,
+                      (uintptr_t)pProcess->pInherit, pProcess->cSPMOpens, (uintptr_t)pProcess->pNext, (uintptr_t)pProcess->pPrev);
 
             sprintf(sz, "i=%d pid=%#06x\n", i, pProcess->pid);

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

@@ -556 +556 @@
 static int              signalJobStop(int iSignalNo);
 static int              signalJobResume(void);
+static int              signalSendPGrpCallback(int iSignalNo, const __LIBC_SPMPROCESS *pProcess, void *pvUser);
 static int              signalActionWorker(__LIBC_PTHREAD pCur, void *pvParam);
 static unsigned         signalTimestamp(void);
@@ -911 +912 @@
  * @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)
@@ -1319 +1318 @@
                         /* Shit! We failed to queue it on a thread. Try put it back in the 1st level queue. */
                         LIBCLOG_MSG("failed to schedule signal %d for any thread!\n", iSignalNo);
-                        __libc_spmSigQueue(&SigInfo, _sys_pid, !!(SigInfo.si_flags & __LIBC_SI_QUEUED));
+                        __libc_spmSigQueue(SigInfo.si_signo, &SigInfo, _sys_pid, !!(SigInfo.si_flags & __LIBC_SI_QUEUED));
                         break;
                     }
@@ -2134 +2133 @@
  * @param   pSigInfo    Signal info (optional).
  */
-int __libc_back_signalSendPidOther(pid_t pid, int iSignalNo, siginfo_t *pSigInfo)
+int __libc_back_signalSendPidOther(pid_t pid, int iSignalNo, const siginfo_t *pSigInfo)
 {
     LIBCLOG_ENTER("pid=%d iSignalNo=%d pSigInfo=%p\n", pid, iSignalNo, (void *)pSigInfo);
@@ -2142 +2141 @@
 
     /*
-     * Send the signal.
-     */
-    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;
-        }
-    }
-
-    /*
-     * Try flag the process.
-     *
-     * If the target is a LIBC process we'll queue a signal on it and poke it.
-     * If not we'll convert the signal to EMX and flag it in the EMX compatible way.
+     * Attempt queue it assuming it's a LIBC process first.
+     * If not a LIBC process (rc is -ESRCH) we'll use alternative
+     * methods. First resorting to OS/2 signal exceptions and the to EMX signals.
      */
     siginfo_t SigInfo = {0};
@@ -2213 +2159 @@
         SigInfo.si_flags   |= __LIBC_SI_QUEUED;
 
-    rc = __libc_spmSigQueue(&SigInfo, pid, SigInfo.si_flags & __LIBC_SI_QUEUED);
+    rc = __libc_spmSigQueue(iSignalNo, &SigInfo, pid, SigInfo.si_flags & __LIBC_SI_QUEUED);
     if (!rc)
     {
+        if (!iSignalNo)
+            LIBCLOG_RETURN_MSG(0, "0 (LIBC permission check ok)\n");
+
         /* poke it... */
         FS_SAVE_LOAD();
@@ -2231 +2180 @@
     {
         /*
+         * Check that the process exists first.
+         */
+        FS_SAVE_LOAD();
+        rc = DosVerifyPidTid(pid, 1);
+        FS_RESTORE();
+        if (rc)
+            LIBCLOG_RETURN_MSG(-ESRCH, "%d (-ESRCH) DosVerifyPidTid(%d, 1) -> %d\n", -ESRCH, pid, rc);
+        if (!iSignalNo)
+            LIBCLOG_RETURN_MSG(0, "0 (OS/2 permission check ok)\n");
+
+        /*
+         * 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:                  rc = 0; break;
+                    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;
+        }
+
+        /*
          * EMX style signal.
-         * Doesn't work for all types of signals.
+         *
+         * Doesn't work for all types of signals and only if process is EMX.
+         * The latter we cannot easily check...
          */
         unsigned uSignalEMX = 0;
@@ -2278 +2282 @@
 
     /*
-     * Check for DosFlagProcess errors.
+     * Check for DosFlagProcess error.
      */
     if (!rc)
@@ -2285 +2289 @@
     LIBCLOG_RETURN_INT(rc);
 }
+
+/**
+ * Sends a signal to a process group.
+ *
+ * Special case for iSignalNo equal to 0, where no signal is sent but permissions to
+ * do so is checked.
+ *
+ * @returns 0 on if signal sent.
+ * @returns -errno on failure.
+ *
+ * @param   pgrp        Process group (positive).
+ *                      0 means the process group of this process.
+ *                      1 means all process in the system. (not implemented!)
+ * @param   iSignalNo   Signal to send to all the processes in the group.
+ *                      If 0 no signal is sent, but error handling is done as if.
+ */
+int         __libc_Back_signalSendPGrp(pid_t pgrp, int iSignalNo)
+{
+    LIBCLOG_ENTER("pgrp=%#x (%d) iSignalNo=%d\n", pgrp, pgrp, iSignalNo);
+    int     rc;
+
+    /*
+     * Validate input.
+     */
+    if (!__SIGSET_SIG_VALID(iSignalNo) && iSignalNo != 0)
+    {
+        LIBC_ASSERTM_FAILED("Invalid signal no. %d\n", iSignalNo);
+        LIBCLOG_RETURN_INT(-EINVAL);
+    }
+    if (pgrp < 0 || pgrp == 1)
+    {
+        LIBC_ASSERTM_FAILED("Invalid pgrp %d\n", pgrp);
+        LIBCLOG_RETURN_INT(-EINVAL);
+    }
+
+    /*
+     * Create signal packet.
+     */
+    siginfo_t SigInfo = {0};
+    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;
+    if (SigInfo.si_timestamp)
+        SigInfo.si_timestamp= signalTimestamp();
+    if (gafSignalProperties[iSignalNo] & SPP_QUEUED)
+        SigInfo.si_flags   |= __LIBC_SI_QUEUED;
+
+    /*
+     * Take the signal semaphore.
+     */
+    rc = __libc_back_signalSemRequest();
+    if (rc)
+        LIBCLOG_RETURN_INT(rc);
+
+    /*
+     * Call SPM to do the enumeration and queueing.
+     */
+    rc = __libc_spmSigQueuePGrp(iSignalNo, &SigInfo, pgrp, SigInfo.si_flags & __LIBC_SI_QUEUED, signalSendPGrpCallback, NULL);
+
+    __libc_back_signalSemRelease();
+    LIBCLOG_RETURN_INT(rc);
+}
+
+
+/**
+ * Callback for poking a process which was signaled as part of a group signaling.
+ * @returns 0 on success.
+ */
+static int signalSendPGrpCallback(int iSignalNo, const __LIBC_SPMPROCESS *pProcess, void *pvUser)
+{
+    LIBCLOG_ENTER("iSignalNo=%d pProcess=%p {pid=%#x} pvUser=%p\n", iSignalNo, (void *)pProcess, pProcess->pid, pvUser);
+    if (!iSignalNo)
+        LIBCLOG_RETURN_MSG(0, "0 (LIBC permission check ok)\n");
+
+    /* poke it... */
+    FS_VAR();
+    FS_SAVE_LOAD();
+    int rc = DosFlagProcess(pProcess->pid, FLGP_PID, PFLG_A, 0);
+    if (rc == ERROR_SIGNAL_REFUSED)
+    {
+        /* Try again... no sure what would cause this condition... */
+        DosSleep(0);
+        DosSleep(1);
+        rc = DosFlagProcess(pProcess->pid, FLGP_PID, PFLG_A, 0);
+    }
+    FS_RESTORE();
+    if (!rc)
+        LIBCLOG_RETURN_INT(0);
+    rc = -__libc_native2errno(rc);
+    LIBCLOG_RETURN_INT(rc);
+}
+
 
 

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

@@ -53 +53 @@
 int         __libc_back_signalAccept(__LIBC_PTHREAD pThrd, int iSignalNo, sigset_t *pSigSet, siginfo_t *pSigInfo);
 int         __libc_back_signalWait(__LIBC_PTHREAD pThrd, volatile int *pfDone, const struct timespec *pTimeout);
-int         __libc_back_signalSendPidOther(pid_t pid, int iSignalNo, siginfo_t *pSigInfo);
+int         __libc_back_signalSendPidOther(pid_t pid, int iSignalNo, const siginfo_t *pSigInfo);
 int         __libc_back_signalAction(int iSignalNo, const struct sigaction *pSigAct, struct sigaction *pSigActOld);
 int         __libc_back_signalRaisePoked(void *pvXcptParams, int tidPoker);