Provided by: rr_5.2.0-4build1_amd64 bug


       rr - record and replay application execution


       rr dump [<options>] [<trace-dir>] [<event-specs>]
       rr gdbinit
       rr help [<command>]
       rr ps [<trace-dir>]
       rr record [<options>] <executable> [<exe-args>]
       rr replay [<options>] [<trace-dir>]


   Common options
       -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-
              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

       -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>] where ev is the global trace time  at  which
              the write occurs and pid is the pid of the process it occurs in.

       -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.

   Syntax for `record'
              rr record [<options>] <executable> [<exe-args>]

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

       -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

   Syntax for `replay'
              rr replay [<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

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

       -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

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

       -x <file>, --gdb-x=<file>
              execute gdb(1) commands from file

   Syntax for `dump`
              rr dump [<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 was written by Robert O'Callahan, Chris Jones, Nathan Froyd and others.

       This manual page was adapted from the help output by Stephen Kitt <>,  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 executiNovember 2015                                     rr(1)