lib/libjcl/run.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 2003-2011 AT&T Intellectual Property          *
*                      and is licensed under the                       *
*                 Eclipse Public License, Version 1.0                  *
*                    by AT&T Intellectual Property                     *
*                                                                      *
*                A copy of the License is available at                 *
*          http://www.eclipse.org/org/documents/epl-v10.html           *
*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *
*                                                                      *
*              Information and Software Systems Research               *
*                            AT&T Research                             *
*                           Florham Park NJ                            *
*                                                                      *
*                 Glenn Fowler <gsf@research.att.com>                  *
*                                                                      *
***********************************************************************/
#pragma prototyped

/*
 * jcl program exec and script loop
 */

#include "jcllib.h"

#include <coshell.h>
#include <errno.h>
#include <ls.h>
#include <tm.h>
#include <tmx.h>

/*
 * if name contains invalid export id chars then
 * return a new name with those chars converted to '_<XX>_'
 */

static char*
fmtexport(const char* name)
{
    register int        c;
    register const char*    s;
    register char*      t;
    register int        n;
    char*           b;

    s = name;
    c = *s++;
    if (isalpha(c) || c == '_')
        do
        {
            if (!(c = *s++))
                return (char*)name;
        } while (isalnum(c) || c == '_');
    n = 1;
    while (c = *s++)
        if (!isalnum(c) && c != '_')
            n++;
    t = b = fmtbuf(strlen(name) + 4 * n + 1);
    for (s = name; c = *s++;)
        if (!isalnum(c) && c != '_')
            t += sfsprintf(t, 5, "_%02X_", c);
        else
            *t++ = c;
    *t = 0;
    return b;
}

/*
 * output dd dsname with &path => /tmp file map
 */

static char*
dsn(Jcl_t* jcl, Jcldd_t* dd, const char* path, int mark)
{
    char*   s;

    if (mark && dd->disp[0] == JCL_DISP_MOD && !(dd->flags & JCL_DD_DIR))
        sfprintf(jcl->vp, "+");
    if (*path == '&')
    {
        if (*++path == '&')
            path++;
        sfprintf(jcl->vp, jcl->tmp);
    }
    sfprintf(jcl->vp, "%s", fmtquote(path, "\"", "\"", strlen(path), FMT_SHELL|FMT_PARAM));
    if (!(s = sfstruse(jcl->vp)))
        nospace(jcl, NiL);
    return s;
}

/*
 * create dd dir if it doesn't exist
 */

static void
checkdir(Jcl_t* jcl, Jcldd_t* dd)
{
    register char*  s;
    Jcldir_t*   dir;

    if (!dtmatch(jcl->outdir, dd->path))
    {
        if (dir = vmnewof(jcl->vm, NiL, Jcldir_t, 1, strlen(dd->path)))
        {
            strcpy(dir->name, dd->path);
            dtinsert(jcl->outdir, dir);
        }
        s = dsn(jcl, dd, dd->path, 0);
        sfprintf(jcl->tp, "[[ ! -d %s && ! -f %s ]] && mkdir -p %s\n", s, s, s);
    }
}

/*
 * execution loop
 */

