Changeset 3438 in kBuild

Timestamp:

Sep 9, 2020 8:01:39 PM (4 years ago)

Author:

bird

Message:

kash: Hammering on threaded mode.

Location:

trunk/src/kash

Files:

• Makefile.kmk (modified) (5 diffs)
• alias.c (modified) (3 diffs)
• alias.h (modified) (1 diff)
• bltin/kill.c (modified) (3 diffs)
• error.c (modified) (1 diff)
• eval.c (modified) (8 diffs)
• exec.c (modified) (3 diffs)
• exec.h (modified) (1 diff)
• expand.c (modified) (6 diffs)
• expand.h (modified) (1 diff)
• jobs.c (modified) (21 diffs)
• jobs.h (modified) (4 diffs)
• main.c (modified) (5 diffs)
• options.c (modified) (3 diffs)
• options.h (modified) (1 diff)
• output.c (modified) (1 diff)
• parser.c (modified) (1 diff)
• redir.c (modified) (1 diff)
• shell.h (modified) (1 diff)
• shfile.c (modified) (3 diffs)
• shfork-win.c (modified) (1 diff)
• shheap.c (modified) (1 diff)
• shinstance.c (modified) (22 diffs)
• shinstance.h (modified) (13 diffs)
• show.c (modified) (3 diffs)
• shtypes.h (modified) (1 diff)
• trap.c (modified) (4 diffs)
• trap.h (modified) (2 diffs)
• var.c (modified) (2 diffs)
• var.h (modified) (1 diff)

trunk/src/kash/Makefile.kmk

@@ -26 +26 @@
 SUB_DEPTH = ../..
 include $(KBUILD_PATH)/subheader.kmk
+
+KASH_WIN_FORKED_MODE = 1
 
 #
@@ -35 +37 @@
 kash_ASTOOL = YASM
 kash_DEFS = lint SHELL SMALL
+if "$(KBUILD_TARGET)" != "win" || defined(KASH_WIN_FORKED_MODE)
 kash_DEFS += SH_FORKED_MODE
+endif
 kash_DEFS.debug = DEBUG=2
 kash_DEFS.haiku = BSD
@@ -44 +48 @@
         BSD YY_NO_UNISTD_H \
         SH_DEAL_WITH_CRLF PC_PATH_SEP PC_DRIVE_LETTERS PC_EXE_EXTS EXEC_HASH_BANG_SCRIPT \
-#       KASH_USE_FORKSHELL2
+        KASH_USE_FORKSHELL2
 kash_DEFS.os2 = \
         HAVE_SYS_SIGNAME HAVE_SYSCTL_H HAVE_SETPROGNAME PC_OS2_LIBPATHS \
@@ -67 +71 @@
 endif
 kash_CFLAGS.win.amd64 = -GS-
+ifdef KASH_WIN_FORKED_MODE
 kash_LDFLAGS.win = -DYNAMICBASE:NO
+endif
 kash_SOURCES = \
         main.c \
@@ -125 +131 @@
         $(kash_0_OUTDIR)/sys_signame.c \
         strsignal.c \
-        strlcpy.c \
+        strlcpy.c
+ifdef KASH_WIN_FORKED_MODE
+kash_SOURCES.win += \
         shfork-win.c \
         shforkA-win.asm
+endif
 
 kash_INTERMEDIATES = \

trunk/src/kash/alias.c

@@ -61 +61 @@
 STATIC struct alias **hashalias(shinstance *, char *);
 
+#ifndef SH_FORKED_MODE
+void
+subshellinitalias(shinstance *psh, shinstance *inherit)
+{
+    unsigned i;
+    unsigned left = inherit->aliases;
+    if (left == 0)
+        return;
+    for (i = 0; i < K_ELEMENTS(inherit->atab); i++)
+    {
+        struct alias const *asrc = inherit->atab[i];
+        if (asrc)
+        {
+            struct alias **ppdst = &psh->atab[i];
+            do
+            {
+                if (*asrc->name)
+                {
+                    struct alias *dst = (struct alias *)ckmalloc(psh, sizeof(*dst));
+                    dst->name = savestr(psh, asrc->name);
+                    dst->val = savestr(psh, asrc->val);
+                    dst->flag = asrc->flag;
+                    *ppdst = dst;
+                    ppdst = &dst->next;
+                }
+                left--;
+                asrc = asrc->next;
+            } while (asrc);
+            *ppdst = NULL;
+            if (left == 0)
+                break;
+        }
+    }
+}
+#endif /* !SH_FORKED_MODE */
+
 STATIC
 void
@@ -111 +147 @@
         ap->next = *app;
         *app = ap;
+        psh->aliases++;
         INTON;
 }
@@ -138 +175 @@
                                 ckfree(psh, ap->val);
                                 ckfree(psh, ap);
+                                psh->aliases--;
                                 INTON;
                         }

trunk/src/kash/alias.h

@@ -44 +44 @@
 };
 
+#ifndef SH_FORKED_MODE
+void subshellinitalias(shinstance *, shinstance *);
+#endif
 struct alias *lookupalias(struct shinstance *, char *, int);
 char *get_alias_text(struct shinstance *, char *);

trunk/src/kash/bltin/kill.c

@@ -61 +61 @@
 killcmd(shinstance *psh, int argc, char *argv[])
 {
-        int errors, numsig, pid;
+        int errors, numsig;
         char *ep;
 
@@ -131 +131 @@
 
         for (errors = 0; argc; argc--, argv++) {
-                if (*argv[0] == '%') {
-                        pid = getjobpgrp(psh, *argv);
+                const char * const strpid = argv[0];
+                shpid pid;
+                if (*strpid == '%') {
+                        pid = getjobpgrp(psh, strpid);
                         if (pid == 0) {
-                                sh_warnx(psh, "illegal job id: %s", *argv);
+                                sh_warnx(psh, "illegal job id: %s", strpid);
                                 errors = 1;
                                 continue;
                         }
                 } else {
-                        pid = strtol(*argv, &ep, 10);
-                        if (!**argv || *ep) {
-                                sh_warnx(psh, "illegal process id: %s", *argv);
+#if !defined(SH_FORKED_MODE) && defined(_MSC_VER)
+                        pid = _strtoi64(strpid, &ep, 10);
+#elif !defined(SH_FORKED_MODE)
+                        pid = strtoll(strpid, &ep, 10);
+#else
+                        pid = strtol(strpid, &ep, 10);
+#endif
+                        if (!*strpid || *ep) {
+                                sh_warnx(psh, "illegal process id: %s", strpid);
                                 errors = 1;
                                 continue;
@@ -147 +155 @@
                 }
                 if (sh_kill(psh, pid, numsig) == -1) {
-                        sh_warn(psh, "%s", *argv);
+                        sh_warn(psh, "%s", strpid);
                         errors = 1;
                 }

trunk/src/kash/error.c

@@ -165 +165 @@
                 TRACEV((psh, msg, va2));
                 va_end(va2);
-                TRACE((psh, "\") pid=%d\n", sh_getpid(psh)));
+                TRACE((psh, "\") pid=%" SHPID_PRI "\n", sh_getpid(psh)));
         } else
-                TRACE((psh, "exverror(%d, NULL) pid=%d\n", cond, sh_getpid(psh)));
+                TRACE((psh, "exverror(%d, NULL) pid=%" SHPID_PRI "\n", cond, sh_getpid(psh)));
 #endif
         if (msg)

trunk/src/kash/eval.c

@@ -225 +225 @@
         psh->displayhist = 1;   /* show history substitutions done with fc */
 #endif
-        TRACE((psh, "pid %d, evaltree(%p: %d, %d) called\n",
+        TRACE((psh, "pid %" SHPID_PRI ", evaltree(%p: %d, %d) called\n",
                sh_getpid(psh), n, n->type, flags));
         switch (n->type) {
@@ -458 +458 @@
                 args.backgnd = backgnd;
                 forkshell2(psh, jp, n, backgnd ? FORK_BG : FORK_FG,
-                           evalsubshell_child, n, &args, sizeof(args), NULL);
+                           evalsubshell_child, n, &args, sizeof(args), NULL);
         }
 #else
@@ -578 +578 @@
                         args.pip[1] = pip[1];
                         forkshell2(psh, jp, lp->n, n->npipe.backgnd ? FORK_BG : FORK_FG,
-                                   evalpipe_child, lp->n, &args, sizeof(args), NULL);
+                                   evalpipe_child, lp->n, &args, sizeof(args), NULL);
                 }
 #else
@@ -677 +677 @@
                         args.pip[1] = pip[1];
                         forkshell2(psh, jp, n, FORK_NOJOB,
-                                   evalbackcmd_child, n, &args, sizeof(args), NULL);
+                                   evalbackcmd_child, n, &args, sizeof(args), NULL);
                 }
 #else
@@ -894 +894 @@
                         volatile int temp_path = 0;
                         char *volatile savecmdname;
+                        int volatile savecmdnamemalloc;
                         volatile int e;
                         int mode;
@@ -909 +910 @@
                         savehandler = psh->handler;
                         savecmdname = psh->commandname;
+                        savecmdnamemalloc = psh->commandnamemalloc;
                         psh->handler = &jmploc;
                         if (!setjmp(jmploc.loc)) {
@@ -930 +932 @@
                                 listsetvar(psh, args->varlist.list,
                                         args->cmdentry.cmdtype == CMDSPLBLTIN ? 0 : VNOSET);
+                                psh->commandnamemalloc = 0;
                                 psh->commandname = args->argv[0];
                                 /* initialize nextopt */
@@ -962 +965 @@
                         if (e != EXSHELLPROC) {
                                 psh->commandname = savecmdname;
+                                psh->commandnamemalloc = savecmdnamemalloc;
                                 if (args->flags & EV_EXIT)
                                         exitshell(psh, psh->exitstatus);
                         }
+                        if (savecmdnamemalloc)
+                                sh_free(psh, savecmdname);
                         if (e != -1) {
                                 if ((e != EXERROR && e != EXEXEC)

trunk/src/kash/exec.c

@@ -45 +45 @@
 #include <stdio.h>
 #include <stdlib.h>
+#include <stddef.h>
 
 /*
@@ -112 +113 @@
 extern char *const parsekwd[];
 
+#ifndef SH_FORKED_MODE
+void
+subshellinitexec(shinstance *psh, shinstance *inherit)
+{
+    unsigned i;
+    for (i = 0; i < K_ELEMENTS(inherit->cmdtable); i++) {
+        struct tblentry const *csrc = inherit->cmdtable[i];
+        if (!csrc) {
+        } else {
+            struct tblentry **ppdst = &psh->cmdtable[i];
+            do
+            {
+                size_t const namesize = strlen(csrc->cmdname) + 1;
+                size_t const entrysize = offsetof(struct tblentry, cmdname) + namesize;
+                struct tblentry *dst = (struct tblentry *)ckmalloc(psh, entrysize);
+                memcpy(dst->cmdname, csrc->cmdname, namesize);
+                dst->rehash = csrc->rehash;
+                dst->cmdtype = csrc->cmdtype;
+
+                dst->param.func = NULL;
+                switch (csrc->cmdtype) {
+                case CMDUNKNOWN:
+                case CMDNORMAL:
+                    dst->param.index = csrc->param.index;
+                    break;
+                case CMDFUNCTION:
+                    dst->param.func = copyfunc(psh, csrc->param.func); /** @todo optimize function allocations */
+                    break;
+                case CMDBUILTIN:
+                case CMDSPLBLTIN:
+                    dst->param.bltin = csrc->param.bltin;
+                    break;
+                }
+
+                *ppdst = dst;
+                ppdst = &dst->next;
+
+                csrc = csrc->next;
+            } while (csrc);
+            *ppdst = NULL;
+        }
+    }
+
+    psh->builtinloc = inherit->builtinloc;
+}
+#endif /* SH_FORKED_MODE */
+
+
 /*
  * Exec a program.  Never returns.  If you change this routine, you may
@@ -222 +271 @@
                 initshellproc(psh);
                 setinputfile(psh, cmd, 0);
+                if (psh->commandnamemalloc) {
+                    sh_free(psh, psh->commandname);
+                    psh->commandnamemalloc = 0;
+                }
+                if (psh->arg0malloc)
+                    sh_free(psh, psh->arg0);
                 psh->commandname = psh->arg0 = savestr(psh, argv[0]);
+                psh->arg0malloc = 1;
 #ifdef EXEC_HASH_BANG_SCRIPT
                 pgetc(psh); pungetc(psh);               /* fill up input buffer */

