Changeset 2293 for trunk/src

Timestamp:

Feb 28, 2009, 8:25:12 AM (16 years ago)

Author:

bird

Message:

kash: forking on windows (almost there).

Location:

trunk/src/kash

Files:

• shfile.c (modified) (1 diff)
• shfile.h (modified) (1 diff)
• shfork-win.c (modified) (6 diffs)
• shforkA-win.asm (modified) (5 diffs)
• shheap.c (modified) (1 diff)
• shheap.h (modified) (1 diff)
• shinstance.c (modified) (5 diffs)
• shinstance.h (modified) (3 diffs)
• show.c (modified) (7 diffs)

trunk/src/kash/shfile.c

@@ -451 +451 @@
 }
 
+#if K_OS == K_OS_WINDOWS && defined(SHFILE_IN_USE) //&& defined(SH_FORKED_MODE)
+/**
+ * Helper for shfork.
+ *
+ * @param   pfdtab  The file descriptor table.
+ * @param   set     Whether to make all handles inheritable (1) or
+ *                  to restore them to the rigth state (0).
+ * @param   hndls   Where to store the three standard handles.
+ */
+void shfile_fork_win(shfdtab *pfdtab, int set, intptr_t *hndls)
+{
+    shmtxtmp tmp;
+    unsigned i;
+
+    shmtx_enter(&pfdtab->mtx, &tmp);
+
+    i = pfdtab->size;
+    while (i-- > 0)
+    {
+        if (pfdtab->tab[i].fd == i)
+        {
+            HANDLE hFile = (HANDLE)pfdtab->tab[i].native;
+            DWORD  fFlag = set || !pfdtab->tab[i].cloexec ? HANDLE_FLAG_INHERIT : 0;
+            if (!SetHandleInformation(hFile, HANDLE_FLAG_INHERIT, fFlag))
+            {
+                DWORD err = GetLastError();
+                assert(0);
+            }
+        }
+    }
+
+    if (hndls)
+    {
+        for (i = 0; i < 3; i++)
+        {
+            if (    pfdtab->size > i
+                &&  pfdtab->tab[i].fd == 0)
+                hndls[i] = pfdtab->tab[i].native;
+            else
+                hndls[i] = (intptr_t)INVALID_HANDLE_VALUE;
+        }
+    }
+
+    shmtx_leave(&pfdtab->mtx, &tmp);
+}
+#endif
+
+
 /**
  * open().

trunk/src/kash/shfile.h

@@ -119 +119 @@
 
 int shfile_init(shfdtab *, shfdtab *);
+void shfile_fork_win(shfdtab *pfdtab, int set, intptr_t *hndls);
 
 int shfile_open(shfdtab *, const char *, unsigned, mode_t);

trunk/src/kash/shfork-win.c

@@ -7 +7 @@
 #include <locale.h>
 #include "shinstance.h"
+#include <Windows.h>
+
+/*******************************************************************************
+*   Defined Constants And Macros                                               *
+*******************************************************************************/
+/** The stack size. This is also defined in shforkA-win.asm. */
+#define SHFORK_STACK_SIZE (1*1024*1024)
 
 
@@ -26 +33 @@
 /* called by shforkA-win.asm: */
 void *shfork_maybe_forked(int argc, char **argv, char **envp);
-extern int shfork_body(uintptr_t stack_ptr);
+extern int shfork_body(shinstance *psh, void *stack_ptr);
 
 
@@ -56 +63 @@
         ||  strcmp(argv[6], "--stack-limit"))
     {
+        char *stack;
         shheap_init();
-        return (char *)sh_malloc(NULL, 1*1024*1024) + 1*1024*1024;
+        stack = (char *)sh_malloc(NULL, SHFORK_STACK_SIZE) + SHFORK_STACK_SIZE;
+        g_stack_base = stack + SHFORK_STACK_SIZE;
+        g_stack_limit = stack;
+        return stack;
     }
 
@@ -64 +75 @@
      * fork() call.
      */
