Changeset 1489

Timestamp:

Sep 11, 2004, 10:49:10 AM (21 years ago)

Author:

bird

Message:

Fixed fork and improoved a bit on spawn and spm.

Location:

trunk/src/emx/src/lib/sys

Files:

• __initdll.c (modified) (2 diffs, 1 prop)
• __spawnve.c (modified) (2 diffs, 1 prop)
• libcfork.c (modified) (3 diffs, 1 prop)

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

@@ -252 +252 @@
 
 /**
- * Fork callback which updates the thread structure in the child.
+ * Fork callback which updates the thread structure in the child
+ * and the global pid & parent pid values.
  *
  * @returns 0 on success.
@@ -270 +271 @@
                         (*__libc_gpTLS)->cDefLoggerDepth - 2);
             (*__libc_gpTLS)->cDefLoggerDepth -= 2;
+            _sys_pid = pForkHandle->pidChild;
+            _sys_ppid = pForkHandle->pidParent;
             rc = 0;
             break;

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

@@ -78 +78 @@
         { \
           errno = ENOMEM; \
-          return -1; \
+          LIBCLOG_RETURN_INT(-1); \
         } \
       arg_ptr = arg_buf + arg_size; \
@@ -87 +87 @@
 int __spawnve (struct _new_proc *np)
 {
-  LIBCLOG_ENTER("np=%p:{mode=%#x}\n", (void *)np, np->mode);
-  int   rc;
-  ULONG exec_flag, mode;
-  RESULTCODES res;
-  char obj[40], *arg_ptr, *arg_buf;
-  char *pgm_name, *base;
-  const char *src, *s;
-  size_t arg_size, arg_alloc, len;
-  int i, quote, bs, method;
-  __LIBC_PSPMPROCESS    pEmbryo;
-  FS_VAR();
-
-  arg_buf = NULL; arg_alloc = 0; arg_size = 0; arg_ptr = NULL;
-
-  mode = np->mode;
-  switch (mode & 0xff)
-    {
-    case P_WAIT:
-      exec_flag = EXEC_SYNC;
-      break;
-    case P_NOWAIT:
-      exec_flag = EXEC_ASYNCRESULT;
-      break;
-    case P_OVERLAY:
-      exec_flag = EXEC_ASYNC;
-      break;
-    default:
-      errno = EINVAL;
-      LIBCLOG_RETURN_INT(-1);
-    }
-  pgm_name = alloca (strlen ((const char *)np->fname_off) + 5);
-  strcpy (pgm_name, (const char *)np->fname_off);
-  _defext (pgm_name, "exe");
-  base = _getname (pgm_name);
-  method = 0;
-  if (stricmp (base, "cmd.exe") == 0 || stricmp (base, "4os2.exe") == 0)
-    method = 1;
-  src = (const char *)np->arg_off;
-  if (np->arg_count > 0)
-    {
-      ++src;                    /* skip flags byte */
-      len = strlen (src) + 1;
-      ADD (len);
-      memcpy (arg_ptr, src, len);
-      arg_ptr += len; src += len;
-    }
-  for (i = 1; i < np->arg_count; ++i)
-    {
-      if (i > 1)
-        {
-          ADD (1);
-          *arg_ptr++ = ' ';
-        }
-      ++src;                    /* skip flags byte */
-      quote = FALSE;
-      if (*src == 0)
-        quote = TRUE;
-      else if (mode & P_QUOTE)
-        {
-          if (src[0] == '@' && src[1] != 0)
+    LIBCLOG_ENTER("np=%p:{mode=%#x}\n", (void *)np, np->mode);
+    __LIBC_PSPMPROCESS    pEmbryo;
+    ULONG                 mode;
+    char *arg_ptr, *arg_buf;
+    char *pgm_name, *base;
+    const char *src, *s;
+    size_t arg_size, arg_alloc, len;
+    int i, quote, bs, method;
+    FS_VAR();
+
+    arg_buf = NULL; arg_alloc = 0; arg_size = 0; arg_ptr = NULL;
+
+    /*
+     * Validate mode.
+     */
+    mode = np->mode;
+    switch (mode & 0xff)
+    {
+        case P_WAIT:
+        case P_NOWAIT:
+        case P_OVERLAY:
+            break;
+        default:
+            errno = EINVAL;
+            LIBC_ASSERTM_FAILED("invalid mode 0x%08lx\n", mode);
+            LIBCLOG_RETURN_INT(-1);
+    }
+
+    /*
+     * Allocate space for the program name and check if it's an OS/2 shell.
+     */
+    pgm_name = alloca (strlen ((const char *)np->fname_off) + 5);
+    strcpy (pgm_name, (const char *)np->fname_off);
+    _defext (pgm_name, "exe");
+    base = _getname (pgm_name);
+    method = 0;
+    if (stricmp (base, "cmd.exe") == 0 || stricmp (base, "4os2.exe") == 0)
+        method = 1;
+
+    /*
+     * Process arguments.
+     */
+    src = (const char *)np->arg_off;
+    if (np->arg_count > 0)
+    {
+        ++src;                    /* skip flags byte */
+        len = strlen (src) + 1;
+        ADD (len);
+        memcpy (arg_ptr, src, len);
+        arg_ptr += len; src += len;
+    }
+    for (i = 1; i < np->arg_count; ++i)
+    {
+        if (i > 1)
+        {
+            ADD (1);
+            *arg_ptr++ = ' ';
+        }
+        ++src;                    /* skip flags byte */
+        quote = FALSE;
+        if (*src == 0)
             quote = TRUE;
-          else
+        else if (mode & P_QUOTE)
+        {
+            if (src[0] == '@' && src[1] != 0)
+                quote = TRUE;
+            else
+                for (s = src; *s != 0; ++s)
+                    if (*s == '?' || *s == '*')
+                    {
+                        quote = TRUE;
+                        break;
+                    }
+        }
+        if (!quote)
             for (s = src; *s != 0; ++s)
-              if (*s == '?' || *s == '*')
+                if (*s == ' ' || *s == '\t' || (*s == '"' && method == 1))
                 {
-                  quote = TRUE;
-                  break;
+                    quote = TRUE;
+                    break;
                 }
-        }
-      if (!quote)
-        for (s = src; *s != 0; ++s)
-          if (*s == ' ' || *s == '\t' || (*s == '"' && method == 1))
+        if (quote)
+        {
+            ADD (1);
+            *arg_ptr++ = '"';
+        }
+        bs = 0;
+        while (*src != 0)
+        {
+            if (*src == '"' && method == 0)
             {
-              quote = TRUE;
-              break;
+                ++bs;
+                ADD (bs);
+                memset (arg_ptr, '\\', bs); arg_ptr += bs;
+                bs = 0;
             }
-      if (quote)
-        {
-          ADD (1);
-          *arg_ptr++ = '"';
-        }
-      bs = 0;
-      while (*src != 0)
-        {
-          if (*src == '"' && method == 0)
+            else if (*src == '\\' && method == 0)
+                ++bs;
+            else
+                bs = 0;
+            ADD (1);
+            *arg_ptr++ = *src;
+            ++src;
+        }
+        if (quote)
+        {
+            ADD (1+bs);
+            memset (arg_ptr, '\\', bs); arg_ptr += bs;
+            *arg_ptr++ = '"';
+        }
+        ++src;
+    }
+    /* The arguments are an array of zero terminated strings, ending with an empty string. */
+    ADD (2);
+    *arg_ptr++ = '\0';
+    *arg_ptr++ = '\0';
+
+
+    /*
+     * Now create an embryo process.
+     */
+    _fmutex_request(&__libc_gmtxExec, 0);
+    pEmbryo = __libc_spmCreateEmbryo(getpid());
+    if (pEmbryo)
+    {
+        /*
+         * Do inheritance stuff.
+         */
+        pEmbryo->pInherit = doInherit();
+        if (pEmbryo->pInherit)
+        {
+            RESULTCODES resc;
+            char        szObj[40];
+            int         rc;
+
+            /*
+             * Create the process.
+             */
+            FS_SAVE_LOAD();
+            LIBCLOG_MSG("Calling DosExecPgm pgm: %s args: %s\\0%s\\0\\0\n", pgm_name, arg_buf, arg_buf + strlen(arg_buf) + 1);
+            rc = DosExecPgm(szObj, sizeof(szObj), EXEC_ASYNCRESULT, (PCSZ)arg_buf, (PCSZ)np->env_off, &resc, (PCSZ)pgm_name);
+            FS_RESTORE();
+            if (!rc)
             {
-              ++bs;
-              ADD (bs);
-              memset (arg_ptr, '\\', bs); arg_ptr += bs;
-              bs = 0;
+                __atomic_cmpxchg32((volatile uint32_t *)(void *)&pEmbryo->pid, (uint32_t)resc.codeTerminate, 0);
+                LIBCLOG_MSG("Spawned pid=%04lx (%ld)\n", resc.codeTerminate, resc.codeTerminate);
+
+                /* cleanup embryo and other stuff. */
+                __libc_spmRelease(pEmbryo);
+                doInheritDone();
+                if (arg_buf != NULL)
+                    _tfree (arg_buf);
+                _fmutex_release(&__libc_gmtxExec);
+
+                /*
+                 * Exit depends on the mode.
+                 */
+                switch (mode & 0xff)
+                {
+                    /*
+                     * Return the pid.
+                     */
+                    case P_NOWAIT:
+                        LIBCLOG_RETURN_INT((int)resc.codeTerminate);
+
+                        /*
+                         * Wait for the child and return the result.
+                         */
+                    case P_WAIT:
+                        /*
+                         * Wait for the child and exit this process with the same result.
+                         */
+                    case P_OVERLAY:
+                    {
+                        PID pid = resc.codeTerminate;
+                        PID pidEnded = 0;
+                        FS_SAVE_LOAD();
+                        LIBCLOG_MSG("Calling DosWaitChild(,,,,0x%04lx)\n", pid);
+                        rc = DosWaitChild(DCWA_PROCESS, DCWW_WAIT, &resc, &pidEnded, pid);
+                        if (!rc)
+                        {
+                            LIBCLOG_MSG("DosWaitChild(,,,,0x%04lx) returned pidEnded=0x%04lx resc.codeTerminate=%ld resc.codeResult=%ld\n",
+                                        pid, pidEnded, resc.codeTerminate, resc.codeResult);
+                            LIBC_ASSERTM(pidEnded == pid, "Expected pid 0x%04lx and got 0x%04lx!\n", pid, pidEnded);
+
+                            if (mode == P_OVERLAY)
+                            {
+                                LIBCLOG_MSG("Calling DosExit(,0)\n");
+                                while (pid == pidEnded)
+                                    DosExit(EXIT_PROCESS, resc.codeResult);
+                            }
+
+                            LIBCLOG_RETURN_INT((int)resc.codeResult);
+                        }
+
+                        LIBC_ASSERTM_FAILED("Calling DosWaitChild(,,,,0x%04lx) -> rc=%d\n", pid, rc);
+                        _sys_set_errno(rc);
+                        LIBCLOG_RETURN_INT(-1);
+                    }
+
+                        /* this can _NEVER_ happen! */
+                    default:
+                        errno = EINVAL;
+                        LIBCLOG_RETURN_INT(-1);
+                }
+                /* won't ever get here! */
             }
-          else if (*src == '\\' && method == 0)
-            ++bs;
-          else
-            bs = 0;
-          ADD (1);
-          *arg_ptr++ = *src;
-          ++src;
-        }
-      if (quote)
-        {
-          ADD (1+bs);
-          memset (arg_ptr, '\\', bs); arg_ptr += bs;
-          *arg_ptr++ = '"';
-        }
-      ++src;
-    }
-  /* The arguments are an array of zero terminated strings, ending with an empty string. */
-  ADD (2);
-  *arg_ptr++ = '\0';
-  *arg_ptr++ = '\0';
-
-  _fmutex_request(&__libc_gmtxExec, 0);
-
-  /*
-   * Now create an embryo process.
-   */
-  pEmbryo = __libc_spmCreateEmbryo(getpid());
-  if (pEmbryo)
-  {
-      /*
-       * Do inheritance stuff.
-       */
-      pEmbryo->pInherit = doInherit();
-      if (pEmbryo->pInherit)
-      {
-          /*
-           * Create the process.
-           */
-          FS_SAVE_LOAD();
-          rc = DosExecPgm (obj, sizeof (obj), exec_flag, (PCSZ)arg_buf, (PCSZ)np->env_off, &res, (PCSZ)pgm_name);
-          FS_RESTORE();
-          if (!rc)
-          {
-              if (exec_flag == EXEC_ASYNCRESULT || exec_flag == EXEC_ASYNC)
-              {
-                  __atomic_cmpxchg32((volatile uint32_t *)(void *)&pEmbryo->pid, (uint32_t)res.codeTerminate, 0);
-                  LIBCLOG_MSG("Spawned pid=%04lx (%ld)\n", res.codeTerminate, res.codeTerminate);
-              }
-
-              /* cleanup embryo and other stuff. */
-              __libc_spmRelease(pEmbryo);
-              doInheritDone();
-              if (arg_buf != NULL)
-                  _tfree (arg_buf);
-              _fmutex_release(&__libc_gmtxExec);
-
-              /* exit depends on the mode. */
-              switch (mode & 0xff)
-                {
-                case P_WAIT:
-                  LIBCLOG_RETURN_INT((int)res.codeResult);
-                case P_NOWAIT:
-                  LIBCLOG_RETURN_INT((int)res.codeTerminate);
-                case P_OVERLAY:
-                  FS_SAVE_LOAD();
-                #if 1 /* hack... */
-                {
-                  PID pid = res.codeTerminate;
-                  for (;;)
-                  {
-                      PID   pidEnded = 0;
-                      LIBCLOG_MSG("Calling DosWaitChild(,,,,0x%04lx)\n", pid);
-                      rc = DosWaitChild(DCWA_PROCESS, DCWW_WAIT, &res, &pidEnded, pid);
-                      if (rc)
-                      {
-                          LIBCLOG_MSG("Calling DosWaitChild(,,,,0x%04lx) -> rc=%d\n", pid, rc);
-                          break;
-                      }
-                      LIBCLOG_MSG("Calling DosWaitChild(,,,,0x%04lx) pidEnded=0x%04lx res.codeTerminate=%ld res.codeResult=%ld\n",
-                                  pid, pidEnded, res.codeTerminate, res.codeResult);
-                      while (pid == pidEnded)
-                          DosExit(EXIT_PROCESS, res.codeResult);
-                  }
-                }
-                #endif
-                  LIBCLOG_MSG("Calling DosExit(,0)\n");
-                  while (1)
-                    DosExit (EXIT_PROCESS, 0);
-                default:
-                  errno = EINVAL;
-                  LIBCLOG_RETURN_INT(-1);
-                }
-              /* won't ever get here! */
-          }
-          else
-            _sys_set_errno (rc);
-          doInheritDone();
-      }
-      /* cleanup embryo */
-      __libc_spmRelease(pEmbryo);
-  }
-
-  if (arg_buf != NULL)
-    _tfree (arg_buf);
-  _fmutex_release(&__libc_gmtxExec);
-  LIBCLOG_RETURN_INT(-1);
+            else
+                _sys_set_errno (rc);
+            doInheritDone();
+        }
+        /* cleanup embryo */
+        __libc_spmRelease(pEmbryo);
+    }
+
+    if (arg_buf != NULL)
+        _tfree (arg_buf);
+    _fmutex_release(&__libc_gmtxExec);
+    LIBCLOG_RETURN_INT(-1);
 }

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

