
Usage:
  CON5repeat  [ options ]  source-directory  target-directory  iterations  [ instances ]

  source-directory
      source-directory is the pathname of the directory that CON5 will
      read from.  CON5 does not modify anything in this directory,
      so it can reside in a filesystem that is mounted read-only.

      A typical value is /kernel.  That is what CON3 uses for its
      source directory.  It could be a copy of /kernel that has been
      prepared in advance on a filesystem other than root.

  target-directory
      All target copies get written to subdirectories of this
      directory.  Do not put anything precious in here, because things
      can get pretty rough.

  iterations
      This is how many times to repeat the whole process, sequentially.
      How long an iteration lasts depends on many things about the
      configuration of the system and its load.  Usually 100 iterations
      takes long enough that you can specify 100, then tell CON5 to
      terminate, later.

  instances
      This is optional.  If it is provided, then CON5 will never exceed
      the given number of concurrent instances.  CON5 calculates the
      largest number of instances that available disk space will
      allow.  If instances is specified on the command line, then CON5
      uses the smaller of the two numbers.  If instances is not
      specified, then CON5 will use the calculated value.


Options
-------

  -n
      No commit.  Do the preliminary calculations and testing for
      preconditions, but don't really do the copying.  If there is an
      error in any of the arguments then exit(1).  If everything looks
      good, then print the number instances that will actually be used
      to start, then exit(0).

  -v
      Verbose.  Print various extra trace messages to stderr.  This is
      used primarily for debugging, but it is retained, just in case,
      and for the curious.  The nature of the messages produced is
      subject to change and is not part of the supported CON5 interface.

  -nofsck
      Normally, CON5 will run fsck -n on the filesystems containing the
      source directory, the target directory, and root, after every
      iteration.  This option prevents CON5 from running fsck.

  -nofsck-root
      Do not run fsck on the root filesystem.  This is useful, when you
      want to run fsck on the source and destination directories, but you
      know that there is other activity on the system, such as other tests.
      So, it makes no sense to try to check the root filesystem, because it
      will not be quiescent.

  -disk-reserve  <kbytes>
      If you reserve disk space, it will be as if the amount of disk
      space available is that much less than it really is, and that
      will be reflected in the calculation of the number of instances
      supportable by the available disk space.

  -processes-per-instance
      CON5 autoconfigures number of instances based on available space
      and available processes.  It computes a budget based on its knowledge
      of how many processes each instance uses.  This option will override
      the number of processes per instance, and so, indirectly change the
      number of instances that are configured.



Fault Injection Options
-----------------------

  All options starting with -fault- are part of a mechanism for
  injecting artificial faults into CON5.  These options are not
  ordinarily used.  They are provided for debugging.  They are used to
  run quick, controlled tests of the behavior of the higher layers in
  the face of failures.  If CON5 is designed properly, then such
  failures would be rare.  So, many code paths that should work
  reliably on the rare occasions when they are needed will not have
  been exercised very much, if CON5 were not tested by fault
  injection.


  -fault-max-instances  <instances>
      fault-max-instances tells CON5 to artificially inject a failure
      of a fork() system call, with errno of EAGAIN for all instances
      above the given number.  This is used to test behavior in the
      face of resource exhaustion, without really having to run tests
      that are monstrous enough to exhaust system resources.

  -fault-cpio
      Cause a thread, chosen at random, to pretend that cpio failed,
      even if there was no error.

  -fault-diff
      Cause a thread, chosen at random, to pretend that diff failed,
      even if there was no error and there were no differences.

  -fault-file-add
      For a thread, chosen at random, after cpio runs but before
      running diff, add an extra file to the target directory.

  -fault-file-drop
      For a thread, chosen at random, after cpio runs but before
      running diff, remove an arbitrary file from the target
      directory.