-        setlocale(LC_ALL, "");
+    setlocale(LC_ALL, "");
 
     /*
@@ -121 +132 @@
         ptr <<= 4;
         ptr |= digit;
+        str++;
     }
     return (void *)ptr;
@@ -132 +144 @@
  *
  * @returns child pid on success, -1 and errno on failure.
+ * @param   psh             The shell that's forking.
  * @param   stack_ptr       The stack address at which the guest is suppost to resume.
  */
-int shfork_body(uintptr_t stack_ptr)
+int shfork_body(shinstance *psh, void *stack_ptr)
 {
-    errno = ENOSYS;
-    return -1;
+    PROCESS_INFORMATION ProcInfo;
+    STARTUPINFO StrtInfo;
+    intptr_t hndls[3];
+    char szExeName[1024];
+    char szCmdLine[1024+256];
+    DWORD cch;
+    int rc = 0;
+
+    /*
+     * Mark all handles inheritable and get the three standard handles.
+     */
+    shfile_fork_win(&psh->fdtab, 1 /* set */, &hndls[0]);
+
+    /*
+     * Create the process.
+     */
+    cch = GetModuleFileName(GetModuleHandle(NULL), szExeName, sizeof(szExeName));
+    if (cch > 0)
+    {
+#if 0 /* quoting the program name doesn't seems to be working :/ */
+        szCmdLine[0] = '"';
+        memcpy(&szCmdLine[1], szExeName, cch);
+        szCmdLine[++cch] = '"';
+#else
+        memcpy(&szCmdLine[0], szExeName, cch);
+#endif
+        cch += sprintf(&szCmdLine[cch], " --!forked!-- --stack-address %p --stack-base %p --stack-limit %p",
+                       stack_ptr, g_stack_base, g_stack_limit);
+        szCmdLine[cch+1] = '\0';
+
+        memset(&StrtInfo, '\0', sizeof(StrtInfo)); /* just in case. */
+        StrtInfo.cb = sizeof(StrtInfo);
+        StrtInfo.lpReserved = NULL;
+        StrtInfo.lpDesktop = NULL;
+        StrtInfo.lpTitle = NULL;
+        StrtInfo.dwX = 0;
+        StrtInfo.dwY = 0;
+        StrtInfo.dwXSize = 0;
+        StrtInfo.dwYSize = 0;
+        StrtInfo.dwXCountChars = 0;
+        StrtInfo.dwYCountChars = 0;
+        StrtInfo.dwFillAttribute = 0;
+        StrtInfo.dwFlags = 0;
+        StrtInfo.wShowWindow = 0;
+        StrtInfo.cbReserved2 = 0;
+        StrtInfo.lpReserved2 = NULL;
+        StrtInfo.hStdInput  = (HANDLE)hndls[0];
+        StrtInfo.hStdOutput = (HANDLE)hndls[1];
+        StrtInfo.hStdError  = (HANDLE)hndls[2];
+        if (CreateProcess(szExeName,
+                          szCmdLine,
+                          NULL,         /* pProcessAttributes */
+                          NULL,         /* pThreadAttributes */
+                          TRUE,         /* bInheritHandles */
+                          CREATE_SUSPENDED,
+                          NULL,         /* pEnvironment */
+                          NULL,         /* pCurrentDirectory */
+                          &StrtInfo,
+                          &ProcInfo))
+        {
+            /*
+             * Copy the memory to the child.
+             */
+            rc = shheap_fork_copy_to_child(ProcInfo.hProcess);
+            if (!rc)
+            {
+                if (ResumeThread(ProcInfo.hThread) != (DWORD)-1)
+                {
+                    rc = sh_add_child(psh, ProcInfo.dwProcessId, ProcInfo.hProcess);
+                    if (!rc)
+                        rc = (int)ProcInfo.dwProcessId;
+                }
+                else
+                {
+                    DWORD dwErr = GetLastError();
+                    fprintf(stderr, "shfork: ResumeThread() -> %d\n", dwErr);
+                    errno = EINVAL;
+                    rc = -1;
+                }
+            }
+            if (rc == -1)
+            {
+                TerminateProcess(ProcInfo.hProcess, 127);
+                /* needed?: ResumeThread(ProcInfo.hThread); */
+                CloseHandle(ProcInfo.hProcess);
+            }
+            CloseHandle(ProcInfo.hThread);
+        }
+        else
+        {
+            DWORD dwErr = GetLastError();
+            fprintf(stderr, "shfork: CreateProcess(%s) -> %d\n", szExeName, dwErr);
+            errno = EINVAL;
+            rc = -1;
+        }
+    }
+    else
+    {
+        DWORD dwErr = GetLastError();
+        fprintf(stderr, "shfork: GetModuleFileName() -> %d\n", dwErr);
+        errno = EINVAL;
+        rc = -1;
+    }
+
+    /*
+     * Restore the handle inherit property.
+     */
+    shfile_fork_win(&psh->fdtab, 0 /* restore */, NULL);
+
+    return rc;
 }

