rr - record and replay application execution

rr was written by Robert O'Callahan, Chris Jones, Nathan Froyd and others.

       This  manual  page  was  adapted  from the help output by Stephen Kitt <skitt@debian.org>, for the Debian
       GNU/Linux system (but may be used by others). It was last modified for rr version 4.0.1.

rr - record and replay application executions     November 2015                                            rr(1)

Commonoptions-A <name>, --microarch=<name>
              force  rr  to  assume  it's  running  on  a CPU with microarch name even if runtime detection says
              otherwise. name should be a string like `Ivy Bridge'.

       -C {on-syscalls,on-all-events,<from-time>}, --checksum={on-syscalls,on-all-events,<from-time>}
              compute and store (during recording) or read and verify (during replay) checksums  of  each  of  a
              tracee's  memory  mappings  either  at  the  end  of  all  syscalls  (on-syscalls),  at all events
              (on-all-events), or starting from a global timepoint from-time.

       -D {<syscall-num,-<signal-num>}, --dump-on={<syscall-num,-<signal-num>}
              dump memory at syscall or signal to the file  tid.time_{rec,rep}  in  trace-dir;  _rec  for  dumps
              during recording, _rep for dumps during replay.

       -F, --force-things
              force  rr  to  do  some  things  that don't seem like good ideas, such as launching an interactive
              emergency debugger if stderr isn't a tty.

       -K, --check-cached-mmaps
              verify that cached task mmaps match /proc/maps.

       -E, --fatal-errors
              any warning or error that is printed is treated as fatal.

       -M, --mark-stdio
              mark stdio writes with [rr<pid><ev>]whereevistheglobaltracetimeatwhichthewriteoccursandpidisthepidoftheprocessitoccursin.-N, --version
              print the version number and exit.

       -S, --suppress-environment-warnings
              suppress warnings about issues in the environment that rr has no control over.

       -T <time>, --dump-at=<time>
              dump memory at global timepoint time-V, --verbose
              log messages that may not be urgently critical to the user

       -W <num-secs>, --wait-secs=<num-secs>
              wait num-secs seconds just after startup, before initiating recording or replaying.

   Syntaxfor`record'rrrecord [<options>] <executable> [<exe-args>]

       -b, --force-syscall-buffer
              force the systall buffer preload library to be used, even if that's probably a bad idea

       -c <num>, --num-cpu-ticks=<num>
              maximum number of `CPU ticks' (currently retired conditional branches) to  allow  a  task  to  run
              before interrupting it

       -e <num>, --num-events=<num>
              maximum  number  of events (syscall enter/exit, signal, CPU interrupt, ...) to allow a task before
              descheduling it

       -i <signal>, --ignore-signal=<signal>
              block signal from being delivered to tracees; probably only useful for unit tests

       -n, --no-syscall-buffer
              disable the syscall buffer preload library even if it would otherwise be used

       -u, --cpu-unbound
              allow tracees to run on any virtual CPU (default is to bind to  CPU  0);  this  option  can  cause
              replay divergence: use with caution

       -v <name>=<value>, --env=<name>=<value>
              value to add to the environment of the tracee; there can be any number of these

   Syntaxfor`replay'rrreplay [<options>] [<trace-dir>]

       -a, --autopilot
              replay without debug server

       -d <command>, --debugger=<command>
              use command as the gdb(1) command

       -f <pid>, --onfork=<pid>
              start a debug server when pid has been forked, and the target event has been reached

       -g <event-num>, --goto=<event-num>
              start a debug server on reaching event-num in the trace; see -M in the general options

       -p {<pid>,<command>}, --onprocess={<pid>,<command>}
              start a debug server when pid or command has been exec'd, and the target event has been reached

       -q, --no-redirect-output
              don't replay writes to stdout/stderr-s <port>, --dbgport=<port>
              only start a debug server on port; don't automatically launch the debugger client too

       -t <event>, --trace=<event>
              singlestep instructions and dump register states when replaying towards event or later

       -x <file>, --gdb-x=<file>
              execute gdb(1) commands from fileSyntaxfor`dump`rrdump [<options>] [<trace-dir>] [<event-specs>]

       Event  specs  can  be  either  an  event number like `127', or a range like `1000-5000'.  By default, all
       events are dumped.

       -b, --syscallbuf
              dump syscallbuf contents

       -m, --recorded-metadata
              dump recorded metadata

       -p, --mmaps
              dump mmap data

       -r, --raw
              dump trace frames in a more easily machine-parseable format instead of the default  human-readable
              format

       -s, --statistics
              dump statistics about the trace

       rr - record and replay application execution

rrdump [<options>] [<trace-dir>] [<event-specs>]
       rrgdbinitrrhelp [<command>]
       rrps [<trace-dir>]
       rrrecord [<options>] <executable> [<exe-args>]
       rrreplay [<options>] [<trace-dir>]