trunk/src/kash/exec.h

@@ -71 +71 @@
 #endif
 
+#ifndef SH_FORKED_MODE
+void subshellinitexec(shinstance *, shinstance *);
+#endif
 SH_NORETURN_1 void shellexec(struct shinstance *, char **, char **, const char *, int) SH_NORETURN_2;
 char *padvance(struct shinstance *, const char **, const char *);

trunk/src/kash/expand.c

@@ -89 +89 @@
 
 STATIC void argstr(shinstance *, char *, int);
+STATIC void expari(shinstance *, int);
 STATIC char *exptilde(shinstance *, char *, int);
 STATIC void expbackq(shinstance *, union node *, int, int);
@@ -106 +107 @@
 STATIC int pmatch(char *, char *, int);
 STATIC char *cvtnum(shinstance *, int, char *);
+STATIC char *cvtnum64(shinstance *, KI64, char *);
 
 /*
@@ -343 +345 @@
  * evaluate, place result in (backed up) result, adjust string position.
  */
-void
+STATIC void
 expari(shinstance *psh, int flag)
 {
@@ -869 +871 @@
         switch (*name) {
         case '$':
+#ifndef SH_FORKED_MODE
+                psh->expdest = cvtnum64(psh, psh->rootpid, psh->expdest);
+                break;
+#else
                 num = psh->rootpid;
                 goto numvar;
+#endif
         case '?':
                 num = psh->exitstatus;
@@ -876 +883 @@
         case '#':
                 num = psh->shellparam.nparam;
-                goto numvar;
-        case '!':
-                num = psh->backgndpid;
 numvar:
                 psh->expdest = cvtnum(psh, num, psh->expdest);
                 break;
+        case '!':
+#ifndef SH_FORKED_MODE
+                psh->expdest = cvtnum64(psh, psh->backgndpid, psh->expdest);
+                break;
+#else
+                num = psh->backgndpid;
+                goto numvar;
+#endif
         case '-':
                 for (i = 0; psh->optlist[i].name; i++) {
@@ -1561 +1573 @@
 }
 
+STATIC char *
+cvtnum64(shinstance *psh, KI64 num, char *buf)
+{
+        char temp[32];
+        int neg = num < 0;
+        char *p = temp + 31;
+
+        temp[31] = '\0';
+
+        do {
+                *--p = num % 10 + '0';
+        } while ((num /= 10) != 0);
+
+        if (neg)
+                *--p = '-';
+
+        while (*p)
+                STPUTC(psh, *p++, buf);
+        return buf;
+}
+
 /*
  * Do most of the work for wordexp(3).

trunk/src/kash/expand.h

@@ -65 +65 @@
 void expandhere(struct shinstance *, union node *, int);
 void expandarg(struct shinstance *, union node *, struct arglist *, int);
-void expari(struct shinstance *, int);
 int patmatch(struct shinstance *, char *, char *, int);
 void rmescapes(struct shinstance *, char *);

trunk/src/kash/jobs.c

@@ -64 +64 @@
 #include "error.h"
 #include "mystring.h"
+#include "init.h"
 #include "shinstance.h"
 
@@ -79 +80 @@
 STATIC void freejob(shinstance *, struct job *);
 STATIC struct job *getjob(shinstance *, const char *, int);
-STATIC int dowait(shinstance *, int, struct job *);
-STATIC int waitproc(shinstance *, int, struct job *, int *);
+STATIC shpid dowait(shinstance *, int, struct job *);
+STATIC shpid waitproc(shinstance *, int, struct job *, int *);
 STATIC void cmdtxt(shinstance *, union node *);
 STATIC void cmdlist(shinstance *, union node *, int);
 STATIC void cmdputs(shinstance *, const char *);
+STATIC shpid forkparent(shinstance *psh, struct job *jp, union node *n, int mode, shpid pid);
+STATIC void forkchild(shinstance *psh, shpid pgrp, union node *n, int mode);
 #ifdef KASH_USE_FORKSHELL2
-static int forkparent(shinstance *psh, struct job *jp, union node *n, int mode, pid_t pid);
-static void forkchild(shinstance *psh, struct job *jp, union node *n, int mode);
+# ifndef SH_FORKED_MODE
+struct forkshell2args
+{
+        shinstance *psh;
+        int mode;
+        shpid pgrp;     /**< The forkchild() pgrp argument (-1 if not in group). */
+        union node *n;
+        void *argp;     /**< Points to child callback data following this structure. */
+        int (* child)(shinstance *, union node *, void *);
+        struct stackmark smark; /* do we need this? */
+};
+static int forkshell2_thread(shinstance *psh, void *argp);
+# endif
 #endif
 
@@ -328 +342 @@
         if (mode & SHOW_PGID) {
                 /* just output process (group) id of pipeline */
-                outfmt(out, "%ld\n", (long)jp->ps->pid);
+                outfmt(out, "%" SHPID_PRI "\n", jp->ps->pid);
                 return;
         }
@@ -382 +396 @@
                 col = strlen(s);
                 if (mode & SHOW_PID) {
-                        fmtstr(s + col, 16, "%ld ", (long)ps->pid);
+                        fmtstr(s + col, 16, "%" SHPID_PRI " ", ps->pid);
                              col += strlen(s + col);
                 }
@@ -475 +489 @@
         int jobno;
         struct job *jp;
-        int silent = 0, gotpid;
+        int silent = 0;
+        shpid gotpid;
 
         TRACE((psh, "showjobs(%x) called\n", mode));
@@ -607 +622 @@
         jp = getjob(psh, *psh->argptr, 0);
         for (i = 0 ; i < jp->nprocs ; ) {
-                out1fmt(psh, "%ld", (long)jp->ps[i].pid);
+                out1fmt(psh, "%" SHPID_PRI, jp->ps[i].pid);
                 out1c(psh, ++i < jp->nprocs ? ' ' : '\n');
         }
@@ -613 +628 @@
 }
 