trunk/src/kash/shforkA-win.asm

@@ -32 +32 @@
  %define NAME(name) _ %+ name
 %endif
+
+;; The stack size. This is also defined in shfork-win.c.
+%define SHFORK_STACK_SIZE (1*1024*1024)
 
 
@@ -108 +111 @@
         mov     [gs:08h], rax
 .below:
-        lea     r9, [rax - 1*1024*1024]
+        lea     r9, [rax - SHFORK_STACK_SIZE]
         cmp     r9, r11
         ja      .above
@@ -132 +135 @@
         mov     [fs:04h], rax
 .below:
-        lea     edx, [eax - 1*1024*1024]
+        lea     edx, [eax - SHFORK_STACK_SIZE]
         cmp     edx, ecx
         ja      .above
@@ -175 +178 @@
 ;;
 ; sh_fork() worker
+;
+; @returns      See fork().
+; @param        psh
 ;
 NAME(shfork_do_it):
@@ -230 +236 @@
         ;
 %ifdef KBUILD_ARCH_AMD64
-        mov     rcx, rsp
-%else
-        mov     ecx, esp
+        ;mov     rcx, rcx               ; psh
+        mov     rdx, rsp                ; stack_ptr
+        sub     rsp, 20h
+        call    NAME(shfork_body)
+        lea     rsp, [rsp + 20h]
+%else
+        mov     edx, esp
+        mov     ecx, [ebp + 8h]         ; psh
         sub     esp, 20h
-        mov     [esp], ecx
-%endif
+        mov     [esp    ], edx
+        mov     [esp + 4], ecx          ; stack_ptr
         call    NAME(shfork_body)
-%ifdef KBUILD_ARCH_AMD64
         lea     esp, [esp + 20h]
 %endif

trunk/src/kash/shheap.c

@@ -137 +137 @@
 #ifdef SHHEAP_IN_USE
 
+# if K_OS == K_OS_WINDOWS
+/**
+ * Copies the heap into the child process.
+ *
+ * @returns 0 on success, -1 and errno on failure.
+ * @param   hChild      Handle to the child process.
+ */
+int shheap_fork_copy_to_child(void *hChild)
+{
+    shmemchunk *chunk;
+    shmtxtmp tmp;
+    int err = 0;
+
+    shmtx_enter(&g_sh_heap_mtx, &tmp);
+
+    for (chunk = g_sh_heap; chunk; chunk = chunk->next)
+    {
+        void *chld_chnk;
+
+        chld_chnk = (shmemchunk *)VirtualAllocEx(hChild, chunk, chunk->size,
+                                                 MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
+        if (chld_chnk != chunk)
+        {
+            err = GetLastError();
+            fprintf(stderr, "shfork: VirtualAllocEx(,%p,%p,) -> %d\n", chunk, chunk->size, err);
+            break;
+        }
+
+        if (!WriteProcessMemory(hChild, chunk, chunk, chunk->size, NULL /* pNumberOfBytesWritten */))
+        {
+            err = GetLastError();
+            fprintf(stderr, "shfork: WriteProcessMemory(,%p,,%p,) -> %d\n", chunk, chunk->size, err);
+            break;
+        }
+    }
+
+    shmtx_leave(&g_sh_heap_mtx, &tmp);
+
+    if (!err)
+        return 0;
+    errno = EINVAL;
+    return -1;
+}
+# endif
+
+
 /**
  * Checks a heap chunk.

trunk/src/kash/shheap.h

@@ -33 +33 @@
 /* heap */
 int shheap_init(void);
+int shheap_fork_copy_to_child(void *);
+
 void *sh_malloc(shinstance *, size_t);
 void *sh_calloc(shinstance *, size_t, size_t);

trunk/src/kash/shinstance.c

@@ -38 +38 @@
 # include <pwd.h>
 #endif
+#if K_OS == K_OS_WINDOWS
+# include <Windows.h>
+#endif
 #include "shinstance.h"
 
 #if K_OS == K_OS_WINDOWS
-extern pid_t shfork_do_it(void); /* shforkA-win.asm */
+extern pid_t shfork_do_it(shinstance *psh); /* shforkA-win.asm */
 #endif
 
@@ -308 +311 @@
 }
 
