relaying data between gdb and process ....
vgdb-error value changed from 0 to 999999
general valgrind monitor commands:
  help [debug]            : monitor command help. With debug: + debugging commands
  v.wait [<ms>]           : sleep <ms> (default 0) then continue
  v.info all_errors       : show all errors found so far
  v.info last_error       : show last error found
  v.info location <addr>  : show information about location <addr>
  v.info n_errs_found [msg] : show the nr of errors found so far and the given msg
  v.info open_fds         : show open file descriptors (only if --track-fds=yes)
  v.kill                  : kill the Valgrind process
  v.set gdb_output        : set valgrind output to gdb
  v.set log_output        : set valgrind output to log
  v.set mixed_output      : set valgrind output to log, interactive output to gdb
  v.set merge-recursive-frames <num> : merge recursive calls in max <num> frames
  v.set vgdb-error <errornr> : debug me at error >= <errornr> 
massif monitor commands:
  snapshot [<filename>]
  detailed_snapshot [<filename>]
      takes a snapshot (or a detailed snapshot)
      and saves it in <filename>
             default <filename> is massif.vgdb.out
  all_snapshots [<filename>]
      saves all snapshot(s) taken so far in <filename>
             default <filename> is massif.vgdb.out
monitor command request to kill this process
Remote connection closed