-int
+shpid
 getjobpgrp(shinstance *psh, const char *name)
 {
@@ -785 +800 @@
 
 #ifndef KASH_USE_FORKSHELL2
-int
+shpid
 forkshell(shinstance *psh, struct job *jp, union node *n, int mode)
 {
@@ -798 +813 @@
                 return -1; /* won't get here */
         case 0:
-                forkchild(psh, jp, n, mode);
+                forkchild(psh, jp == NULL || jp->nprocs == 0 ? -1 : jp->ps[0].pid, n, mode);
                 return 0;
         default:
@@ -805 +820 @@
 }
 #else /* KASH_USE_FORKSHELL2 */
-int forkshell2(struct shinstance *psh, struct job *jp, union node *n, int mode,
+shpid
+forkshell2(shinstance *psh, struct job *jp, union node *n, int mode,
                int (*child)(struct shinstance *, void *, union node *),
                union node *nchild, void *argp, size_t arglen,
                void (*setupchild)(struct shinstance *, struct shinstance *, void *))
 {
-        pid_t pid;
-
-        TRACE((psh, "forkshell2(%%%d, %p, %d, %p, %p, %p, %d) called\n", jp - psh->jobtab, n, mode, child, nchild, argp, (int)arglen));
+        shpid pid;
+
+# ifdef SH_FORKED_MODE
+        /*
+         * fork variant.
+         */
         pid = sh_fork(psh);
         if (pid == 0)
         {
                 /* child */
-                forkchild(psh, jp, n, mode);
-                sh_exit(psh, child(psh, nchild, argp));
+                forkchild(psh, jp == NULL || jp->nprocs == 0 ? -1 : jp->ps[0].pid, n, mode);
+                sh__exit(psh, child(psh, nchild, argp));
                 return 0;
         }
@@ -831 +850 @@
         error(psh, "Cannot fork");
         return -1; /* won't get here */
-}
-#endif
-
-#ifdef KASH_USE_FORKSHELL2
-static
-#endif
-int
-forkparent(shinstance *psh, struct job *jp, union node *n, int mode, pid_t pid)
-{
-        int pgrp;
+
+# else
+        /*
+         * Clone the shell and start a thread to service the subshell.
+         */
+        struct shinstance *pshchild;
+
+        TRACE((psh, "forkshell2(%%%d, %p, %d, %p, %p, %p, %d) called\n",
+                   jp - psh->jobtab, n, mode, child, nchild, argp, (int)arglen));
+
+        pshchild = sh_create_child_shell(psh);
+        if (pshchild) {
+                /* pack arguments */
+                struct forkshell2args *args = (struct forkshell2args *)sh_calloc(pshchild, sizeof(*args) + arglen, 1);
+                args->psh = pshchild;
+                args->argp = memcpy(args + 1, argp, arglen);
+                args->child = child;
+                args->mode = mode;
+                args->pgrp = jp == NULL || jp->nprocs == 0 ? -1 : jp->ps[0].pid;
+                setstackmark(pshchild, &args->smark);
+                args->n = copyparsetree(pshchild, n);
+                if (setupchild)
+                        setupchild(pshchild, psh, args->argp);
+
+                /* start the thread */
+                pid = sh_thread_start(psh, pshchild, forkshell2_thread, args);
+                if (pid >= 0)
+                        return forkparent(psh, jp, n, mode, pid);
+                error(psh, "sh_start_child_thread failed (%d)!", (int)pid);
+        }
+        else
+                error(psh, "sh_create_child_shell failed!");
+        return -1;
+# endif
+}
+#endif
+
+static shpid
+forkparent(shinstance *psh, struct job *jp, union node *n, int mode, shpid pid)
+{
+        shpid pgrp;
 
         if (psh->rootshell && mode != FORK_NOJOB && mflag(psh)) {
@@ -860 +910 @@
                         commandtext(psh, ps, n);
         }
-        TRACE((psh, "In parent shell:  child = %d\n", pid));
+        TRACE((psh, "In parent shell:  child = %" SHPID_PRI "\n", pid));
         return pid;
 }
 
-#ifdef KASH_USE_FORKSHELL2
-static
-#endif
-void
-forkchild(shinstance *psh, struct job *jp, union node *n, int mode)
+static void
+forkchild(shinstance *psh, shpid pgrp, union node *n, int mode)
 {
         int wasroot;
-        int pgrp;
         const char *devnull = _PATH_DEVNULL;
         const char *nullerr = "Can't open %s";
 
         wasroot = psh->rootshell;
-        TRACE((psh, "Child shell %d\n", sh_getpid(psh)));
+        TRACE((psh, "Child shell %" SHPID_PRI "\n", sh_getpid(psh)));
         psh->rootshell = 0;
 
@@ -884 +930 @@
         psh->jobctl = 0;                /* do job control only in root shell */
         if (wasroot && mode != FORK_NOJOB && mflag(psh)) {
-                if (jp == NULL || jp->nprocs == 0)
+                if (pgrp == -1)
                         pgrp = sh_getpid(psh);
-                else
-                        pgrp = jp->ps[0].pid;
                 /* This can fail because we are doing it in the parent also.
                    And we must ignore SIGTTOU at this point or we'll be stopped! */
@@ -898 +942 @@
                 setsignal(psh, SIGTSTP);
                 setsignal(psh, SIGTTOU);
-        } else if (mode == FORK_BG) {
+        } else
+#endif
+        if (mode == FORK_BG) {
                 ignoresig(psh, SIGINT);
                 ignoresig(psh, SIGQUIT);
-                if ((jp == NULL || jp->nprocs == 0) &&
-                    ! fd0_redirected_p(psh)) {
+                if (pgrp == -1 && ! fd0_redirected_p(psh)) {
                         shfile_close(&psh->fdtab, 0);
                         if (shfile_open(&psh->fdtab, devnull, O_RDONLY, 0) != 0)
@@ -908 +953 @@
                 }
         }
-#else
-        if (mode == FORK_BG) {
-                ignoresig(psh, SIGINT);
-                ignoresig(psh, SIGQUIT);
-                if ((jp == NULL || jp->nprocs == 0) &&
-                    ! fd0_redirected_p(psh)) {
-                        shfile_close(&psh->fdtab, 0);
-                        if (shfile_open(&psh->fdtab, devnull, O_RDONLY, 0) != 0)
-                                error(psh, nullerr, devnull);
-                }
-        }
-#endif
         if (wasroot && iflag(psh)) {
                 setsignal(psh, SIGINT);
@@ -928 +961 @@
         psh->jobs_invalid = 1;
 }
+
+#if defined(KASH_USE_FORKSHELL2) && !defined(SH_FORKED_MODE)
+/** thread procedure */
+static int forkshell2_thread(shinstance *psh, void *argp)
+{
+        struct forkshell2args * volatile volargs = (struct forkshell2args *)argp;
+        struct jmploc jmp;
+        TRACE2((psh, "forkshell2_thread:\n"));
+
+        if (setjmp(jmp.loc) == 0) {
+                struct forkshell2args * const args = volargs;
+
+                forkchild(psh, args->pgrp, args->n, args->mode);
+
+                psh->handler = &jmp;
+                return args->child(psh, args->n, args->argp);
+        }
+
+        /*
+         * (We longjmp'ed here.)
+         *
+         * This is copied from main() and simplified:
+         */
+        for (;;) {
+                psh = volargs->psh; /* longjmp paranoia */
+
+                if (psh->exception != EXSHELLPROC) {
+                        if (psh->exception == EXEXEC)
+                                psh->exitstatus = psh->exerrno;
+                        else if (psh->exception == EXERROR)
+                                psh->exitstatus = 2;
+                        TRACE2((psh, "forkshell2_thread: exception=%d -> exitshell2(,%d)\n", psh->exception, psh->exitstatus));
+                        return exitshell2(psh, psh->exitstatus);
+                }
+
+                /* EXSHELLPROC - tryexec gets us here and it wants to run a program
+                   hoping (?) it's a shell script.  We must reset the shell state and
+                   turn ourselves into a root shell before doing so. */
+                TRACE2((psh, "forkshell2_thread: exception=EXSHELLPROC\n"));
+                psh->rootpid = /*getpid()*/ psh->pid;
+                psh->rootshell = 1;
+                psh->minusc = NULL;
+
+                reset(psh);
+                popstackmark(psh, &volargs->smark);
+
+                FORCEINTON;                             /* enable interrupts */
+
+                /* state3: */
+                if (sflag(psh) == 0) {
+# ifdef SIGTSTP
+                        static int sigs[] =  { SIGINT, SIGQUIT, SIGHUP, SIGPIPE, SIGTSTP };
+# else
+                        static int sigs[] =  { SIGINT, SIGQUIT, SIGHUP, SIGPIPE };
+# endif
+                        unsigned i;
+                        for (i = 0; i < K_ELEMENTS(sigs); i++)
+                                setsignal(psh, sigs[i]);
+                }
+
+                if (setjmp(jmp.loc) == 0) {
+                        psh->handler = &jmp;
+                        cmdloop(psh, 1);
+                        TRACE2((psh, "forkshell2_thread: cmdloop returned -> exitshell2(,%d)\n", psh->exitstatus));
+                        return exitshell2(psh, psh->exitstatus);
+                }
+        }
+}
+#endif
+
 
 /*
@@ -952 +1055 @@
 {
 #if JOBS
-        int mypgrp = sh_getpgrp(psh);
+        shpid mypgrp = sh_getpgrp(psh);
 #endif
         int status;
@@ -1009 +1112 @@
  */
 
-STATIC int
+STATIC shpid
 dowait(shinstance *psh, int block, struct job *job)
 {
-        int pid;
+        shpid pid;
         int status;
         struct procstat *sp;
@@ -1023 +1126 @@
         do {
                 pid = waitproc(psh, block, job, &status);
-                TRACE((psh, "wait returns pid %d, status %d\n", pid, status));
+                TRACE((psh, "wait returns pid %" SHPID_PRI ", status %d\n", pid, status));
         } while (pid == -1 && errno == EINTR && psh->gotsig[SIGINT - 1] == 0);
         if (pid <= 0)
@@ -1037 +1140 @@
                                         continue;
                                 if (sp->pid == pid) {
-                                        TRACE((psh, "Job %d: changing status of proc %d from 0x%x to 0x%x\n", jp - psh->jobtab + 1, pid, sp->status, status));
+                                        TRACE((psh, "Job %d: changing status of proc %" SHPID_PRI " from 0x%x to 0x%x\n",
+                                                   jp - psh->jobtab + 1, pid, sp->status, status));
                                         sp->status = status;
                                         thisjob = jp;
@@ -1086 +1190 @@
  * rather than blocking.
  */
-STATIC int
+STATIC shpid
 waitproc(shinstance *psh, int block, struct job *jp, int *status)
 {

trunk/src/kash/jobs.h

@@ -42 +42 @@
 #define FORK_NOJOB 2
 
+#define FORK_JUST_IO 4          /* forking I/O subprocess/thread (here doc). */
+
 /* mode flags for showjob(s) */
 #define SHOW_PGID       0x01    /* only show pgid - for jobs -p */
@@ -61 +63 @@
 
 struct procstat {
-        pid_t   pid;            /* process id */
+        shpid   pid;            /* process id */
         int     status;         /* last process status from wait() */
         char    cmd[MAXCMDTEXT];/* text of command being run */
@@ -70 +72 @@
         struct procstat *ps;    /* status or processes when more than one */
         int     nprocs;         /* number of processes */
-        pid_t   pgrp;           /* process group of this job */
+        shpid   pgrp;           /* process group of this job */ /**< @todo is job:pgrp used anywhere? */
         char    state;
 #define JOBRUNNING      0       /* at least one proc running */
@@ -96 +98 @@
 struct job *makejob(struct shinstance *, union node *, int);
 #ifdef KASH_USE_FORKSHELL2
-int forkshell2(struct shinstance *, struct job *, union node *, int,
-               int (*child)(struct shinstance *, void *, union node *),
-               union node *, void *, size_t,
-               void (*setupchild)(struct shinstance *, struct shinstance *, void *));
+shpid forkshell2(struct shinstance *, struct job *, union node *, int,
+                 int (*child)(struct shinstance *, void *, union node *),
+                 union node *, void *, size_t,
+                 void (*setupchild)(struct shinstance *, struct shinstance *, void *));
 #else
-int forkshell(struct shinstance *, struct job *, union node *, int);
-void forkchild(struct shinstance *, struct job *, union node *, int);
-int forkparent(struct shinstance *, struct job *, union node *, int, pid_t);
+shpid forkshell(struct shinstance *, struct job *, union node *, int);
 #endif
 int waitforjob(struct shinstance *, struct job *);
 int stoppedjobs(struct shinstance *);
 void commandtext(struct shinstance *, struct procstat *, union node *);
-int getjobpgrp(struct shinstance *, const char *);
+shpid getjobpgrp(struct shinstance *, const char *);
 
 #if ! JOBS

trunk/src/kash/main.c

@@ -45 +45 @@
 #endif
 
+#include <assert.h>
 #include <errno.h>
 #include <stdio.h>
@@ -101 +102 @@
 
 int
-#if K_OS == K_OS_WINDOWS
+#if K_OS == K_OS_WINDOWS && defined(SH_FORKED_MODE)
 real_main(int argc, char **argv, char **envp)
 #else
@@ -130 +131 @@
          * Create the root shell instance.
          */
-        psh = sh_create_root_shell(NULL, argc, argv, envp);
+        psh = sh_create_root_shell(argv, envp);
         if (!psh)
                 return 2;
         shthread_set_shell(psh);
-        shell_main(psh, argc, psh->argptr);
+        shell_main(psh, argc, psh->orgargv);
         /* Not reached. */
         return 89;
@@ -406 +407 @@
 
         if (argc >= 2) {                /* That's what SVR2 does */
+                char * const savedcommandname = psh->commandname;
+                int const savedcommandnamemalloc = psh->commandnamemalloc;
                 char *fullname;
                 struct stackmark smark;
@@ -413 +416 @@
                 setinputfile(psh, fullname, 1);
                 psh->commandname = fullname;
+                psh->commandnamemalloc = 0;
                 cmdloop(psh, 0);
                 popfile(psh);
+                psh->commandname = savedcommandname;
+                psh->commandnamemalloc = savedcommandnamemalloc;
                 popstackmark(psh, &smark);
         }

trunk/src/kash/options.c

@@ -41 +41 @@
 #endif
 
+#include <assert.h>
 #include <stdlib.h>
 
@@ -77 +78 @@
 STATIC int getopts(shinstance *, char *, char *, char **, char ***, char **);
 
+#ifndef SH_FORKED_MODE
+void
+subshellinitoptions(shinstance *psh, shinstance *inherit)
+{
+    unsigned i;
+    int left;
+    const char *arg;
+    memcpy(&psh->optlist[0], &inherit->optlist[0], sizeof(psh->optlist));
+
+    /** @todo opimize: skip this when executing builtins. */
+    /* Whether the subshell uses argptr/shellparam/arg0 or replaces them depends
+       on whether the shell will execute a builtin command or not.
+
+       orgargv is already set by the shinstance.c core code, scan the original
+       again and update arg0, shellparm, argptr and optptr. */
+
+    /* arg0 is either something from orgargv, or in the EXSHELLPROC case a
+       separate allocation that we need to dupe here. The (new) arg0malloc
+       flag indicates which. */
+    i = 0;
+    psh->arg0malloc = inherit->arg0malloc;
+    if (inherit->arg0malloc) {
+        psh->arg0 = savestr(psh, inherit->arg0);
+    } else {
+        while ((arg = inherit->orgargv[i]) != NULL) {
+            if (inherit->arg0 == arg) {
+                psh->arg0 = psh->orgargv[i];
+                break;
+            }
+            i++;
+        }
+        assert(psh->arg0 != NULL);
+    }
+
+    /* eval.h's commandname is same as arg0 when set unless we're doing a dot-include. */
+    if (inherit->commandname) {
+        if (inherit->commandname == inherit->arg0) {
+            psh->commandname = psh->arg0;
+        } else {
+            psh->commandname = savestr(psh, inherit->commandname);
+            psh->commandnamemalloc = 1;
+        }
+    }
+
+    /* shellparam is either pointing right after arg0 in orgargv, though it may
+       also be a separately allocated thing (see setparam), or pointing to the
+       arguments of a shell function we're executing (see eval.c).  All in all,
+       it's simpler if we just copy the whole darn thing, ASSUMING no
+       modifications will be made that are needed to be visible elsewhere.
+       */
+    psh->shellparam.malloc = 1;
+    psh->shellparam.reset  = inherit->shellparam.reset;
+    psh->shellparam.nparam = left = inherit->shellparam.nparam;
+    assert(left >= 0);
+    psh->shellparam.p = (char **)ckmalloc(psh, left + 1);
+    psh->shellparam.p[left] = NULL;
+    while (left-- > 0) {
+        arg = inherit->shellparam.p[left];
+        psh->shellparam.p[left] = savestr(psh, arg);
+    }
+
+    /* The shellparam.optnext member is either NULL or points to a 'p' entry. */
+    if (inherit->shellparam.optnext) {
+        size_t idx = (size_t)(inherit->shellparam.optnext - inherit->shellparam.p);
+        assert(idx <= inherit->shellparam.nparam);
+        if (idx <= inherit->shellparam.nparam)
+            psh->shellparam.optnext = &psh->shellparam.p[idx];
+    }
+
+    /* The shellparam.optptr member is either NULL or points within argument
+       prior to shellparam.optnext.  We can leave it as NULL if at the EOS. */
+    if (inherit->shellparam.optptr && *inherit->shellparam.optptr != '\0') {
+        intptr_t idx;
+        if (!inherit->shellparam.optnext || inherit->shellparam.optnext == inherit->shellparam.p)
+            idx = (intptr_t)(inherit->shellparam.nparam - 1);
+        else {
+            idx = (intptr_t)(inherit->shellparam.optnext - inherit->shellparam.p - 1);
+            if (idx > inherit->shellparam.nparam)
+                idx = inherit->shellparam.nparam - 1;
+        }
+        while (idx >= 0) {
+            size_t arglen, off;
+            arg = inherit->shellparam.p[idx];
+            arglen = strlen(arg);
+            off = (size_t)(inherit->shellparam.optptr - arg);
+            if (off < arglen) {
+                psh->shellparam.optptr = psh->shellparam.p[idx] + off;
+                break;
+            }
+            off--;
+        }
+        assert(psh->shellparam.optptr != NULL);
+    }
+
+    /* minusc:    only used in main.c, so not applicable to subshells. */
+    /* optionarg: only used by callers of nextopt, so not relevant when forking subhells. */
+}
+#endif /* SH_FORKED_MODE */
+
 
 /*
@@ -105 +205 @@
         debug(psh) = 1;
 #endif
+        psh->commandnamemalloc = 0;
+        psh->arg0malloc = 0;
         psh->arg0 = argv[0];
         if (sflag(psh) == 0 && psh->minusc == NULL) {

trunk/src/kash/options.h

@@ -130 +130 @@
 /*extern char *optptr;*/                /* used by nextopt */
 
+#ifndef SH_FORKED_MODE
+void subshellinitoptions(struct shinstance *, struct shinstance *);
+#endif
 void procargs(struct shinstance *, int, char **);
 void optschanged(struct shinstance *);

trunk/src/kash/output.c

@@ -356 +356 @@
                         f++;
                 }
+#ifdef _MSC_VER  /* for SHPID_PRI / KI64_PRI */
+                else if (*f == 'I' && f[1] == '6' && f[2] == '4') {
+                        isquad++;
+                        f += 3;
+                }
+#endif
                 digit = digit_upper;
                 switch (*f) {

trunk/src/kash/parser.c

@@ -617 +617 @@
 
 void fixredir(shinstance *psh, union node *n, const char *text, int err)
-        {
+{
         TRACE((psh, "Fix redir %s %d\n", text, err));
         if (!err)

trunk/src/kash/redir.c

@@ -288 +288 @@
                 args.pip[1] = pip[1];
                 args.len = len;
-                forkshell2(psh, (struct job *)NULL, (union node *)NULL, FORK_NOJOB,
+                forkshell2(psh, (struct job *)NULL, (union node *)NULL,
+                           FORK_NOJOB | FORK_JUST_IO,
                            openhere_child, redir, &args, sizeof(args), NULL);
         }

trunk/src/kash/shell.h

@@ -94 +94 @@
 #include "shtypes.h"
 
+#ifndef SH_FORKED_MODE
+# ifndef KASH_USE_FORKSHELL2
+#  define KASH_USE_FORKSHELL2
+# endif
 #endif
+
+#endif

trunk/src/kash/shfile.c

@@ -637 +637 @@
 #ifdef SHFILE_IN_USE
         /* Get CWD with unix slashes. */
-        char buf[SHFILE_MAX_PATH];
-        if (getcwd(buf, sizeof(buf)))
-        {
-            shfile_fix_slashes(buf);
-
-            pfdtab->cwd = sh_strdup(NULL, buf);
-            if (!inherit)
+        if (!inherit)
+        {
+            char buf[SHFILE_MAX_PATH];
+            if (getcwd(buf, sizeof(buf)))
+            {
+                shfile_fix_slashes(buf);
+                pfdtab->cwd = sh_strdup(NULL, buf);
+            }
+            if (pfdtab->cwd)
             {
 # if K_OS == K_OS_WINDOWS
@@ -817 +819 @@
             }
             else
+                rc = -1;
+        }
+        else
+        {
+            /*
+             * Inherit from parent shell's file table.
+             */
+            shfile const *src;
+            shfile       *dst;
+            shmtxtmp      tmp;
+            unsigned      fdcount;
+            unsigned      fd;
+
+            shmtx_enter(&inherit->mtx, &tmp);
+
+            /* allocate table and cwd: */
+            fdcount = inherit->size;
+            pfdtab->tab = dst = (shfile *)(fdcount ? sh_calloc(NULL, sizeof(pfdtab->tab[0]), fdcount) : NULL);
+            pfdtab->cwd = sh_strdup(NULL, inherit->cwd);
+            if (   pfdtab->cwd
+                && (pfdtab->tab || fdcount == 0))
             {
-                /** @todo */
-                errno = ENOSYS;
+                /* duplicate table entries: */
+                for (fd = 0, src = inherit->tab; fd < fdcount; fd++, src++, dst++)
+                    if (src->fd == -1)
+                        dst->native = dst->fd = -1;
+                    else
+                    {
+# ifdef SH_FORKED_MODE
+                        KBOOL const cox = !!(src->shflags & SHFILE_FLAGS_CLOSE_ON_EXEC);
+# else
+                        KBOOL const cox = !!(src->shflags & SHFILE_FLAGS_CLOSE_ON_EXEC); /// @todo K_TRUE
+# endif
+                        *dst = *src;
+# if K_OS == K_OS_WINDOWS
+                        if (DuplicateHandle(GetCurrentProcess(),
+                                            (HANDLE)src->native,
+                                            GetCurrentProcess(),
+                                            (HANDLE *)&dst->native,
+                                            0,
+                                            cox ? FALSE : TRUE /* bInheritHandle */,
+                                            DUPLICATE_SAME_ACCESS))
+                            TRACE2((NULL, "shfile_init: %d (%#x, %#x) %p (was %p)\n",
+                                    dst->fd, dst->oflags, dst->shflags, dst->native, src->native));
+                        else
+                        {
+                            dst->native = (intptr_t)INVALID_HANDLE_VALUE;
+                            rc = shfile_dos2errno(GetLastError());
+                            TRACE2((NULL, "shfile_init: %d (%#x, %#x) %p - failed %d / %u!\n",
+                                    dst->fd, dst->oflags, dst->shflags, src->native, rc, GetLastError()));
+                            break;
+                        }
+
+# elif K_OS == K_OS_LINUX /* 2.6.27 / glibc 2.9 */ || K_OS == K_OS_FREEBSD /* 10.0 */ || K_OS == K_OS_NETBSD /* 6.0 */
+                        dst->native = dup3(src->native, -1, cox ? O_CLOEXEC : 0);
+# else
+                        if (cox)
+                        {
+#  ifndef SH_FORKED_MODE
+                            shmtxtmp tmp2;
+                            shmtx_enter(&global_exec_something, &tmp)
+#  endif
+                            dst->native = dup2(src->native, -1);
+                            if (dst->native >= 0)
+                                rc = fcntl(dst->native, F_SETFD, FD_CLOEXEC);
+#  ifndef SH_FORKED_MODE
+                            shmtx_leave(&global_exec_something, &tmp)
+#  endif
+                            if (rc != 0)
+                                break;
+                        }
+                        else
+                            dst->native = dup2(src->native, -1);
+                        if (dst->native < 0)
+                        {
+                            rc = -1;
+                            break;
+                        }
+# endif
+                    }
+            }
+            else
                 rc = -1;
-            }
-        }
-        else
-            rc = -1;
+            pfdtab->size = fd;
+            shmtx_leave(&inherit->mtx, &tmp);
+        }   /* inherit != NULL */
 #endif
     }
@@ -833 +913 @@
 
 /**
- * Changes the inheritability of a file descriptro, taking console handles into
+ * Changes the inheritability of a file descriptor, taking console handles into
  * account.
  *

trunk/src/kash/shfork-win.c

@@ -246 +246 @@
                 if (ResumeThread(ProcInfo.hThread) != (DWORD)-1)
                 {
-                    rc = sh_add_child(psh, ProcInfo.dwProcessId, ProcInfo.hProcess);
+                    rc = sh_add_child(psh, ProcInfo.dwProcessId, ProcInfo.hProcess, K_TRUE);
                     if (!rc)
                         rc = (int)ProcInfo.dwProcessId;

trunk/src/kash/shheap.c

@@ -35 +35 @@
 #include "shinstance.h"
 
-#if K_OS == K_OS_WINDOWS
+#if K_OS == K_OS_WINDOWS && defined(SH_FORKED_MODE)
 # define SHHEAP_IN_USE
 #endif

trunk/src/kash/shinstance.c

@@ -40 +40 @@
 #include "shinstance.h"
 
+#include "alias.h"
+#include "memalloc.h"
+#include "shell.h"
+#include "trap.h"
+
 #if K_OS == K_OS_WINDOWS
 # include <Windows.h>
+# ifdef SH_FORKED_MODE
 extern pid_t shfork_do(shinstance *psh); /* shforkA-win.asm */
+# endif
 #endif
 
@@ -174 +181 @@
 static void sh_destroy(shinstance *psh)
 {
+/** @todo finish this...   */
     memset(psh, 0, sizeof(*psh));
     sh_free(NULL, psh);
@@ -221 +229 @@
 
 /**
- * Creates a root shell instance.
- *
- * @param   inherit     The shell to inherit from. If NULL inherit from environment and such.
- * @param   argc        The argument count.
+ * Creates a shell instance, caller must link it.
+ *
+ * @param   inherit     The shell to inherit from, or NULL if root.
  * @param   argv        The argument vector.
  * @param   envp        The environment vector.
+ * @param   parentfdtab File table to inherit from, NULL if root.
  *
  * @returns pointer to root shell on success, NULL on failure.
  */
-shinstance *sh_create_root_shell(shinstance *inherit, int argc, char **argv, char **envp)
+static shinstance *sh_create_shell_common(char **argv, char **envp, shfdtab *parentfdtab)
 {
     shinstance *psh;
-    int i;
 
     /*
@@ -241 +248 @@
     if (psh)
     {
-        /* Init it enough for sh_destroy() to not get upset */
-          /* ... */
+        /* Init it enough for sh_destroy() to not get upset: */
+        /* ... */
 
         /* Call the basic initializers. */
         if (    !sh_clone_string_vector(psh, &psh->shenviron, envp)
-            &&  !sh_clone_string_vector(psh, &psh->argptr, argv)
-            &&  !shfile_init(&psh->fdtab, inherit ? &inherit->fdtab : NULL))
-        {
-            /* the special stuff. */
-#ifdef _MSC_VER
-            psh->pid = _getpid();
+            &&  !sh_clone_string_vector(psh, &psh->orgargv, argv)
+            &&  !shfile_init(&psh->fdtab, parentfdtab))
+        {
+            unsigned i;
+
+            /*
+             * The special stuff.
+             */
+#ifdef _MSC_VER
+            psh->pgid = psh->pid = _getpid();
 #else
             psh->pid = getpid();
-#endif
+            psh->pgid = getpgid();
+#endif
+
             /*sh_sigemptyset(&psh->sigrestartset);*/
-            for (i = 0; i < NSIG; i++)
+            for (i = 0; i < K_ELEMENTS(psh->sigactions); i++)
                 psh->sigactions[i].sh_handler = SH_SIG_UNK;
-            if (inherit)
-                psh->sigmask = psh->sigmask;
-            else
-            {
 #if defined(_MSC_VER)
-                sh_sigemptyset(&psh->sigmask);
-#else
-                sigprocmask(SIG_SETMASK, NULL, &psh->sigmask);
-#endif
-            }
+            sh_sigemptyset(&psh->sigmask);
+#else
+            sigprocmask(SIG_SETMASK, NULL, &psh->sigmask);
+#endif
+
+            /*
+             * State initialization.
+             */
+            /* cd.c */
+            psh->getpwd_first = 1;
+
+            /* exec */
+            psh->builtinloc = -1;
 
             /* memalloc.c */
@@ -303 +320 @@
             /* show.c */
             psh->tracefd = -1;
-
-            /* link it. */
-            sh_int_link(psh);
             return psh;
         }
@@ -313 +327 @@
     return NULL;
 }
+
+/**
+ * Creates the root shell instance.
+ *
+ * @param   argv        The argument vector.
+ * @param   envp        The environment vector.
+ *
+ * @returns pointer to root shell on success, NULL on failure.
+ */
+shinstance *sh_create_root_shell(char **argv, char **envp)
+{
+    shinstance *psh = sh_create_shell_common(argv, envp, NULL /*parentfdtab*/);
+    if (psh)
+    {
+        sh_int_link(psh);
+        return psh;
+    }
+    return NULL;
+}
+
+#ifndef SH_FORKED_MODE
+
+/**
+ * Does the inherting from the parent shell instance.
+ */
+static void sh_inherit_from_parent(shinstance *psh, shinstance *inherit)
+{
+    /*
+     * Do the rest of the inheriting.
+     */
+    psh->parent = inherit;
+    psh->pgid = inherit->pgid;
+
+    psh->sigmask = psh->sigmask;
+    /** @todo sigactions?   */
+    /// @todo suppressint?
+
+    /* alises: */
+    subshellinitalias(psh, inherit);
+
+    /* cd.c */
+    psh->getpwd_first = inherit->getpwd_first;
+    if (inherit->curdir)
+        psh->curdir = savestr(psh, inherit->curdir);
+    if (inherit->prevdir)
+        psh->prevdir = savestr(psh, inherit->prevdir);
+
+    /* eval.h */
+    /* psh->commandname - see subshellinitoptions */
+    psh->exitstatus  = inherit->exitstatus;          /// @todo ??
+    psh->back_exitstatus = inherit->back_exitstatus; /// @todo ??
+    psh->funcnest = inherit->funcnest;
+    psh->evalskip = inherit->evalskip;               /// @todo ??
+    psh->skipcount = inherit->skipcount;             /// @todo ??
+
+    /* exec.c */
+    subshellinitexec(psh, inherit);
+
+    /* input.h/input.c - only for the parser and anyway forkchild calls closescript(). */
+
+    /* jobs.h - should backgndpid be -1 in subshells? */
+
+    /* jobs.c -    */
+    psh->jobctl = inherit->jobctl;  /// @todo ??
+    psh->initialpgrp = inherit->initialpgrp;
+    psh->ttyfd = inherit->ttyfd;
+    /** @todo copy jobtab so the 'jobs' command can be run in a subshell.
+     *  Better, make it follow the parent chain and skip the copying.  Will
+     *  require some kind of job locking. */
+
+    /* mail.c - nothing (for now at least) */
+
+    /* main.h */
+    psh->rootpid = inherit->rootpid;
+    psh->psh_rootshell = inherit->psh_rootshell;
+
+    /* memalloc.h / memalloc.c - nothing. */
+
+    /* myhistedit.h  */ /** @todo copy history? Do we need to care? */
+
+    /* output.h */ /** @todo not sure this is possible/relevant for subshells */
+    psh->output.fd = inherit->output.fd;
+    psh->errout.fd = inherit->errout.fd;
+    if (inherit->out1 == &inherit->memout)
+        psh->out1 = &psh->memout;
+    if (inherit->out2 == &inherit->memout)
+        psh->out2 = &psh->memout;
+
+    /* options.h */
+    subshellinitoptions(psh, inherit);
+
+    /* parse.h/parse.c */
+    psh->whichprompt = inherit->whichprompt;
+    /* tokpushback, doprompt and needprompt shouldn't really matter, parsecmd resets thems. */
+    /* The rest are internal to the parser, as I see them, and can be ignored. */
+
+    /* redir.c - we shouldn't sub-shell with redirlist as non-NULL, I think.  */
+    assert(inherit->redirlist == NULL);
+    assert(inherit->fd0_redirected == 0); /* (follows from redirlist == NULL) */
+
+    /* show.c */
+    psh->tracefd = inherit->tracefd;
+
+    /* trap.h / trap.c */ /** @todo we don't carry pendingsigs to the subshell, right? */
+    subshellinittrap(psh, inherit);
+
+    /* var.h */
+    subshellinitvar(psh, inherit);
+}
+
+/**
+ * Creates a child shell instance.
+ *
+ * @param   inherit     The shell to inherit from.
+ *
+ * @returns pointer to root shell on success, NULL on failure.
+ */
+shinstance *sh_create_child_shell(shinstance *inherit)
+{
+    shinstance *psh = sh_create_shell_common(inherit->orgargv, inherit->shenviron, &inherit->fdtab);
+    if (psh)
+    {
+        /* Fake a pid for the child: */
+        static unsigned volatile s_cShells = 0;
+        int const iSubShell = ++s_cShells;
+        psh->pid = SHPID_MAKE(SHPID_GET_PID(inherit->pid), iSubShell);
+
+        sh_inherit_from_parent(psh, inherit);
+
+        /* link it */
+        sh_int_link(psh);
+        return psh;
+    }
+    return NULL;
+}
+
+#endif /* !SH_FORKED_MODE */
 
 /** getenv() */
@@ -777 +928 @@
 }
 
-int sh_kill(shinstance *psh, pid_t pid, int signo)
+int sh_kill(shinstance *psh, shpid pid, int signo)
 {
     shinstance *pshDst;
@@ -793 +944 @@
         if (pshDst->pid == pid)
         {
-            TRACE2((psh, "sh_kill(%d, %d): pshDst=%p\n", pid, signo, pshDst));
+            TRACE2((psh, "sh_kill(%" SHPID_PRI ", %d): pshDst=%p\n", pid, signo, pshDst));
             sh_sig_do_signal(psh, pshDst, signo, 1 /* locked */);
 
@@ -807 +958 @@
      * Some other process, call kill where possible
      */
-#if defined(SH_FORKED_MODE)
-# ifdef _MSC_VER
+#ifdef _MSC_VER
     errno = ENOSYS;
     rc = -1;
-# else
+#elif defined(SH_FORKED_MODE)
 /*    fprintf(stderr, "kill(%d, %d)\n", pid, signo);*/
     rc = kill(pid, signo);
-# endif
-
-#else
+#else
+# error "PORT ME?"
 #endif
 
@@ -823 +972 @@
 }
 
-int sh_killpg(shinstance *psh, pid_t pgid, int signo)
-{
+int sh_killpg(shinstance *psh, shpid pgid, int signo)
+{
+    shinstance *pshDst;
+    shmtxtmp tmp;
     int rc;
 
-#if defined(SH_FORKED_MODE)
-# ifdef _MSC_VER
+    /*
+     * Self or any of the subshells?
+     */
+    shmtx_enter(&g_sh_mtx, &tmp);
+
+    pshDst = g_sh_tail;
+    while (pshDst != NULL)
+    {
+        if (pshDst->pgid == pgid)
+        {
+            TRACE2((psh, "sh_killpg(%" SHPID_PRI ", %d): pshDst=%p\n", pgid, signo, pshDst));
+            sh_sig_do_signal(psh, pshDst, signo, 1 /* locked */);
+
+            shmtx_leave(&g_sh_mtx, &tmp);
+            return 0;
+        }
+        pshDst = pshDst->prev;
+    }
+
+    shmtx_leave(&g_sh_mtx, &tmp);
+
+#ifdef _MSC_VER
     errno = ENOSYS;
     rc = -1;
-# else
+#elif defined(SH_FORKED_MODE)
     //fprintf(stderr, "killpg(%d, %d)\n", pgid, signo);
     rc = killpg(pgid, signo);
-# endif
-
-#else
-#endif
-
-    TRACE2((psh, "sh_killpg(%d, %d) -> %d [%d]\n", pgid, signo, rc, errno));
+#else
+# error "PORTME?"
+#endif
+
+    TRACE2((psh, "sh_killpg(%" SHPID_PRI ", %d) -> %d [%d]\n", pgid, signo, rc, errno));
     (void)psh;
     return rc;
@@ -846 +1016 @@
 clock_t sh_times(shinstance *psh, shtms *tmsp)
 {
-#if defined(SH_FORKED_MODE)
-    (void)psh;
-# ifdef _MSC_VER
+#ifdef _MSC_VER
     errno = ENOSYS;
     return (clock_t)-1;
-# else
+#elif defined(SH_FORKED_MODE)
+    (void)psh;
     return times(tmsp);
-# endif
-
-#else
+#else
+# error "PORTME"
 #endif
 }
@@ -873 +1041 @@
  * @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.
+ * @param   psh         The shell instance.
+ * @param   pid         The child pid.
+ * @param   hChild      Windows child handle.
+ * @param   fProcess    Set if process, clear if thread.
  */
-int sh_add_child(shinstance *psh, pid_t pid, void *hChild)
+int sh_add_child(shinstance *psh, shpid pid, void *hChild, KBOOL fProcess)
 {
     /* get a free table entry. */
@@ -898 +1067 @@
     psh->children[i].hChild = hChild;
 #endif
-    (void)hChild;
+#ifndef SH_FORKED_MODE
+    psh->children[i].fProcess = fProcess;
+#endif
+    (void)hChild; (void)fProcess;
     return 0;
 }
+
+#ifdef SH_FORKED_MODE
 
 pid_t sh_fork(shinstance *psh)
@@ -938 +1112 @@
 }
 
+#else  /* !SH_FORKED_MODE */
+
+# ifdef _MSC_VER
+/** Thread wrapper procedure. */
+static unsigned __stdcall sh_thread_wrapper(void *user)
+{
+    shinstance *psh = (shinstance *)user;
+    int iExit;
+
+    /* Update the TID and PID (racing sh_thread_start) */
+    DWORD tid = GetCurrentThreadId();
+    shpid pid = GetCurrentProcessId();
+
+    pid = SHPID_MAKE(pid, tid);
+    psh->pid = pid;
+    psh->tid = tid;
+
+    /* Set the TLS entry before we try TRACE or TRACE2. */
+    shthread_set_shell(psh);
+
+    TRACE2((psh, "sh_thread_wrapper: enter\n"));
+    iExit = psh->thread(psh, psh->threadarg);
+/** @todo do shell cleanup. */
+    TRACE2((psh, "sh_thread_wrapper: quits - iExit=%d\n", iExit));
+
+    _endthreadex(iExit);
+    return iExit;
+}
+# else
+#  error "PORTME"
+# endif
+
+/**
+ * Starts a sub-shell thread.
+ */
+shpid sh_thread_start(shinstance *pshparent, shinstance *pshchild, int (*thread)(shinstance *, void *), void *arg)
+{
+# ifdef _MSC_VER
+    unsigned tid = 0;
+    uintptr_t hThread;
+    shpid pid;
+
+    pshchild->thread    = thread;
+    pshchild->threadarg = arg;
+    hThread = _beginthreadex(NULL /*security*/, 0 /*stack_size*/, sh_thread_wrapper, pshchild, 0 /*initflags*/, &tid);
+    if (hThread == -1)
+        return -errno;
+
+    pid = SHPID_MAKE(SHPID_GET_PID(pshparent->pid), tid);
+    pshchild->pid = pid;
+    pshchild->tid = tid;
+
+    if (sh_add_child(pshparent, pid, (void *)hThread, K_FALSE) != 0) {
+        return -ENOMEM;
+    }
+    return pid;
+
+# else
+#  error "PORTME"
+# endif
+}
+
+#endif /* !SH_FORKED_MODE */
+
 /** waitpid() */
-pid_t sh_waitpid(shinstance *psh, pid_t pid, int *statusp, int flags)
-{
-    pid_t pidret;
+shpid sh_waitpid(shinstance *psh, shpid pid, int *statusp, int flags)
+{
+    shpid   pidret;
 #if K_OS == K_OS_WINDOWS //&& defined(SH_FORKED_MODE)
     DWORD   dwRet;
@@ -1015 +1253 @@
         {
             DWORD dwExitCode = 127;
+#ifndef SH_FORKED_MODE
+            if (psh->children[i].fProcess ? GetExitCodeProcess(hChild, &dwExitCode) : GetExitCodeThread(hChild, &dwExitCode))
+#else
             if (GetExitCodeProcess(hChild, &dwExitCode))
+#endif
             {
                 pidret = psh->children[i].pid;
@@ -1046 +1288 @@
 #endif
 
-    TRACE2((psh, "waitpid(%d, %p, %#x) -> %d [%d] *statusp=%#x (rc=%d)\n", pid, statusp, flags,
+    TRACE2((psh, "waitpid(%" SHPID_PRI ", %p, %#x) -> %" SHPID_PRI " [%d] *statusp=%#x (rc=%d)\n", pid, statusp, flags,
             pidret, errno, *statusp, WEXITSTATUS(*statusp)));
     (void)psh;
@@ -1282 +1524 @@
 uid_t sh_getuid(shinstance *psh)
 {
-#if defined(SH_FORKED_MODE)
-# ifdef _MSC_VER
+#ifdef _MSC_VER
     uid_t uid = 0;
-# else
+#else
     uid_t uid = getuid();
-# endif
-
-#else
 #endif
 
@@ -1299 +1537 @@
 uid_t sh_geteuid(shinstance *psh)
 {
-#if defined(SH_FORKED_MODE)
-# ifdef _MSC_VER
+#ifdef _MSC_VER
     uid_t euid = 0;
-# else
+#else
     uid_t euid = geteuid();
-# endif
-
-#else
 #endif
 
@@ -1316 +1550 @@
 gid_t sh_getgid(shinstance *psh)
 {
-#if defined(SH_FORKED_MODE)
-# ifdef _MSC_VER
+#ifdef _MSC_VER
     gid_t gid = 0;
-# else
+#else
     gid_t gid = getgid();
-# endif
-
-#else
 #endif
 
@@ -1333 +1563 @@
 gid_t sh_getegid(shinstance *psh)
 {
-#if defined(SH_FORKED_MODE)
-# ifdef _MSC_VER
+#ifdef _MSC_VER
     gid_t egid = 0;
-# else
+#else
     gid_t egid = getegid();
-# endif
-
-#else
 #endif
 
@@ -1348 +1574 @@
 }
 
-pid_t sh_getpid(shinstance *psh)
-{
-    pid_t pid;
-
-#if defined(SH_FORKED_MODE)
-# ifdef _MSC_VER
-    pid = _getpid();
-# else
-    pid = getpid();
-# endif
-#else
-#endif
-
+shpid sh_getpid(shinstance *psh)
+{
+    return psh->pid;
+}
+
+shpid sh_getpgrp(shinstance *psh)
+{
+    shpid pgid = psh->pgid;
+#ifndef _MSC_VER
+    assert(pgid == getpgrp());
+#endif
+
+    TRACE2((psh, "sh_getpgrp() -> %" SHPID_PRI " [%d]\n", pgid, errno));
+    return pgid;
+}
+
+/**
+ * @param   pid     Should always be zero, i.e. referring to the current shell
+ *                  process.
+ */
+shpid sh_getpgid(shinstance *psh, shpid pid)
+{
+    shpid pgid;
+    if (pid == 0 || psh->pid == pid)
+    {
+        shpid pgid = psh->pgid;
+#ifndef _MSC_VER
+        assert(pgid == getpgrp());
+#endif
+    }
+    else
+    {
+        assert(0);
+        errno = ESRCH;
+        pgid = -1;
+    }
+
+    TRACE2((psh, "sh_getpgid(%" SHPID_PRI ") -> %" SHPID_PRI " [%d]\n", pid, pgid, errno));
+    return pgid;
+}
+
+/**
+ *
+ * @param   pid     The pid to modify.  This is always 0, except when forkparent
+ *                  calls to group a newly created child.  Though, we might
+ *                  almost safely ignore it in that case as the child will also
+ *                  perform the operation.
+ * @param   pgid    The process group to assign @a pid to.
+ */
+int sh_setpgid(shinstance *psh, shpid pid, shpid pgid)
+{
+#if defined(SH_FORKED_MODE) && !defined(_MSC_VER)
+    int rc = setpgid(pid, pgid);
+    TRACE2((psh, "sh_setpgid(%" SHPID_PRI ", %" SHPID_PRI ") -> %d [%d]\n", pid, pgid, rc, errno));
     (void)psh;
-    return pid;
-}
-
-pid_t sh_getpgrp(shinstance *psh)
-{
-#if defined(SH_FORKED_MODE)
-# ifdef _MSC_VER
-    pid_t pgrp = _getpid();
-# else
-    pid_t pgrp = getpgrp();
-# endif
-
-#else
-#endif
-
-    TRACE2((psh, "sh_getpgrp() -> %d [%d]\n", pgrp, errno));
+#else
+    int rc = 0;
+    if (pid == 0 || psh->pid == pid)
+    {
+        TRACE2((psh, "sh_setpgid(self,): %" SHPID_PRI " -> %" SHPID_PRI "\n", psh->pgid, pgid));
+        psh->pgid = pgid;
+    }
+    else
+    {
+        /** @todo fixme   */
+        rc = -1;
+        errno = ENOSYS;
+    }
+#endif
+    return rc;
+}
+
+shpid sh_tcgetpgrp(shinstance *psh, int fd)
+{
+    shpid pgrp;
+
+#ifdef _MSC_VER
+    pgrp = -1;
+    errno = ENOSYS;
+#elif defined(SH_FORKED_MODE)
+    pgrp = tcgetpgrp(fd);
+#else
+# error "PORT ME"
+#endif
+
+    TRACE2((psh, "sh_tcgetpgrp(%d) -> %" SHPID_PRI " [%d]\n", fd, pgrp, errno));
     (void)psh;
     return pgrp;
 }
 
-pid_t sh_getpgid(shinstance *psh, pid_t pid)
-{
-#if defined(SH_FORKED_MODE)
-# ifdef _MSC_VER
-    pid_t pgid = pid;
-# else
-    pid_t pgid = getpgid(pid);
-# endif
-
-#else
-#endif
-
-    TRACE2((psh, "sh_getpgid(%d) -> %d [%d]\n", pid, pgid, errno));
+int sh_tcsetpgrp(shinstance *psh, int fd, shpid pgrp)
+{
+    int rc;
+    TRACE2((psh, "sh_tcsetpgrp(%d, %" SHPID_PRI ")\n", fd, pgrp));
+
+#ifdef _MSC_VER
+    rc = -1;
+    errno = ENOSYS;
+#elif defined(SH_FORKED_MODE)
+    rc = tcsetpgrp(fd, pgrp);
+#else
+# error "PORT ME"
+#endif
+
+    TRACE2((psh, "sh_tcsetpgrp(%d, %" SHPID_PRI ") -> %d [%d]\n", fd, pgrp, rc, errno));
     (void)psh;
-    return pgid;
-}
-
-int sh_setpgid(shinstance *psh, pid_t pid, pid_t pgid)
-{
-#if defined(SH_FORKED_MODE)
-# ifdef _MSC_VER
+    return rc;
+}
+
+int sh_getrlimit(shinstance *psh, int resid, shrlimit *limp)
+{
+#ifdef _MSC_VER
     int rc = -1;
     errno = ENOSYS;
-# else
-    int rc = setpgid(pid, pgid);
-# endif
-
-#else
-#endif
-
-    TRACE2((psh, "sh_setpgid(%d, %d) -> %d [%d]\n", pid, pgid, rc, errno));
-    (void)psh;
-    return rc;
-}
-
-pid_t sh_tcgetpgrp(shinstance *psh, int fd)
-{
-    pid_t pgrp;
-
-#if defined(SH_FORKED_MODE)
-# ifdef _MSC_VER
-    pgrp = -1;
-    errno = ENOSYS;
-# else
-    pgrp = tcgetpgrp(fd);
-# endif
-
-#else
-#endif
-
-    TRACE2((psh, "sh_tcgetpgrp(%d) -> %d [%d]\n", fd, pgrp, errno));
-    (void)psh;
-    return pgrp;
-}
-
-int sh_tcsetpgrp(shinstance *psh, int fd, pid_t pgrp)
-{
-    int rc;
-    TRACE2((psh, "sh_tcsetpgrp(%d, %d)\n", fd, pgrp));
-
-#if defined(SH_FORKED_MODE)
-# ifdef _MSC_VER
-    rc = -1;
-    errno = ENOSYS;
-# else
-    rc = tcsetpgrp(fd, pgrp);
-# endif
-
-#else
-#endif
-
-    TRACE2((psh, "sh_tcsetpgrp(%d, %d) -> %d [%d]\n", fd, pgrp, rc, errno));
-    (void)psh;
-    return rc;
-}
-
-int sh_getrlimit(shinstance *psh, int resid, shrlimit *limp)
-{
-#if defined(SH_FORKED_MODE)
-# ifdef _MSC_VER
-    int rc = -1;
-    errno = ENOSYS;
-# else
+#elif defined(SH_FORKED_MODE)
     int rc = getrlimit(resid, limp);
-# endif
-
-#else
+#else
+# error "PORT ME"
     /* returned the stored limit */
 #endif
@@ -1480 +1703 @@
 int sh_setrlimit(shinstance *psh, int resid, const shrlimit *limp)
 {
-#if defined(SH_FORKED_MODE)
-# ifdef _MSC_VER
+#ifdef _MSC_VER
     int rc = -1;
     errno = ENOSYS;
-# else
+#elif defined(SH_FORKED_MODE)
     int rc = setrlimit(resid, limp);
-# endif
-
-#else
+#else
+# error "PORT ME"
     /* if max(shell) < limp; then setrlimit; fi
        if success; then store limit for later retrival and maxing. */

trunk/src/kash/shinstance.h

@@ -65 +65 @@
 typedef struct shchild
 {
-    pid_t       pid;                    /**< The pid. */
+    shpid       pid;                    /**< The pid. */
 #if K_OS == K_OS_WINDOWS
     void       *hChild;                 /**< The process handle. */
+#endif
+#ifndef SH_FORKED_MODE
+    KBOOL       fProcess;               /**< Set if process, clear if internal thread. */
 #endif
 } shchild;
@@ -140 +143 @@
     struct shinstance  *prev;           /**< The previous shell instance. */
     struct shinstance  *parent;         /**< The parent shell instance. */
-    pid_t               pid;            /**< The (fake) process id of this shell instance. */
+    shpid               pid;            /**< The (fake) process id of this shell instance. */
     shtid               tid;            /**< The thread identifier of the thread for this shell. */
+    shpid               pgid;           /**< Process group ID. */
     shfdtab             fdtab;          /**< The file descriptor table. */
     shsigaction_t       sigactions[NSIG]; /**< The signal actions registered with this shell instance. */
@@ -148 +152 @@
     int                 num_children;   /**< Number of children in the array. */
     shchild            *children;       /**< The child array. */
+#ifndef SH_FORKED_MODE
+    int (*thread)(struct shinstance *, void *); /**< The thread procedure. */
+    void               *threadarg;      /**< The thread argument. */
+#endif
 
     /* alias.c */
 #define ATABSIZE 39
     struct alias       *atab[ATABSIZE];
+    unsigned            aliases;        /**< Number of active aliases. */
 
     /* cd.c */
@@ -178 +187 @@
     int                 skipcount;      /**< number of levels to skip */
     int                 loopnest;       /**< current loop nesting level */
+    int                 commandnamemalloc; /**< Set if commandname is malloc'ed (only subshells). */
 
     /* expand.c */
@@ -210 +220 @@
 
     /* jobs.h */
-    pid_t               backgndpid/* = -1 */;   /**< pid of last background process */
+    shpid               backgndpid/* = -1 */;   /**< pid of last background process */
     int                 job_warning;    /**< user was warned about stopped jobs */
 
@@ -217 +227 @@
     int                 njobs;          /**< size of array */
     int                 jobs_invalid;   /**< set in child */
-    int                 initialpgrp;    /**< pgrp of shell on invocation */
+    shpid               initialpgrp;    /**< pgrp of shell on invocation */
     int                 curjob/* = -1*/;/**< current job */
     int                 ttyfd/* = -1*/;
@@ -231 +241 @@
 
     /* main.h */
-    int                 rootpid;        /**< pid of main shell. */
+    shpid               rootpid;        /**< pid of main shell. */
     int                 rootshell;      /**< true if we aren't a child of the main shell. */
     struct shinstance  *psh_rootshell;  /**< The root shell pointer. (!rootshell) */
@@ -272 +282 @@
     char               *optionarg;      /**< set by nextopt */
     char               *optptr;         /**< used by nextopt */
+    char              **orgargv;        /**< The original argument vector (for cleanup). */
+    int                 arg0malloc;     /**< Indicates whether arg0 was allocated or is part of orgargv. */
 
     /* parse.h */
@@ -346 +358 @@
 
 
-extern shinstance *sh_create_root_shell(shinstance *, int, char **, char **);
+extern shinstance *sh_create_root_shell(char **, char **);
+extern shinstance *sh_create_child_shell(shinstance *);
 
 /* environment & pwd.h */
@@ -395 +408 @@
 SH_NORETURN_1 void sh_abort(shinstance *) SH_NORETURN_2;
 void sh_raise_sigint(shinstance *);
-int sh_kill(shinstance *, pid_t, int);
-int sh_killpg(shinstance *, pid_t, int);
+int sh_kill(shinstance *, shpid, int);
+int sh_killpg(shinstance *, shpid, int);
 
 /* times */
@@ -416 +429 @@
 
 /* wait / process */
-int sh_add_child(shinstance *psh, pid_t pid, void *hChild);
+int sh_add_child(shinstance *psh, shpid pid, void *hChild, KBOOL fProcess);
 #ifdef _MSC_VER
 #   include <process.h>
@@ -442 +455 @@
 #   endif
 #endif
-pid_t sh_fork(shinstance *);
-pid_t sh_waitpid(shinstance *, pid_t, int *, int);
+#ifdef SH_FORKED_MODE
+shpid sh_fork(shinstance *);
+#else
+shpid sh_thread_start(shinstance *pshparent, shinstance *pshchild, int (*thread)(shinstance *, void *), void *arg);
+#endif
+shpid sh_waitpid(shinstance *, shpid, int *, int);
 SH_NORETURN_1 void sh__exit(shinstance *, int) SH_NORETURN_2;
 int sh_execve(shinstance *, const char *, const char * const*, const char * const *);
@@ -450 +467 @@
 gid_t sh_getgid(shinstance *);
 gid_t sh_getegid(shinstance *);
-pid_t sh_getpid(shinstance *);
-pid_t sh_getpgrp(shinstance *);
-pid_t sh_getpgid(shinstance *, pid_t);
-int sh_setpgid(shinstance *, pid_t, pid_t);
+shpid sh_getpid(shinstance *);
+shpid sh_getpgrp(shinstance *);
+shpid sh_getpgid(shinstance *, shpid);
+int sh_setpgid(shinstance *, shpid, shpid);
 
 /* tc* */
-pid_t sh_tcgetpgrp(shinstance *, int);
-int sh_tcsetpgrp(shinstance *, int, pid_t);
+shpid sh_tcgetpgrp(shinstance *, int);
+int sh_tcsetpgrp(shinstance *, int, shpid);
 
 /* sys/resource.h */

trunk/src/kash/show.c

@@ -299 +299 @@
 
         if (pos) {
-        int     s = errno;
+                int     s = errno;
                 char    prefix[40];
                 size_t  len;
 
-                len = sprintf(prefix, "[%d] ", sh_getpid(psh));
+#ifdef SH_FORKED_MODE
+                len = sprintf(prefix, "[%" SHPID_PRI "] ", sh_getpid(psh));
+#else
+                shpid pid = sh_getpid(psh);
+                len = sprintf(prefix, "[%d/%d] ", SHPID_GET_PID(pid), SHPID_GET_TID(pid));
+#endif
                 shfile_write(&psh->fdtab, psh->tracefd, prefix, len);
                 shfile_write(&psh->fdtab, psh->tracefd, psh->tracebuf, pos);
@@ -310 +315 @@
                 psh->tracebuf[0] = '\0';
 
-        errno = s;
+                errno = s;
         }
 }
@@ -359 +364 @@
                 } else {
                         /* it's too big for some reason... */
-            int s = errno;
+                        int s = errno;
                         trace_flush(psh);
                         shfile_write(&psh->fdtab, psh->tracefd, str, len);
                         if (!flush_it)
                                 shfile_write(&psh->fdtab, psh->tracefd, "[too long]\n", sizeof( "[too long]\n") - 1);
-            errno = s;
+                        errno = s;
                 }
 

trunk/src/kash/shtypes.h

@@ -131 +131 @@
 #endif
 
+/** @name Extra wide pid_t so we can safely add a sub-pid to the top.
+ * @{ */
+#ifndef SH_FORKED_MODE
+typedef KI64 shpid;
+# define SHPID_MAKE(pid, tid)       ((shpid)(KU32)(pid) | (shpid)(KU32)(tid) << 32)
+# define SHPID_GET_PID(shpid)       ((pid_t)(KU32)(shpid))
+# define SHPID_GET_TID(shpid)       ((pid_t)((shpid) >> 32))
+# define SHPID_PRI                  KI64_PRI
+#else
+typedef pid_t shpid;
+# define SHPID_GET_PID(shpid)       (shpid)
+# define SHPID_PRI                  KI32_PRI
+#endif
+/** @}  */
+
 #endif
 

trunk/src/kash/trap.c

@@ -80 +80 @@
 static int getsigaction(shinstance *, int, shsig_t *);
 
+#ifndef SH_FORKED_MODE
+void
+subshellinittrap(shinstance *psh, shinstance *inherit)
+{
+        /* The forkchild calls clear_traps(), we have to emulate that here. */
+        unsigned i;
+        memcpy(psh->sigmode, inherit->sigmode, sizeof(psh->sigmode));
+        for (i = 0; i < K_ELEMENTS(inherit->trap); i++) {
+                const char *src = inherit->trap[i];
+                if (!src) {
+                } else if (i > 0) {
+                        setsignal(psh, i);
+                }
+        }
+}
+#endif
+
+
 /*
  * return the signal number described by `p' (as a number or a name)
@@ -210 +228 @@
                 if (*tp && **tp) {      /* trap not NULL or SIG_IGN */
                         INTOFF;
-                        ckfree(psh, *tp);
-                        *tp = NULL;
+                        ckfree(psh, *tp);
+                        *tp = NULL;
                         if (tp != &psh->trap[0])
                                 setsignal(psh, (int)(tp - psh->trap));
@@ -417 +435 @@
  */
 
-SH_NORETURN_1 void
-exitshell(shinstance *psh, int status)
+int
+exitshell2(shinstance *psh, int status)
 {
         struct jmploc loc1, loc2;
         char *p;
 
-        TRACE((psh, "pid %d, exitshell(%d)\n", sh_getpid(psh), status));
+        TRACE((psh, "pid %" SHPID_PRI ", exitshell(%d)\n", sh_getpid(psh), status));
         if (setjmp(loc1.loc)) {
                 goto l1;
@@ -435 +453 @@
                 evalstring(psh, p, 0);
         }
-l1:   psh->handler = &loc2;                     /* probably unnecessary */
+l1:
+        psh->handler = &loc2;                   /* probably unnecessary */
         output_flushall(psh);
 #if JOBS
         setjobctl(psh, 0);
 #endif
-l2: sh__exit(psh, status);
+l2:
+        return status;
+}
+
+SH_NORETURN_1 void
+exitshell(shinstance *psh, int status)
+{
+        sh__exit(psh, exitshell2(psh, status));
         /* NOTREACHED */
 }
+

trunk/src/kash/trap.h

@@ -37 +37 @@
 /*extern int pendingsigs;*/
 
+#ifndef SH_FORKED_MODE
+void subshellinittrap(shinstance *, shinstance *);
+#endif
 int trapcmd(struct shinstance *, int, char **);
 void clear_traps(struct shinstance *);
@@ -44 +47 @@
 void dotrap(struct shinstance *);
 void setinteractive(struct shinstance *, int);
+int exitshell2(struct shinstance *, int);
 SH_NORETURN_1 void exitshell(struct shinstance *, int) SH_NORETURN_2;
+

trunk/src/kash/var.c

@@ -41 +41 @@
 #endif
 
+#include <assert.h>
 #include <stddef.h>
 #include <stdlib.h>
@@ -270 +271 @@
         }
 }
+
+
+#ifndef SH_FORKED_MODE
+/*
+ * This routine is called to copy variable state from parent to child shell.
+ */
+void
+subshellinitvar(shinstance *psh, shinstance *inherit)
+{
+        unsigned i;
+        for (i = 0; i < K_ELEMENTS(inherit->vartab); i++) {
+                struct var const *vsrc = inherit->vartab[i];
+                if (!vsrc) {
+                } else {
+                        struct var **ppdst = &psh->vartab[i];
+                        do
+                        {
+                                struct var *dst;
+                                if (!(vsrc->flags & VSTRFIXED)) {
+                                        dst = (struct var *)ckmalloc(psh, sizeof(*dst));
+                                } else {
+                                        /* VSTRFIXED is used when the structure is a fixed allocation in
+                                           the shinstance structure, so scan those to find which it is: */
+                                        size_t            left     = ((struct var *)&inherit->vartab[0] - &inherit->vatty);
+                                        struct var const *fixedsrc = &inherit->vatty;
+                                        dst = &psh->vatty;
+                                        while (left-- > 0)
+                                                if (vsrc != fixedsrc) {
+                                                        fixedsrc++;
+                                                        dst++;
+                                                } else
+                                                        break;
+                                        assert(left < 256 /*whatever, just no rollover*/);
+                                }
+                                *dst = *vsrc;
+
+                                if (!(vsrc->flags & VTEXTFIXED)) {
+                                        dst->text = savestr(psh, vsrc->text);
+                                        dst->flags &= ~VSTACK;
+                                }
+
+                                *ppdst = dst;
+                                ppdst = &dst->next;
+
+                                vsrc = vsrc->next;
+                        } while (vsrc);
+                        *ppdst = NULL;
+                }
+        }
+
+        /** @todo We don't always need to copy local variables. */
+        if (inherit->localvars) {
+                struct localvar const *vsrc  = inherit->localvars;
+                struct localvar      **ppdst = &psh->localvars;
+                do
+                {
+                        struct localvar *dst = ckmalloc(psh, sizeof(*dst));
+
+                        dst->flags = vsrc->flags & ~VSTACK;
+                        if (vsrc->flags & VTEXTFIXED)
+                                dst->text = savestr(psh, vsrc->text);
+                        else
+                                dst->text = vsrc->text;
+
+                        dst->vp = find_var(psh, vsrc->vp->text, NULL, NULL);
+                        assert(dst->vp);
+
+                        *ppdst = dst;
+                        ppdst = &dst->next;
+
+                        vsrc = vsrc->next;
+                } while (vsrc);
+        }
+}
+#endif /* !SH_FORKED_MODE */
 
 /*

trunk/src/kash/var.h

@@ -127 +127 @@
 
 void initvar(struct shinstance *);
+#ifndef SH_FORKED_MODE
+void subshellinitvar(shinstance *, shinstance *);
+#endif
 void setvar(struct shinstance *, const char *, const char *, int);
 void setvareq(struct shinstance *, char *, int);