+/** getenv() */
 char *sh_getenv(shinstance *psh, const char *var)
 {
@@ -868 +872 @@
 }
 
+/**
+ * Adds a child to the shell
+ *
+ * @returns 0 on success, on failure -1 and errno set to ENOMEM.
+ *
+ * @param   psh     The shell instance.
+ * @param   pid     The child pid.
+ * @param   hChild  Windows child handle.
+ */
+int sh_add_child(shinstance *psh, pid_t pid, void *hChild)
+{
+    /* get a free table entry. */
+    int i = psh->num_children++;
+    if (!(i % 32))
+    {
+        void *ptr = sh_realloc(psh, psh->children, sizeof(*psh->children) * (i + 32));
+        if (!ptr)
+        {
+            psh->num_children--;
+            errno = ENOMEM;
+            return -1;
+        }
+        psh->children = ptr;
+    }
+
+    /* add it */
+    psh->children[i].pid = pid;
+#if K_OS == K_OS_WINDOWS
+    psh->children[i].hChild = hChild;
+#endif
+    (void)hChild;
+    return 0;
+}
+
 pid_t sh_fork(shinstance *psh)
 {
@@ -877 +915 @@
 
 #elif K_OS == K_OS_WINDOWS //&& defined(SH_FORKED_MODE)
-    pid = shfork_do_it();
+    pid = shfork_do_it(psh);
 
 #elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
@@ -896 +934 @@
 }
 
