Changeset 3438 for trunk/src/kash/jobs.c

Timestamp:

Sep 9, 2020, 10:01:39 PM (5 years ago)

Author:

bird

Message:

kash: Hammering on threaded mode.

File:

• trunk/src/kash/jobs.c (modified) (21 diffs)

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)
 {