Exec.C

Go to the documentation of this file.

// Last modified on Thu Nov 10 09:19:30 PST 1994 by levin
/*

  This file implements the portion of the Vesta EXEC primitive that
  is invoked directly from the evaluator/interpreter.

*/

/*

TYPE
  StdTreatment = TEXT,
    /* "ignore"             => send to /dev/null
       "report"             => report to user
       "reportError"        => report to user, 
       "value"              => include {stdxxx = <value>} in return, where
                               xxx is either "out" or "err"
    */
  ExecResult = {
    code: INT,              // exit status:
                            //   256 > code >= 0 => tool reported this result
                            //   -256 < code < 0 => tool got -code as a signal
                            //   code <= -256 =>
                            //           tool reported -code as a result, but
                            //           also produced output for which the
                            //           specified treatment was "reportError"
                            //           if x is (-code) DIV 256 then
                            //              x == 1 => output on stdout
                            //              x == 2 => output on stderr,
                            //              x == 3 => output on both
                            //   code >= 256 or code < -1023 => undefined
                            //
    wd: BINDING,            // files created in the working directory
    root: BINDING,          // files created elsewhere in the file system
    stdout: TEXT,           // defined iff stdoutTreatment == "value"
    stderr: TEXT            // defined iff stderrTreatment == "value"
    }

EXEC(
  platform: TEXT,                // on which command is to execute
  command: LIST[TEXT],           // HEAD is tool name, TAIL is arguments
  stdin: TEXT := "",
  stdoutTreatment: StdTreatment := "report",
  stderrTreatment: StdTreatment := "reportError",
  ENV: BINDING                   // for expected fields, see below
 ): ExecResult

*/



ValC
prim_exec(
          ValC platform,        // TEXT
          ValC command,         // LIST[TEXT],
          ValC stdin,           // TEXT
          ValC stdoutTr,        // TEXT (StdTreatment)
          ValC stderrTr,        // TEXT (StdTreatment)
          ValC env              // BINDING
          )
  {
    String pf
    String host
    // convert platform to ordinary text string
    if (!choose_host(pf, &host)) {
      // can't find a suitable host platform; complain
    }
    if (host == NIL) {
      // tool will execute locally
      // establish stdin, stdout, stderr:
      //   stdin:  if non-NIL, copy to file and open as filedescriptor
      //   stdout:  ignore => /dev/null, report => pipe to stdout
      //            reportError => ??? (tee)
      //            value => open derived file, pass descriptor, remember
      //                     shortId
      // set up environment variables from env$ENVVARS
      // create mount points for file system root and wd
      // create combined command line for tooldriver, including:
      //   chroot info (mount points)
      //   user id (to switch back from superuser)
      //   original command line
      // fork
      // in child, perform chroot and mounts, switch user id, sigvec, exec
      // in parent, wait for child
      // when child exits, compute error code (perhaps done by child?)
      //   if treatments are "value", create VV's from shortIds
      // talk to mount points to get result bindings for wd and fs
      // put together result value from pieces
    } else {
      // tool will execute remotely
      // establish stdin, stdout, stderr:
      //   stdin:  if non-NIL, copy to file (if necessary) and
      //           pass file name to tooldriver on command line
      //   stdout and stderr:
      //     ignore => tell tooldriver to set to /dev/null,
      //     report => create socket, pass to tooldriver on command line
      //     reportError => as for "report", but pass flag to tooldriver
      //     value => open derived file, pass name to tooldriver, remember
      //              shortId locally
      // look at env$ENVVARS and create text rep for tooldriver
      // create mount points for file system root and wd
      //   do nfs_mount
      // call remote tooldriver on "host".  This is pseudo RPC:
      //   start with rsh /vesta/components/tooldriver (platform specific)
      //     alternative:  tooldriver is a daemon that listens on a well-known
      //       socket and forks a unique child instance for each request.
      //   pass socket name for argument stream
      //   push "marshalled" data down socket:
      //     stdin, stdout, stderr setup info from above
      //     mount point names and server info
      //     user id (to switch back from superuser)
      //     environment vars (text rep)
      //     tool command line
      // need threads for stdout/stderr sockets (alertable wait?)
      // main thread waits on completion info from tooldriver
      // tooldriver does:
      //    if stdin is needed, opens the file name passed and sets file desc.
      //    sets file descriptors for stdout and stderr by creating sockets
      //      and connecting to those passed as parameters.  If error flag
      //      is set, must create a thread and a pty, passing the pty as
      //      the file descriptor and having the thread copy data from pty
      //      to socket, setting flag on firs time.
      //    create mount points and nfs mount for root and wd
      //    chroot
      //    switch user id
      //    set up sigvec
      //    exec tool, using command
      // in parent, wait for child
      // when child exits, compute error code (perhaps done by child?)
      //   if treatments are "value", create VV's from shortIds
      // talk to mount points to get result bindings for wd and fs
      // put together result value from pieces
    }
      
      

---