+/** waitpid() */
 pid_t sh_waitpid(shinstance *psh, pid_t pid, int *statusp, int flags)
 {
     pid_t pidret;
-
+#ifdef SH_PURE_STUB_MODE
     *statusp = 0;
-#ifdef SH_PURE_STUB_MODE
     pidret = -1;
 
-#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
+#elif K_OS == K_OS_WINDOWS //&& defined(SH_FORKED_MODE)
+    DWORD   dwRet;
+    HANDLE  hChild = INVALID_HANDLE_VALUE;
+    int     i;
+
+    *statusp = 0;
+    pidret = -1;
+    if (pid != -1)
+    {
+        /*
+         * A specific child, try look it up in the child process table
+         * and wait for it.
+         */
+        for (i = 0; i < psh->num_children; i++)
+            if (psh->children[i].pid == pid)
+                break;
+        if (i < psh->num_children)
+        {
+            dwRet = WaitForSingleObject(psh->children[i].hChild,
+                                        flags & WNOHANG ? 0 : INFINITE);
+            if (dwRet == WAIT_OBJECT_0)
+                hChild = psh->children[i].hChild;
+            else if (dwRet == WAIT_TIMEOUT)
+            {
+                i = -1; /* don't try close anything */
+                pidret = 0;
+            }
+            else
+                errno = ECHILD;
+        }
+        else
+            errno = ECHILD;
+    }
+    else if (psh->num_children <= MAXIMUM_WAIT_OBJECTS)
+    {
+        HANDLE ahChildren[64];
+        for (i = 0; i < psh->num_children; i++)
+            ahChildren[i] = psh->children[i].hChild;
+        dwRet = WaitForMultipleObjects(psh->num_children, &ahChildren[0],
+                                       FALSE,
+                                       flags & WNOHANG ? 0 : INFINITE);
+        i = dwRet - WAIT_OBJECT_0;
+        if ((unsigned)i < (unsigned)psh->num_children)
+        {
+            hChild = psh->children[i].hChild;
+        }
+        else if (dwRet == WAIT_TIMEOUT)
+        {
+            i = -1; /* don't try close anything */
+            pidret = 0;
+        }
+        else
+        {
+            i = -1; /* don't try close anything */
+            errno = EINVAL;
+        }
+    }
+    else
+    {
+        fprintf(stderr, "panic! too many children!\n");
+        i = -1;
+        *(char *)1 = '\0'; /** @todo implement this! */
+    }
+
+    /*
+     * Close the handle, and if we succeeded collect the exit code first.
+     */
+    if (    i >= 0
+        &&  i < psh->num_children)
+    {
+        if (hChild != INVALID_HANDLE_VALUE)
+        {
+            DWORD dwExitCode = 127;
+            if (GetExitCodeProcess(hChild, &dwExitCode))
+            {
+                pidret = psh->children[i].pid;
+                if (dwExitCode && !W_EXITCODE(dwExitCode, 0))
+                    dwExitCode |= 16;
+                *statusp = W_EXITCODE(dwExitCode, 0);
+            }
+            else
+                errno = EINVAL;
+        }
+
+        /* remove and close */
+        hChild = psh->children[i].hChild;
+        psh->num_children--;
+        if (i < psh->num_children)
+            psh->children[i] = psh->children[psh->num_children];
+        i = CloseHandle(hChild); assert(i);
+    }
+
+#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
+    *statusp = 0;
 # ifdef _MSC_VER
     pidret = -1;

trunk/src/kash/shinstance.h

@@ -59 +59 @@
 #endif
 
+/**
+ * A child process.
+ */
+typedef struct shchild
+{
+    pid_t       pid;                    /**< The pid. */
+#if K_OS == K_OS_WINDOWS
+    void       *hChild;                 /**< The process handle. */
+#endif
+} shchild;
 
 /* memalloc.c */
@@ -135 +145 @@
     shsigset_t          sigmask;        /**< Our signal mask. */
     char              **shenviron;      /**< The environment vector. */
+    int                 num_children;   /**< Number of children in the array. */
+    shchild            *children;       /**< The child array. */
 
     /* alias.c */
@@ -396 +408 @@
 
 /* wait / process */
+int sh_add_child(shinstance *psh, pid_t pid, void *hChild);
 #ifdef _MSC_VER
 #   include <process.h>

trunk/src/kash/show.c

@@ -274 +274 @@
 trputc(shinstance *psh, int c)
 {
-        if (debug(psh) != 1)
+        if (psh && debug(psh) != 1)
                 return;
         putc(c, tracefile);
@@ -287 +287 @@
         va_list va;
 
-        if ((psh || !tracefile) && debug(psh) != 1)
-                return;
-        fprintf(tracefile, "[%d] ", sh_getpid(psh));
+        if (!tracefile || (psh && debug(psh) != 1))
+                return;
+        fprintf(tracefile, "[%d] ", sh_getpid(psh));
         va_start(va, fmt);
         (void) vfprintf(tracefile, fmt, va);
@@ -304 +304 @@
         int savederrno = errno;
 
-        if ((psh || !tracefile) && debug(psh) != 1)
-                return;
-        fprintf(tracefile, "[%d] ", sh_getpid(psh));
+        if (!tracefile || (psh && debug(psh) != 1))
+                return;
+        fprintf(tracefile, "[%d] ", sh_getpid(psh));
         (void) vfprintf(tracefile, fmt, va);
 
@@ -320 +320 @@
         int savederrno = errno;
 
-        if ((psh || !tracefile) && debug(psh) != 1)
+        if (!tracefile || (psh && debug(psh) != 1))
                 return;
         fputs(s, tracefile);
@@ -335 +335 @@
         char c;
 
-        if ((psh || !tracefile) && debug(psh) != 1)
+        if (!tracefile || (psh && debug(psh) != 1))
                 return;
         putc('"', tracefile);
@@ -378 +378 @@
         int savederrno = errno;
 
-        if ((psh || !tracefile) && debug(psh) != 1)
+        if (!tracefile || (psh && debug(psh) != 1))
                 return;
         while (*ap) {
@@ -400 +400 @@
         int fd;
 
-        if (debug(psh) != 1) {
+        if (psh && debug(psh) != 1) {
                 if (tracefile)
                         fflush(tracefile);