Changeset 3373 for trunk

Timestamp:

May 27, 2007, 1:03:27 PM (18 years ago)

Author:

bird

Message:

Wait for spawned/execed child so it can finish inherting us. Close file handles on exec. Fixes #168.Fixes #167.

Location:

trunk/libc/src/kNIX

Files:

• filehandles.c (modified) (1 diff)
• os2/__spawnve.c (modified) (2 diffs)
• os2/b_processWait.c (modified) (1 diff)
• os2/kNIX-os2.h (modified) (1 diff)
• os2/sharedpm.c (modified) (1 diff)
• os2/syscalls.h (modified) (1 diff)

trunk/libc/src/kNIX/filehandles.c

@@ -560 +560 @@
 
 
+/**
+ * Called as a response to a successful exec so we can close
+ * all open files.
+ */
+void        __libc_fhExecDone(void)
+{
+    LIBCLOG_ENTER("");
+
+    /*
+     * This isn't thread safe, but there shouldn't be any threads
+     * around so it'll have to do for now.
+     */
+    unsigned iFH;
+    for (iFH = 0; iFH < gcFHs; iFH++)
+    {
+        __LIBC_PFH pFH = gpapFHs[iFH];
+        if (pFH)
+            __libc_FHClose(iFH);
+    }
+
+    LIBCLOG_RETURN_VOID();
+}
+
+
 
 #undef  __LIBC_LOG_GROUP

trunk/libc/src/kNIX/os2/__spawnve.c

@@ -517 +517 @@
                 __atomic_cmpxchg32((volatile uint32_t *)(void *)&pEmbryo->pid, (uint32_t)resc.codeTerminate, ~0);
                 LIBCLOG_MSG("Spawned pid=%04lx (%ld)\n", resc.codeTerminate, resc.codeTerminate);
-                __libc_back_processWaitNotifyExec(resc.codeTerminate);
-
-                /* cleanup embryo and other stuff. */
-                __libc_spmRelease(pEmbryo);
-                doInheritDone();
+
+                /*
+                 * If the service is running, notify it now. Otherwise wait until
+                 * we're done waiting for the child finish inheriting us.
+                 */
+                int fDoneNotifyExec = __libc_back_processWaitNotifyAlreadyStarted();
+                if (fDoneNotifyExec)
+                    __libc_back_processWaitNotifyExec(resc.codeTerminate);
+
+                /*
+                 * Delay a tiny bit while the child is starting up and doing the inheriting.
+                 * If we figure that it's a libc child, we can wait a good deal longer.
+                 */
+                /** @todo add a SPM notification for when inherit is completed. */
+                __LIBC_SPMLOADAVG LoadAvg;
+                unsigned uLoadAvgTS;
+                int fDoneInherit;
+                ULONG ulStart = fibGetMsCount();
+                rc = 0;
+                while (     (fDoneInherit = pEmbryo->enmState > __LIBC_PROCSTATE_ALIVE
+                                         || (pEmbryo->pInherit == NULL && pEmbryo->pInheritLocked == NULL)
+                            ) == 0
+                       &&   fibGetMsCount() - ulStart <= 8)
+                {
+                    DosSleep(!(rc++ % 7));
+                    __libc_spmGetLoadAvg(&LoadAvg, &uLoadAvgTS); /* SMP HACK */
+                }
+                if (    !fDoneInherit
+                    &&  pEmbryo->enmState == __LIBC_PROCSTATE_ALIVE)
+                {
+                    LIBCLOG_MSG("libc child - wait some more (rc=%d)\n", rc);
+                    rc = 0;
+                    __libc_spmGetLoadAvg(&LoadAvg, &uLoadAvgTS); /* SMP HACK */
+                    while (     (fDoneInherit = pEmbryo->enmState > __LIBC_PROCSTATE_ALIVE
+                                             || (pEmbryo->pInherit == NULL && pEmbryo->pInheritLocked == NULL)
+                                ) == 0
+                           &&   fibGetMsCount() - ulStart <= 100)
+                    {
+                        DosSleep(!(rc++ % 7));
+                        __libc_spmGetLoadAvg(&LoadAvg, &uLoadAvgTS); /* SMP HACK */
+                    }
+                }
+                LIBCLOG_MSG("fDoneInherit=%d rc=%d enmState=%d inh=%p,%p - waited %d ms\n",
+                            fDoneInherit, rc, pEmbryo->enmState, pEmbryo->pInherit, pEmbryo->pInheritLocked, fibGetMsCount() - ulStart);
+
+                /*
+                 * Do cleanups unless we're in an exec in which case we wish to
+                 * get some more stuff done before we do the clean ups.
+                 */
+                if ((ulMode & 0xff) != P_OVERLAY)
+                {
+                    doInheritDone();
+                    if (!fDoneNotifyExec)
+                        __libc_back_processWaitNotifyExec(resc.codeTerminate);
+                    __libc_spmRelease(pEmbryo);
+                    _fmutex_release(&__libc_gmtxExec);
+                }
                 if (pszArgsBuf != NULL)
                     _tfree(pszArgsBuf);
