Index: /trunk/src/kash/Makefile.kmk =================================================================== --- /trunk/src/kash/Makefile.kmk (revision 2291) +++ /trunk/src/kash/Makefile.kmk (revision 2292) @@ -32,4 +32,5 @@ PROGRAMS += kash kash_TEMPLATE = BIN +kash_ASTOOL = YASM kash_DEFS = lint SHELL SMALL kash_DEFS += SH_STUB_MODE # for the time being. @@ -50,4 +51,7 @@ HAVE_SYS_SIGNAME HAVE_SYSCTL_H HAVE_SETPROGNAME kash_INCS = $(PATH_kash) . # (the last is because of error.h) +kash_ASFLAGS.win = -g cv8 +kash_ASFLAGS.win.x86 = -f win32 +kash_ASFLAGS.win.amd64 = -f win64 if "$(USER)" == "bird" && "$(KBUILD_TARGET)" != "win" kash_CFLAGS += -std=gnu99 @@ -96,5 +100,7 @@ kash_SOURCES.win = \ sys_signame.c \ - strlcpy.c + strlcpy.c \ + shfork-win.c \ + shforkA-win.asm kash_SOURCES.solaris = \ sys_signame.c \ Index: /trunk/src/kash/main.c =================================================================== --- /trunk/src/kash/main.c (revision 2291) +++ /trunk/src/kash/main.c (revision 2292) @@ -101,5 +101,9 @@ int +#if K_OS == K_OS_WINDOWS +real_main(int argc, char **argv, char **envp) +#else main(int argc, char **argv, char **envp) +#endif { shinstance *psh; Index: /trunk/src/kash/shfork-win.c =================================================================== --- /trunk/src/kash/shfork-win.c (revision 2292) +++ /trunk/src/kash/shfork-win.c (revision 2292) @@ -0,0 +1,140 @@ + + +/******************************************************************************* +* Header Files * +*******************************************************************************/ +#include +#include +#include "shinstance.h" + + +/******************************************************************************* +* Global Variables * +*******************************************************************************/ +static void *g_stack_base = 0; +static void *g_stack_limit = 0; + + +/******************************************************************************* +* Internal Functions * +*******************************************************************************/ +static void *shfork_string_to_ptr(const char *str, const char *argv0, const char *what); + +/* in shforkA-win.asm: */ +extern void shfork_resume(void *cur, void *base, void *limit); + +/* called by shforkA-win.asm: */ +void *shfork_maybe_forked(int argc, char **argv, char **envp); +extern int shfork_body(uintptr_t stack_ptr); + + +/*** + * Called by shforkA-win.asm to check whether we're a forked child + * process or not. + * + * In the former case we will resume execution at the fork resume + * point. In the latter we'll allocate a new stack of the forkable + * heap and return it to the caller so real_main() in main.c can be + * invoked on it. + * + * @returns Stack or not at all. + * @param argc Argument count. + * @param argv Argument vector. + * @param envp Environment vector. + */ +void *shfork_maybe_forked(int argc, char **argv, char **envp) +{ + void *stack_ptr; + + /* + * Are we actually forking? + */ + if ( argc != 8 + || strcmp(argv[1], "--!forked!--") + || strcmp(argv[2], "--stack-address") + || strcmp(argv[4], "--stack-base") + || strcmp(argv[6], "--stack-limit")) + { + shheap_init(); + return (char *)sh_malloc(NULL, 1*1024*1024) + 1*1024*1024; + } + + /* + * Do any init that needs to be done before resuming the + * fork() call. + */ + setlocale(LC_ALL, ""); + + /* + * Convert the stack addresses. + */ + stack_ptr = shfork_string_to_ptr(argv[3], argv[0], "--stack-address"); + g_stack_base = shfork_string_to_ptr(argv[5], argv[0], "--stack-base"); + g_stack_limit = shfork_string_to_ptr(argv[7], argv[0], "--stack-limit"); + + /* + * Switch stack and jump to the fork resume point. + */ + shfork_resume(stack_ptr, g_stack_base, g_stack_limit); + /* (won't get here) */ + return NULL; +} + +/*** + * Converts a string into a pointer. + * + * @returns Pointer. + * @param argv0 The program name in case of error. + * @param str The string to convert. + */ +static void *shfork_string_to_ptr(const char *str, const char *argv0, const char *what) +{ + const char *start = str; + intptr_t ptr = 0; + if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) + str += 2; + while (*str) + { + unsigned digit; + switch (*str) + { + case '0': digit = 0; break; + case '1': digit = 1; break; + case '2': digit = 2; break; + case '3': digit = 3; break; + case '4': digit = 4; break; + case '5': digit = 5; break; + case '6': digit = 6; break; + case '7': digit = 7; break; + case '8': digit = 8; break; + case '9': digit = 9; break; + case 'a': case 'A': digit = 0xa; break; + case 'b': case 'B': digit = 0xb; break; + case 'c': case 'C': digit = 0xc; break; + case 'd': case 'D': digit = 0xd; break; + case 'e': case 'E': digit = 0xe; break; + case 'f': case 'F': digit = 0xf; break; + default: + fprintf(stderr, "%s: fatal error: Invalid %s '%s'\n", argv0, what, start); + exit(2); + } + ptr <<= 4; + ptr |= digit; + } + return (void *)ptr; +} + +/*** + * Create the child process making sure it inherits all our handles, + * copy of the forkable heap and kick it off. + * + * Called by shfork_do_it() in shforkA-win.asm. + * + * @returns child pid on success, -1 and errno on failure. + * @param stack_ptr The stack address at which the guest is suppost to resume. + */ +int shfork_body(uintptr_t stack_ptr) +{ + errno = ENOSYS; + return -1; +} Index: /trunk/src/kash/shforkA-win.asm =================================================================== --- /trunk/src/kash/shforkA-win.asm (revision 2292) +++ /trunk/src/kash/shforkA-win.asm (revision 2292) @@ -0,0 +1,328 @@ +; $Id$ +;; @file +; shforkA-win.asm - assembly routines used when forking on Windows. +; + +; +; Copyright (c) 2009 knut st. osmundsen +; +; This file is part of kBuild. +; +; kBuild is free software; you can redistribute it and/or modify +; it under the terms of the GNU General Public License as published by +; the Free Software Foundation; either version 3 of the License, or +; (at your option) any later version. +; +; kBuild 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 General Public License for more details. +; +; You should have received a copy of the GNU General Public License +; along with kBuild. If not, see +; +; + +;******************************************************************************* +;* Defined Constants And Macros * +;******************************************************************************* +%ifdef KBUILD_ARCH_AMD64 + %define NAME(name) name +%else + %define NAME(name) _ %+ name +%endif + + +;******************************************************************************* +;* External Symbols * +;******************************************************************************* +extern NAME(real_main) +extern NAME(shfork_maybe_forked) +extern NAME(shfork_body) + + +[section .text] + +;; +; C main() wrapper. +; +NAME(main): +global NAME(main) +%ifdef KBUILD_ARCH_AMD64 +[proc_frame main] +%endif + + ; + ; Prolog, spilling parameters from registers. + ; +%ifdef KBUILD_ARCH_AMD64 + [pushreg rbp] + push rbp + [setframe rbp, 0] + mov rbp, rsp + [allocstack 0x40] + sub rsp, 40h + and rsp, ~1fh + mov [rsp ], rcx ; argc + mov [rsp+ 8h], rdx ; argv + mov [rsp+10h], r8 ; envp + [endprolog] +%else + push ebp + mov ebp, esp + sub esp, 40h + and esp, ~1fh +%endif + + ; + ; Call shfork_maybe_forked. This will not return if we're forking. + ; +%ifndef KBUILD_ARCH_AMD64 + mov ecx, [ebp + 8h] ; argc + mov edx, [ebp + 0ch] ; argv + mov eax, [ebp + 10h] ; envp + mov [esp ], ecx + mov [esp + 4h], edx + mov [esp + 8h], eax +%endif + call NAME(shfork_maybe_forked) + + ; + ; Ok, it returned which means we're not forking. + ; + ; The accumulator register is now pointing to the top of the + ; stack we're going to call real_main on. Switch and call it. + ; + ; The TIB adjustments is required or we'll crash in longjmp/unwind. + ; +%ifdef KBUILD_ARCH_AMD64 + mov [rsp + 18h], rax + mov [rax - 8h], rsp + + mov r10, [gs:08h] ; StackBase (the higher value) + mov r11, [gs:10h] ; StackLimit (the lower value) + mov [rax - 10h], r10 + mov [rax - 18h], r11 + cmp rax, r10 + jb .below + mov [gs:08h], rax +.below: + lea r9, [rax - 1*1024*1024] + cmp r9, r11 + ja .above + mov [gs:10h], r9 +.above: + + mov rcx, [rsp ] ; argc + mov rdx, [rsp + 08h] ; argv + mov r8, [rsp + 10h] ; envp + + lea rsp, [eax - 40h] ; Switch! +%else + mov [esp + 18h], eax + mov [eax - 4], esp + lea esp, [eax - 40h] ; Switch! + + mov edx, [fs:04h] ; StackBase (the higher value) + mov ecx, [fs:08h] ; StackLimit (the lower value) + mov [eax - 10h], edx + mov [eax - 18h], ecx + cmp rax, edx + jb .below + mov [fs:04h], rax +.below: + lea edx, [eax - 1*1024*1024] + cmp edx, ecx + ja .above + mov [fs:08h], edx +.above: + + mov ecx, [ebp + 8h] ; argc + mov edx, [ebp + 0ch] ; argv + mov eax, [ebp + 10h] ; envp + + mov [esp ], ecx + mov [esp + 4h], edx + mov [esp + 8h], eax +%endif + call NAME(real_main) + + ; + ; Switch back the stack, restore the TIB fields and we're done. + ; +%ifdef KBUILD_ARCH_AMD64 + lea r11, [rsp + 40h] + mov rsp, [rsp + 38h] + mov r8, [r11 - 10h] + mov r9, [r11 - 18h] + mov [gs:08h], r8 + mov [gs:10h], r9 +%else + lea edx, [esp + 40h] + mov esp, [esp + 2ch] + mov ecx, [edx - 10h] + mov edx, [edx - 18h] + mov [fs:04h], ecx + mov [fs:08h], edx +%endif + leave + ret +%ifdef KBUILD_ARCH_AMD64 +[endproc_frame main] +%endif + + +;; +; sh_fork() worker +; +NAME(shfork_do_it): +global NAME(shfork_do_it) +%ifdef KBUILD_ARCH_AMD64 + [proc_frame shfork_do_it] + [pushreg rbp] + push rbp + [setframe rbp, 0] + mov rbp, rsp + [allocstack 0x400] + sub rsp, 400h + and rsp, ~1ffh +[endprolog] +%else + push ebp + mov ebp, esp + sub esp, 400h + and esp, ~1ffh +%endif + + ; + ; Save most registers so they can be restored in the child. + ; +%ifdef KBUILD_ARCH_AMD64 + fxsave [rsp] + mov [rsp + 200h], rbp + mov [rsp + 208h], rax + mov [rsp + 210h], rbx + mov [rsp + 218h], rcx + mov [rsp + 220h], rdx + mov [rsp + 228h], rsi + mov [rsp + 230h], rdi + mov [rsp + 238h], r8 + mov [rsp + 240h], r9 + mov [rsp + 248h], r10 + mov [rsp + 250h], r11 + mov [rsp + 258h], r12 + mov [rsp + 260h], r13 + mov [rsp + 268h], r14 + mov [rsp + 270h], r15 +%else + fxsave [esp] + mov [esp + 200h], ebp + mov [esp + 208h], eax + mov [esp + 210h], ebx + mov [esp + 218h], ecx + mov [esp + 220h], edx + mov [esp + 228h], esi + mov [esp + 230h], edi +%endif + + ; + ; Call the shfork_body that will spawn the child and all that. + ; +%ifdef KBUILD_ARCH_AMD64 + mov rcx, rsp +%else + mov ecx, esp + sub esp, 20h + mov [esp], ecx +%endif + call NAME(shfork_body) +%ifdef KBUILD_ARCH_AMD64 + lea esp, [esp + 20h] +%endif + + ; + ; Just leave the function, no need to restore things. + ; + leave + ret +%ifdef KBUILD_ARCH_AMD64 +[endproc_frame shfork_do_it] +%endif + + +;; +; Switch the stack, restore the register and leave as if we'd called shfork_do_it. +; +; @param cur Current stack pointer. +; @param base The stack base (higher value). +; @param limit The stack limit (lower value). +; +NAME(shfork_resume): +global NAME(shfork_resume) +%ifdef KBUILD_ARCH_AMD64 + mov rsp, rcx +%else + mov ecx, [esp + 4] + mov edx, [esp + 8] + mov eax, [esp + 12] + mov esp, ecx +%endif + + ; + ; Adjust stack stuff in the TIB (longjmp/unwind). + ; +%ifdef KBUILD_ARCH_AMD64 + cmp rdx, [gs:08h] ; StackBase (the higher value) + jb .below + mov [gs:08h], rdx +.below: + cmp r8, [gs:10h] ; StackLimit + ja .above + mov [gs:10h], r8 +.above: +%else + cmp edx, [fs:04h] ; StackBase (the higher value) + jb .below + mov [fs:04h], edx +.below: + cmp eax, [fs:08h] ; StackLimit + ja .above + mov [fs:08h], eax +.above: +%endif + + ; + ; Restore most of the registers. + ; + ;; @todo xmm registers may require explicit saving/restoring... +%ifdef KBUILD_ARCH_AMD64 + frstor [rsp] + mov rbp, [rsp + 200h] + mov rax, [rsp + 208h] + mov rbx, [rsp + 210h] + mov rcx, [rsp + 218h] + mov rdx, [rsp + 220h] + mov rsi, [rsp + 228h] + mov rdi, [rsp + 230h] + mov r8, [rsp + 238h] + mov r9, [rsp + 240h] + mov r10, [rsp + 248h] + mov r11, [rsp + 250h] + mov r12, [rsp + 258h] + mov r13, [rsp + 260h] + mov r14, [rsp + 268h] + mov r15, [rsp + 270h] +%else + frstor [esp] + mov ebp, [esp + 200h] + mov eax, [esp + 208h] + mov ebx, [esp + 210h] + mov ecx, [esp + 218h] + mov edx, [esp + 220h] + mov esi, [esp + 228h] + mov edi, [esp + 230h] +%endif + xor eax, eax ; the child returns 0. + leave + ret + Index: /trunk/src/kash/shheap.c =================================================================== --- /trunk/src/kash/shheap.c (revision 2291) +++ /trunk/src/kash/shheap.c (revision 2292) @@ -29,4 +29,5 @@ * Header Files * *******************************************************************************/ +#include "shheap.h" #include #include Index: /trunk/src/kash/shheap.h =================================================================== --- /trunk/src/kash/shheap.h (revision 2291) +++ /trunk/src/kash/shheap.h (revision 2292) @@ -1,5 +1,5 @@ /* $Id$ */ /** @file - * The shell heap methods. + * The shell memory heap methods. */ @@ -32,4 +32,5 @@ /* heap */ +int shheap_init(void); void *sh_malloc(shinstance *, size_t); void *sh_calloc(shinstance *, size_t, size_t); Index: /trunk/src/kash/shinstance.c =================================================================== --- /trunk/src/kash/shinstance.c (revision 2291) +++ /trunk/src/kash/shinstance.c (revision 2292) @@ -39,4 +39,8 @@ #endif #include "shinstance.h" + +#if K_OS == K_OS_WINDOWS +extern pid_t shfork_do_it(void); /* shforkA-win.asm */ +#endif @@ -872,13 +876,11 @@ pid = -1; -#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE) -# ifdef _MSC_VER -# ifdef SH_FORKED_MODE - /** @todo */ - *(char *)1 = 0x1; -# else +#elif K_OS == K_OS_WINDOWS //&& defined(SH_FORKED_MODE) + pid = shfork_do_it(); + +#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE) +# ifdef _MSC_VER pid = -1; errno = ENOSYS; -# endif # else pid = fork();