@@ -187 +187 @@
         static char szMsg[] = "LIBC Error: Couldn't register process in shared memory!\r\n";
         ULONG       ul;
-        LIBC_ASSERTM_FAILED("couldn't find self process!\n");
+        LIBC_ASSERTM_FAILED("couldn't register process!\n");
 
         DosWrite(2, szMsg, sizeof(szMsg), &ul);
@@ -212 +212 @@
         pProcess->pvModuleHead = pModule;
     pProcess->ppvModuleTail = (void **)&pModule->pNext;
+
+
+#if 0
+    /*
+     * Debug checks.
+     */
+    static char sz[] = "forking\0forking\0";
+    PPIB pPib;
+    PTIB pTib;
+    DosGetInfoBlocks(&pTib, &pPib);
+    if (!memcmp(pPib->pib_pchcmd, sz, sizeof(sz)))
+    {
+        LIBC_ASSERTM(pProcess->pvForkHandle, "fork arguments, no fork handle!!! process %p\n", pProcess);
+        if (!pProcess->pvForkHandle)
+            __libc_SpmCheck(0, 1);
+    }
+    else
+    {
+        LIBC_ASSERTM(!pProcess->pvForkHandle, "no fork arguments, fork handle!!! process %p handle %p\n", pProcess, pProcess->pvForkHandle);
+        if (pProcess->pvForkHandle)
+            __libc_SpmCheck(0, 1);
+    }
+#endif
 
     /*
@@ -745 +768 @@
         char        szErr[64];
         RESULTCODES rsc = {0,0};
+        #if 1
         rc = DosExecPgm(szErr, sizeof(szErr), EXEC_ASYNCRESULT, (PCSZ)pPib->pib_pchcmd, NULL, &rsc, (PCSZ)&szPgm[0]);
+        #else /* debugging checks */
+        rc = DosExecPgm(szErr, sizeof(szErr), EXEC_ASYNCRESULT, (PCSZ)"forking\0forking\0", NULL, &rsc, (PCSZ)&szPgm[0]);
+        #endif
         if (!rc)
         {