persistent process supervision
runtools_intro(8)                  runtools                  runtools_intro(8)

       runtools_intro - overview of the runtools utilities

       The  runtools  package  provides a set of utilities for configuring and
       constraining the process execution environment of other programs.  Most
       of  the  utilities exec into the process environment they create.  That
       is, they are designed to replace themselves with some other program.  A
       few of the utilities act as lightweight supervisors, remaining resident
       themselves while monitoring some other process or processes.  The  run-
       tools utilities include:

              Runs a program with arguments specified in an argfile.

              Runs a program with an alias in place of the 0th argument.

              Runs a program with linux ``oom killer'' abatement.

              Runs  a program in the background, detached from the controlling

              Runs and supervises a program with an associated logger.

              Runs a program with an environment defined in either an  envfile
              or an envdir.

              Runs a program described in an argvfile.

              Runs a program with modified resource limits.

              Runs  a program with an associated lockfile, optionally contain-
              ing the pid of the process.

              Runs a program after waiting some delay or receiving a signal.

              Runs a program in a new session and process group.

              Multipurpose utility for  running  a  program  in  a  configured
              process  environment,  combining  many of the functions of other
              runtools within a single executable.

              Runs and supervises a program with an associated signal trapper.

              Runs a program with specific user and group permissions.

       The  runtools  utilities are designed primarily for use within the run-
       scripts of service supervisors, such as perpd(8) and  daemontools.   In
       this  case,  they  will  normally  be used to define and constrain such
       things as resources, privileges, environmental variables, file descrip-
       tors,  etc.   They may be used to provide carefully regulated execution
       environments for long-running programs, for security and resource opti-

       Most  of  the utilities in the runtools package are very small programs
       designed to do one simple thing.  Because the effects of multiple  run-
       tools  are often required, it is customary to use whatever runtools are
       needed in an ``exec chain''.  An exec chain is a sequence  of  runtools
       commands,  one  calling  another,  often  in a specific order, with the
       final command execing into the actual program intended.  The  following
       perpetrate(5) snippet shows an example in sh(1) syntax:

              if test ${1} = 'start' ; then
                exec runenv -i ./envfile \
                    runlimit -c 0 -f 2000000 -m 30000000 \
                        runuid fooman \
                          /usr/sbin/foo -f

       In  the  example above, the program /usr/sbin/foo is ultimately desired
       as the long-running process.  An exec chain is used to:

       o   define the environment for ``foo'' with runenv(8)

       o   constrain corefiles,