int
jclrun(Jcl_t* scope)
{
    register Jcl_t*     jcl;
    register Jclstep_t* step;
    register Jcldd_t*   dd;
    register Jclcat_t*  cat;
    register Jclsym_t*  sym;
    register char*      s;
    char*           arg;
    char*           t;
    Coshell_t*      co;
    Cojob_t*        cj;
    Jcldd_t*        xx;
    Jcldd_t*        std[4];
    Dtlink_t        k;
    Jcl_t*          top;
    int         code;
    int         del;
    int         n;
    int         i;
    double          pct;
    double          real;
    double          user;
    double          sys;
    Time_t          start;
    unsigned long       flags;
    char            subdir[64];

    if (!(jcl = jclopen(scope, scope->step->command, scope->flags|scope->step->flags, scope->disc)))
        return -1;
    if (jcl->flags & JCL_EXEC)
    {
        if (!(co = coopen(pathshell(), (jcl->flags & (JCL_EXEC|JCL_TRACE)) == (JCL_EXEC|JCL_TRACE) ? CO_ANY : (CO_ANY|CO_SILENT), NiL)))
        {
            if (jcl->disc->errorf)
                (*jcl->disc->errorf)(NiL, jcl->disc, 2, "%s: cannot connect to coshell", jcl->name);
            jclclose(jcl);
            return -1;
        }
        start = tmxgettime();
        user = co->user;
        sys = co->sys;
    }
    code = 0;
    if (jcl->name && (!scope || !scope->scope || (scope->scope->flags & JCL_SCOPE)))
    {
        top = jcl;
        if (!(jcl->flags & JCL_EXEC))
        {
            if (jcl->flags & JCL_VERBOSE)
                sfprintf(sfstdout, ": JOB %s\nexport %sJOBNAME=%s\ncode=0\n", jcl->name, JCL_AUTO, jcl->name);
            if (jcl->flags & JCL_TRACE)
                sfprintf(sfstderr, "+ : JOB %s\n", jcl->name);
        }
        if (jcl->flags & JCL_SUBDIR)
        {
            if (jcl->flags & JCL_EXEC)
            {
                t = fmttime("%y-%m-%d", time(NiL));
                n = 0;
                for (;;)
                {
                    sfsprintf(subdir, sizeof(subdir), "%s.%s.%d", jcl->name, t, ++n);
                    if (!mkdir(subdir, S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IXOTH))
                        break;
                    if (errno != EEXIST)
                    {
                        if (jcl->disc->errorf)
                            (*jcl->disc->errorf)(NiL, jcl->disc, ERROR_SYSTEM|2, "%s: cannot create job subdirectory", subdir);
                        jclclose(jcl);
                        return -1;
                    }
                }
                if (chdir(subdir))
                {
                    if (jcl->disc->errorf)
                        (*jcl->disc->errorf)(NiL, jcl->disc, ERROR_SYSTEM|2, "%s: cannot run in job subdirectory", subdir);
                    jclclose(jcl);
                    return -1;
                }
                sfsync(sfstdout);
                sfsync(sfstderr);
                for (i = 0; i < elementsof(redirect); i++)
                    if (jcl->redirect[i] > 0)
                    {
                        close(redirect[i].fd);
                        if ((n = open(redirect[i].file, O_CREAT|O_TRUNC|O_WRONLY|O_APPEND|O_BINARY, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)) != redirect[i].fd)
                        {
                            close(n);
                            dup2(jcl->redirect[i], redirect[i].fd);
                        }
                    }
                sfset(sfstdout, SF_LINE, 1);
                sfset(sfstderr, SF_LINE, 1);
                if (jcl->flags & JCL_TRACE)
                    sfprintf(sfstderr, "+ mkdir %s\n+ cd %s\n", subdir, subdir);
                if (jcl->flags & JCL_VERBOSE)
                    sfprintf(sfstdout, "STARTED AT %s\n", fmttime("%K", time(NiL)));
            }
            else if (jcl->flags & JCL_VERBOSE)
            {
                sfprintf(sfstdout, "n=0\nt=$(date +%%y-%%m-%%d)\nwhile  :\ndo   d=%s.$t.$((++n))\n  [[ -d $d ]] || break\ndone\nmkdir $d && cd $d || exit 1\n", jcl->name);
                sfputr(sfstdout, "exec > SYSOUT 2> SYSERR\nTIMEFORMAT='USAGE CPU=%P%% REAL=%R USR=%U SYS=%S'\ntime {\ndate +'STARTED AT %K'", '\n');
            }
        }
    }
    else
        for (top = scope; !top->name && !(top->flags & JCL_SCOPE) && top->scope; top = top->scope);
    while (step = jclstep(jcl))
    {
        for (dd = (Jcldd_t*)dtfirst(step->dd); dd; dd = (Jcldd_t*)dtnext(step->dd, dd))
            if (dd->flags & JCL_DD_ALIAS)
            {
                dd->flags &= ~JCL_DD_ALIAS;
                xx = 0;
                t = fmtbuf(n = strlen(step->name) + strlen(dd->path) + 2);
                sfsprintf(t, n, "%s.%s", step->name, dd->path);
                for (scope = jcl; scope; scope = scope->scope)
                    if ((xx = (Jcldd_t*)dtmatch(scope->step->dd, t)) ||
                        (xx = (Jcldd_t*)dtmatch(scope->step->dd, dd->path)))
                        break;
                if (!xx)
                {
                    if (jcl->disc->errorf)
                        (*jcl->disc->errorf)(NiL, jcl->disc, 2, "%s: DD not defined", dd->path);
                    code = -1;
                    goto bad;
                }
                k = dd->link;
                s = dd->name;
                *dd = *xx;
                dd->link = k;
                dd->name = s;
            }
        if (!jcl->tmp)
        {
            for (dd = (Jcldd_t*)dtfirst(step->dd); dd; dd = (Jcldd_t*)dtnext(step->dd, dd))
            {
                if (dd->path && *dd->path == '&')
                    break;
                for (cat = dd->cat; cat; cat = cat->next)
                    if (cat->path && *cat->path == '&')
                        break;
            }
            if (dd)
            {
                if (jcl->flags & JCL_EXEC)
                {
                    if (!(s = getenv("TMPDIR")))
                        s = "/tmp";
                    sfprintf(jcl->vp, "%s/job.%s.%lu.", s, jcl->name, (unsigned long)getpid());
                }
                else
                    sfprintf(jcl->vp, "${TMPDIR:-/tmp}/job.%s.$$.", jcl->name);
                if (!(s = sfstruse(jcl->vp)))
                    nospace(jcl, NiL);
                jcl->tmp = stash(jcl, jcl->vm, s, 0);
                if ((jcl->flags & (JCL_VERBOSE|JCL_EXEC)) == JCL_VERBOSE)
                    sfprintf(sfstdout, "trap 'code=$?; rm -rf %s*; exit $code' 0 1 2\n", jcl->tmp);
            }
        }
        jcl->steps++;
        if (jcl->flags & (JCL_LISTEXEC|JCL_LISTINPUTS|JCL_LISTOUTPUTS|JCL_LISTPROGRAMS|JCL_LISTSCRIPTS))
        {
            if (jcl->flags & JCL_LISTEXEC)
                uniq(jcl->name, step->command, 0, jcl->disc);
            else if (jcl->flags & (JCL_LISTINPUTS|JCL_LISTOUTPUTS))
            {
                for (dd = (Jcldd_t*)dtfirst(step->dd); dd; dd = (Jcldd_t*)dtnext(step->dd, dd))
                {
                    flags = dd->disp[0] == JCL_DISP_NEW ? JCL_LISTOUTPUTS : JCL_LISTINPUTS;
                    if (dd->path && *dd->path != '&')
                        uniq(dd->path, NiL, flags, jcl->disc);
                    for (cat = dd->cat; cat; cat = cat->next)
                        if (*cat->path != '&')
                            uniq(cat->path, NiL, flags, jcl->disc);
                }
            }
            else if (jcl->flags & JCL_LISTPROGRAMS)
            {
                if (step->flags & JCL_PGM)
                    uniq(step->command, NiL, 0, jcl->disc);
            }
            else if (jcl->flags & JCL_LISTSCRIPTS)
            {
                if (!(step->flags & JCL_PGM) && (s = jclfind(jcl, step->command, 0, 0, NiL)))
                    uniq(s, NiL, 0, jcl->disc);
            }
        }
        if (!jcleval(jcl, jcl->cond, code))
            break;
        if (jcleval(jcl, step->cond, code))
        {
            if (step->flags & JCL_PGM)
            {
                std[0] = std[1] = std[2] = std[3] = 0;
                sfprintf(jcl->tp, ": %s\n", step->name);
                for (dd = (Jcldd_t*)dtfirst(step->dd); dd; dd = (Jcldd_t*)dtnext(step->dd, dd))
                    switch (dd->flags & (JCL_DD_DIR|JCL_DD_SYSIN|JCL_DD_SYSOUT|JCL_DD_SYSERR|JCL_DD_REFERENCE))
                    {
                    case JCL_DD_DIR:
                        if (dd->disp[0] == JCL_DISP_NEW || dd->disp[0] == JCL_DISP_MOD)
                            checkdir(jcl, dd);
                        break;
                    case JCL_DD_SYSIN:
                        if (dd->path)
                            std[0] = dd;
                        if (dd->here)
                            std[3] = dd;
                        break;
                    case JCL_DD_SYSOUT:
                        std[1] = dd;
                        break;
                    case JCL_DD_SYSERR:
                        std[2] = dd;
                        break;
                    default:
                        if (!(dd->flags & JCL_DD_DUMMY) && (jcl->flags & (JCL_EXEC|JCL_VERBOSE)) && dd->path && *dd->path != '&' && dd->disp[0] == JCL_DISP_NEW && (*dd->path != '$' || *(dd->path + 1) != '(') && (s = strrchr(dd->path, '/')))
                        {
                            *s = 0;
                            checkdir(jcl, dd);
                            *s = '/';
                        }
                        break;
                    }
                for (dd = (Jcldd_t*)dtfirst(jcl->dd); dd; dd = (Jcldd_t*)dtnext(jcl->dd, dd))
                    if ((dd->flags & (JCL_DD_MARKED|JCL_DD_SYSIN|JCL_DD_SYSOUT|JCL_DD_SYSERR|JCL_DD_REFERENCE)) == JCL_DD_MARKED && (dd->disp[0] == JCL_DISP_NEW || dd->disp[0] == JCL_DISP_MOD))
                    {
                        s = dsn(jcl, dd, dd->path, 0);
                        sfprintf(jcl->tp, "[[ -e %s ]] || > %s\n", s, s);
                    }
                for (dd = (Jcldd_t*)dtfirst(step->dd); dd; dd = (Jcldd_t*)dtnext(step->dd, dd))
                    if ((dd->flags & (JCL_DD_MARKED|JCL_DD_SYSIN|JCL_DD_SYSOUT|JCL_DD_SYSERR|JCL_DD_REFERENCE)) == JCL_DD_MARKED && (dd->disp[0] == JCL_DISP_NEW || dd->disp[0] == JCL_DISP_MOD))
                    {
                        s = dsn(jcl, dd, dd->path, 0);
                        sfprintf(jcl->tp, "[[ -e %s ]] || > %s\n", s, s);
                    }
                if ((dd = std[0]) && dd->cat)
                {
                    std[0] = std[3] = 0;
                    sfprintf(jcl->tp, "cat %s", dsn(jcl, dd, dd->path, 0));
                    for (cat = dd->cat; cat; cat = cat->next)
                        sfprintf(jcl->tp, " \\\n\t%s", dsn(jcl, dd, cat->path, 0));
                    sfprintf(jcl->tp, " |\n");
                }
                if (jcl->flags & JCL_EXEC)
                    sfprintf(jcl->tp, "%sJOBNAME=%s ", JCL_AUTO, top->name);
                sfprintf(jcl->tp, "%s=%s", fmtexport("STEP"), step->name);
                s = " \\\n";
                for (dd = (Jcldd_t*)dtfirst(jcl->dd); dd; dd = (Jcldd_t*)dtnext(jcl->dd, dd))
                    if (!(dd->flags & JCL_DD_REFERENCE))
                    {
                        sfprintf(jcl->tp, "%s%s=%s", s, fmtexport(dd->name), dsn(jcl, dd, dd->path, 1));
                        for (cat = dd->cat; cat; cat = cat->next)
                            sfprintf(jcl->tp, "'\n\t'%s", dsn(jcl, dd, cat->path, 1));
                    }
                for (dd = (Jcldd_t*)dtfirst(step->dd); dd; dd = (Jcldd_t*)dtnext(step->dd, dd))
                    if (dd->path && !(dd->flags & (JCL_DD_SYSIN|JCL_DD_SYSOUT|JCL_DD_SYSERR|JCL_DD_REFERENCE)))
                    {
                        sfprintf(jcl->tp, "%s%s=%s", s, fmtexport(dd->name), dsn(jcl, dd, dd->path, 1));
                        for (cat = dd->cat; cat; cat = cat->next)
                            sfprintf(jcl->tp, "'\n\t'%s", dsn(jcl, dd, cat->path, 1));
                        s = " \\\n";
                    }
                del = 0;
                sfprintf(jcl->tp, "%sDDIN='", s);
                s = "";
                for (dd = (Jcldd_t*)dtfirst(jcl->dd); dd; dd = (Jcldd_t*)dtnext(jcl->dd, dd))
                    if (!(dd->flags & (JCL_DD_SYSIN|JCL_DD_SYSOUT|JCL_DD_SYSERR|JCL_DD_REFERENCE)) && dd->disp[0] != JCL_DISP_NEW && dd->disp[0] != JCL_DISP_MOD)
                    {
                        sfprintf(jcl->tp, "%s%s", s, fmtexport(dd->name));
                        s = " ";
                    }
                for (dd = (Jcldd_t*)dtfirst(step->dd); dd; dd = (Jcldd_t*)dtnext(step->dd, dd))
                    if (!(dd->flags & (JCL_DD_SYSIN|JCL_DD_SYSOUT|JCL_DD_SYSERR|JCL_DD_REFERENCE)) && dd->disp[0] != JCL_DISP_NEW && dd->disp[0] != JCL_DISP_MOD)
                    {
                        sfprintf(jcl->tp, "%s%s", s, fmtexport(dd->name));
                        s = " ";
                    }
                sfprintf(jcl->tp, "' \\\nDDOUT='");
                s = "";
                for (dd = (Jcldd_t*)dtfirst(jcl->dd); dd; dd = (Jcldd_t*)dtnext(jcl->dd, dd))
                    if (!(dd->flags & (JCL_DD_SYSIN|JCL_DD_SYSOUT|JCL_DD_SYSERR|JCL_DD_REFERENCE)) && (dd->disp[0] == JCL_DISP_NEW || dd->disp[0] == JCL_DISP_MOD))
                    {
                        sfprintf(jcl->tp, "%s%s", s, fmtexport(dd->name));
                        s = " ";
                    }
                for (dd = (Jcldd_t*)dtfirst(step->dd); dd; dd = (Jcldd_t*)dtnext(step->dd, dd))
                {
                    if (!(dd->flags & (JCL_DD_SYSIN|JCL_DD_SYSOUT|JCL_DD_SYSERR|JCL_DD_REFERENCE)) && (dd->disp[0] == JCL_DISP_NEW || dd->disp[0] == JCL_DISP_MOD))
                    {
                        sfprintf(jcl->tp, "%s%s", s, fmtexport(dd->name));
                        s = " ";
                    }
                    if (dd->disp[1] == JCL_DISP_DELETE)
                        del |= 1;
                    if (dd->disp[2] == JCL_DISP_DELETE)
                        del |= 2;
                }
                sfprintf(jcl->tp, "' \\\n%s", step->command);
                if (s = step->parm)
                {
                    if (*s == '(')
                    {
                        arg = strcpy(fmtbuf(strlen(s) + 1), s);
                        while (s = jclparm(&arg))
                            sfprintf(jcl->vp, ",%s", s);
                        if (!(s = sfstruse(jcl->vp)))
                            nospace(jcl, NiL);
                        if (*s == ',')
                            s++;
                        for (t = s + strlen(s); t > s && *--t ==  ' ';);
                        if (*t == ')')
                            *++t = 0;
                        else if (*t == ',')
                            *t = 0;
                    }
                    sfprintf(jcl->tp, " %s", fmtquote(s, "$'", "'", strlen(s), FMT_SHELL));
                }
                for (sym = (Jclsym_t*)dtfirst(step->syms); sym; sym = (Jclsym_t*)dtnext(step->syms, sym))
                    sfprintf(jcl->tp, " %s=%s", fmtquote(sym->name, "'", "'", strlen(sym->name), FMT_SHELL), fmtquote(sym->value, "$'", "'", strlen(sym->value), 0));
                if (dd = std[0])
                {
                    sfprintf(jcl->tp, " < %s", dsn(jcl, dd, dd->path, 0));
                    std[3] = 0;
                }
                if (dd = std[1])
                    sfprintf(jcl->tp, " > %s", dsn(jcl, dd, dd->path, 0));
                if (dd = std[2])
                    sfprintf(jcl->tp, " 2> %s", dsn(jcl, dd, dd->path, 0));
                if (dd = std[3])
                    sfprintf(jcl->tp, " <<%s\n%s%s", fmtquote(dd->dlm, "'", "'", strlen(dd->dlm), 1), dd->here, dd->dlm);
                sfprintf(jcl->tp, "\ncode=$?\n");
                if (del)
                {
                    if (del & 1)
                    {
                        sfprintf(jcl->tp, "if (( ! $code ))\nthen\n\trm -rf");
                        for (dd = (Jcldd_t*)dtfirst(step->dd); dd; dd = (Jcldd_t*)dtnext(step->dd, dd))
                            if (dd->disp[1] == JCL_DISP_DELETE)
                                sfprintf(jcl->tp, " %s", dsn(jcl, dd, dd->path, 0));
                    }
                    if (del & 2)
                    {
                        if (del & 1)
                            sfprintf(jcl->tp, "\nelse\n");
                        else
                            sfprintf(jcl->tp, "\nif (( $code ))\nthen\n");
                        sfprintf(jcl->tp, "\trm -rf");
                        for (dd = (Jcldd_t*)dtfirst(step->dd); dd; dd = (Jcldd_t*)dtnext(step->dd, dd))
                            if (dd->disp[2] == JCL_DISP_DELETE)
                                sfprintf(jcl->tp, " %s", dsn(jcl, dd, dd->path, 0));
                    }
                    sfprintf(jcl->tp, "\nfi\n");
                }
                if (jcl->flags & JCL_EXEC)
                    sfprintf(jcl->tp, "exit $code\n");
                if (!(s = sfstruse(jcl->tp)))
                    nospace(jcl, NiL);
            }
            else if ((jcl->flags & (JCL_VERBOSE|JCL_EXEC)) == JCL_VERBOSE)
                sfprintf(sfstdout, ": %s PROC %s\n", step->name, step->command);
            else if ((jcl->flags & (JCL_TRACE|JCL_EXEC)) == (JCL_TRACE|JCL_EXEC))
                sfprintf(sfstderr, "+ : %s PROC %s\n", step->name, step->command);
            if (step->flags & JCL_PGM)
            {
                if ((jcl->flags & (JCL_VERBOSE|JCL_EXEC)) == JCL_VERBOSE)
                    sfputr(sfstdout, s, -1);
                if (sfsync(sfstdout))
                {
                    if (jcl->disc->errorf)
                        (*jcl->disc->errorf)(NiL, jcl->disc, 2, "write error");
                    code = -1;
                    break;
                }
                if (!(jcl->flags & JCL_EXEC))
                    code = 0;
                else if (!(cj = coexec(co, s, CO_APPEND, redirect[0].file, redirect[1].file, NiL)) || !(cj = cowait(co, cj, -1)))
                    code = 127;
                else
                    code = cj->status;
            }
            else if (jcl->flags & JCL_RECURSE)
                code = jclrun(jcl);
            else
                code = 0;
            if (code)
                jcl->failed++;
            else
                jcl->passed++;
            if (jclrc(jcl, step, code) < 0)
                break;
        }
    }
 bad:
    if (jcl->tmp && (jcl->flags & JCL_EXEC))
    {
        sfprintf(jcl->tp, "rm -rf %s*\n", jcl->tmp);
        if (!(s = sfstruse(jcl->tp)))
            nospace(jcl, NiL);
        if (cj = coexec(co, s, CO_APPEND, redirect[0].file, redirect[1].file, NiL))
            cowait(co, cj, -1);
    }
    if (jcl == top)
    {
        if (jcl->flags & JCL_GDG)
        {
            s = "gdgupdate";
            if (!(jcl->flags & JCL_EXEC))
                sfputr(sfstdout, s, '\n');
            else if (cj = coexec(co, s, CO_APPEND, redirect[0].file, redirect[1].file, NiL))
                cowait(co, cj, -1);
        }
        if ((jcl->flags & (JCL_SUBDIR|JCL_VERBOSE)) == (JCL_SUBDIR|JCL_VERBOSE))
        {
            if (jcl->flags & JCL_EXEC)
                sfprintf(sfstdout, "COMPLETED AT %s\n", fmttime("%K", time(NiL)));
            else
                sfputr(sfstdout, "date +'COMPLETED AT %K'\n}", '\n');
        }
        if ((jcl->flags & (JCL_EXEC|JCL_SUBDIR)) == (JCL_EXEC|JCL_SUBDIR) && chdir("..") && jcl->disc->errorf)
            (*jcl->disc->errorf)(NiL, jcl->disc, ERROR_SYSTEM|2, "%s: cannot chdir to job subdirectory parent", subdir);
        if ((jcl->flags & (JCL_EXEC|JCL_VERBOSE)) == (JCL_EXEC|JCL_VERBOSE))
        {
            start = tmxgettime() - start;
            user = (co->user - user) / CO_QUANT;
            sys = (co->sys - sys) / CO_QUANT;
            if (pct = (real = (double)start / 1e9))
                pct = 100.0 * ((user + sys) / pct);
            sfprintf(sfstdout, "USAGE CPU=%.2f%% REAL=%.2f USR=%.2f SYS=%.2f\n", pct, real, user, sys);
        }
    }
    code = jclclose(jcl);
    if (scope)
        jclrc(scope, NiL, code);
    return code;
}