-                _fmutex_release(&__libc_gmtxExec);
 
                 /*
@@ -575 +626 @@
 
                         /*
-                         * Wait
+                         * Wait a bit more for the child to catch on since we're going to
+                         * close all file handles next and that we certainly screw up tcpip
+                         * handles in the child if they aren't already passed along.
+                         */
+                        if (!fDoneInherit)
+                        {
+                            LIBCLOG_MSG("waiting some more...\n");
+                            do
+                            {
+                                DosSleep(!(rc++ % 3));
+                                __libc_spmGetLoadAvg(&LoadAvg, &uLoadAvgTS); /* SMP HACK */
+                                fDoneInherit = pEmbryo->enmState > __LIBC_PROCSTATE_ALIVE
+                                            || (pEmbryo->pInherit == NULL && pEmbryo->pInheritLocked == NULL);
+                            } while (!fDoneInherit
+                                  && fibGetMsCount() - ulStart <= 200);
+                            LIBCLOG_MSG("fDoneInherit=%d rc=%d enmState=%d inh=%p,%p - waited %d ms\n",
+                                        fDoneInherit, rc, pEmbryo->enmState, pEmbryo->pInherit, pEmbryo->pInheritLocked, fibGetMsCount() - ulStart);
+                        }
+
+                        if (!fDoneNotifyExec)
+                            __libc_back_processWaitNotifyExec(resc.codeTerminate);
+                        __libc_spmRelease(pEmbryo);
+                        doInheritDone();
+                        _fmutex_release(&__libc_gmtxExec);
+
+                        /*
+                         * Shut down the process...
+                         */
+                        _rmtmp();
+                        __libc_fhExecDone();
+
+                        /*
+                         * Wait for the child to complete and forward stuff while doing so...
                          */
                         pid_t pid = resc.codeTerminate;

trunk/libc/src/kNIX/os2/b_processWait.c

@@ -584 +584 @@
     }
     return -ENOMEM;
+}
+
+
+/**
+ * Checks whether the service has already been started.
+ *
+ * @return 1 if started, 0 if not.
+ */
+int __libc_back_processWaitNotifyAlreadyStarted(void)
+{
+    return gtidThread != 0;
 }
 

trunk/libc/src/kNIX/os2/kNIX-os2.h

@@ -245 +245 @@
 
 void __libc_back_processWaitNotifyTerm(void);
+int  __libc_back_processWaitNotifyAlreadyStarted(void);
 void __libc_back_processWaitNotifyExec(pid_t pid);
 void __libc_back_processWaitNotifyChild(siginfo_t *pSigInfo);

trunk/libc/src/kNIX/os2/sharedpm.c

@@ -2762 +2762 @@
 
         /* update state and insert at head of that state list. */
-        pProcess->enmState = __LIBC_PROCSTATE_ALIVE;
+        LIBC_ASSERT(sizeof(pProcess->enmState) == sizeof(int));
+        __lxchg((int volatile *)&pProcess->enmState, __LIBC_PROCSTATE_ALIVE);
         pProcess->pNext = gpSPMHdr->apHeads[__LIBC_PROCSTATE_ALIVE];
         if (pProcess->pNext)

trunk/libc/src/kNIX/os2/syscalls.h

@@ -64 +64 @@
 EXTERN _fmutex          __libc_gmtxExec INIT({0});
 #endif
+void                    __libc_fhExecDone(void);
 /** @} */