static void rsp_vpkt ( const rsp_buf * const buf )
{
s_scratch.clear();
for ( int i = 1; i < buf->len; ++i )
{
const char c = buf->data[ i ];
if ( c == ';' || c == '?' )
break;
s_scratch.push_back( c );
}
if ( s_scratch.empty() )
throw std::runtime_error( "Illegal 'v' packet: the operation name is empty." );
if ( s_scratch == "vCont?" )
{
// We don't support the vCont command, which is only a must if we have reported
// support for the multiprocess extensions.
send_unknown_command_reply( rsp.client_fd );
}
else if ( s_scratch == "Kill" )
{
kill_request();
send_ok_packet( rsp.client_fd );
}
else
{
send_unknown_command_reply( rsp.client_fd );
}
}
void process_client_command ( const rsp_buf * const buf )
{
if ( rsp.is_target_running )
{
// printf( "BREAK received while CPU running.\n" );
if ( buf->data[0] == GDB_RSP_BREAK_CMD )
{
stall_cpu();
collect_cpu_stop_reason( true );
send_signal_reply_packet();
rsp.cpu_poll_speed = CPS_SLOW;
return;
}
throw std::runtime_error( "A GDB RSP command was received while the CPU was running, which is an indication "
"that the RSP handling got out of sync." );
}
assert( rsp.cpu_poll_speed == CPS_SLOW );
switch ( buf->data[0] )
{
case GDB_RSP_BREAK_CMD:
// The target was not running and a break command was received. This can happen if the user
// issues a break (with Ctrl+C) but the CPU just stalled for anothe reason.
send_signal_reply_packet();
break;
case '!':
// Request for extended remote mode, which we do support.
send_ok_packet( rsp.client_fd );
break;
case '?':
send_signal_reply_packet();
break;
case 'c':
rsp_continue( buf );
break;
case 'g':
rsp_read_all_regs();
break;
case 'H':
// Set the thread number of any subsequent operations.
// Hc is for step and continue operations, Hg for all other operations.
// The thread number can be -1 for all threads, a thread number, or 0 for "just pick any thread".
// We only support one thread, so ignore all arguments and just reply "OK"
send_ok_packet( rsp.client_fd );
break;
case 'k':
kill_request();
break;
case 'm':
rsp_read_mem( buf );
break;
case 'M':
rsp_write_mem( buf );
break;
case 'P':
rsp_write_reg( buf );
break;
case 'q':
// General query packets.
rsp_query( buf );
break;
case 's':
// Single step (one high level instruction). This could be hard without DWARF2 info.
rsp_step( buf );
break;
case 'v':
// Any one of a number of packets to control execution
rsp_vpkt( buf );
break;
// ----- These are all packets that we have decided not to support -----
case 'z':
case 'Z':
rsp_watchpoint( buf );
break;
case 'D': // Detach GDB. I'm not sure what to do in this case. If you type "detach" in the current
// GDB version it does not close the connection and it triggers error message
// "A problem internal to GDB has been detected".
case 'X': // We don't support binary memory writes. The old code did, so it should not be hard
// to port it to this new implementation. This is only an optimisation, as GDB
// will fall back to using text-based memory writes (see the 'M' command).
send_unknown_command_reply( rsp.client_fd );
break;
default:
// Assert on all unsupported packets that were not already known to the developer. This helps catch bugs.
#ifndef NDEBUG
printf( "Unknown RSP packet received: %s\n", format_packet_for_tracing_purposes( buf ).c_str() );
assert( false );
#endif
send_unknown_command_reply( rsp.client_fd );
break;
}
}
/* handle_gdb_valgrind_command handles the provided mon string command.
If command is recognised, return 1 else return 0.
Note that in case of ambiguous command, 1 is returned.
*sink_wanted_at_return is modified if one of the commands
'v.set *_output' is handled.
*/
static
int handle_gdb_valgrind_command (char* mon, OutputSink* sink_wanted_at_return)
{
UWord ret = 0;
char s[strlen(mon)+1]; /* copy for strtok_r */
char* wcmd;
HChar* ssaveptr;
const char* endptr;
int kwdid;
int int_value;
vg_assert (initial_valgrind_sink_saved);
strcpy (s, mon);
wcmd = strtok_r (s, " ", &ssaveptr);
/* NB: if possible, avoid introducing a new command below which
starts with the same 3 first letters as an already existing
command. This ensures a shorter abbreviation for the user. */
switch (VG_(keyword_id) ("help v.set v.info v.wait v.kill v.translate"
" v.do",
wcmd, kwd_report_duplicated_matches)) {
case -2:
ret = 1;
break;
case -1:
break;
case 0: /* help */
ret = 1;
wcmd = strtok_r (NULL, " ", &ssaveptr);
if (wcmd == NULL) {
int_value = 0;
} else {
switch (VG_(keyword_id) ("debug", wcmd, kwd_report_all)) {
case -2: int_value = 0; break;
case -1: int_value = 0; break;
case 0: int_value = 1; break;
default: tl_assert (0);
}
}
VG_(gdb_printf) (
"general valgrind monitor commands:\n"
" help [debug] : monitor command help. With debug: + debugging commands\n"
" v.wait [<ms>] : sleep <ms> (default 0) then continue\n"
" v.info all_errors : show all errors found so far\n"
" v.info last_error : show last error found\n"
" v.info n_errs_found : show the nr of errors found so far\n"
" v.info open_fds : show open file descriptors (only if --track-fds=yes)\n"
" v.kill : kill the Valgrind process\n"
" v.set gdb_output : set valgrind output to gdb\n"
" v.set log_output : set valgrind output to log\n"
" v.set mixed_output : set valgrind output to log, interactive output to gdb\n"
" v.set merge-recursive-frames <num> : merge recursive calls in max <num> frames\n"
" v.set vgdb-error <errornr> : debug me at error >= <errornr> \n");
if (int_value) { VG_(gdb_printf) (
"debugging valgrind internals monitor commands:\n"
" v.do expensive_sanity_check_general : do an expensive sanity check now\n"
" v.info gdbserver_status : show gdbserver status\n"
" v.info memory [aspacemgr] : show valgrind heap memory stats\n"
" (with aspacemgr arg, also shows valgrind segments on log ouput)\n"
" v.info exectxt : show stacktraces and stats of all execontexts\n"
" v.info scheduler : show valgrind thread state and stacktrace\n"
" v.set debuglog <level> : set valgrind debug log level to <level>\n"
" v.translate <addr> [<traceflags>] : debug translation of <addr> with <traceflags>\n"
" (default traceflags 0b00100000 : show after instrumentation)\n"
" An additional flag 0b100000000 allows to show gdbserver instrumentation\n");
}
break;
case 1: /* v.set */
ret = 1;
wcmd = strtok_r (NULL, " ", &ssaveptr);
switch (kwdid = VG_(keyword_id)
("vgdb-error debuglog merge-recursive-frames"
" gdb_output log_output mixed_output",
wcmd, kwd_report_all)) {
case -2:
case -1:
break;
case 0: /* vgdb-error */
case 1: /* debuglog */
case 2: /* merge-recursive-frames */
wcmd = strtok_r (NULL, " ", &ssaveptr);
if (wcmd == NULL) {
int_value = 0;
endptr = "empty"; /* to report an error below */
} else {
HChar *the_end;
int_value = strtol (wcmd, &the_end, 10);
endptr = the_end;
}
if (*endptr != '\0') {
VG_(gdb_printf) ("missing or malformed integer value\n");
} else if (kwdid == 0) {
VG_(gdb_printf) ("vgdb-error value changed from %d to %d\n",
VG_(dyn_vgdb_error), int_value);
VG_(dyn_vgdb_error) = int_value;
} else if (kwdid == 1) {
VG_(gdb_printf) ("debuglog value changed from %d to %d\n",
VG_(debugLog_getLevel)(), int_value);
VG_(debugLog_startup) (int_value, "gdbsrv");
} else if (kwdid == 2) {
VG_(gdb_printf)
("merge-recursive-frames value changed from %d to %d\n",
VG_(clo_merge_recursive_frames), int_value);
VG_(clo_merge_recursive_frames) = int_value;
} else {
vg_assert (0);
}
break;
case 3: /* gdb_output */
(*sink_wanted_at_return).fd = -2;
command_output_to_log = False;
VG_(gdb_printf) ("valgrind output will go to gdb\n");
break;
case 4: /* log_output */
(*sink_wanted_at_return).fd = initial_valgrind_sink.fd;
command_output_to_log = True;
VG_(gdb_printf) ("valgrind output will go to log\n");
break;
case 5: /* mixed output */
(*sink_wanted_at_return).fd = initial_valgrind_sink.fd;
command_output_to_log = False;
VG_(gdb_printf)
("valgrind output will go to log, interactive output will go to gdb\n");
break;
default:
vg_assert (0);
}
break;
case 2: /* v.info */ {
ret = 1;
wcmd = strtok_r (NULL, " ", &ssaveptr);
switch (kwdid = VG_(keyword_id)
("all_errors n_errs_found last_error gdbserver_status memory"
" scheduler open_fds exectxt",
wcmd, kwd_report_all)) {
case -2:
case -1:
break;
case 0: // all_errors
// A verbosity of minimum 2 is needed to show the errors.
VG_(show_all_errors)(/* verbosity */ 2, /* xml */ False);
break;
case 1: // n_errs_found
VG_(gdb_printf) ("n_errs_found %d n_errs_shown %d (vgdb-error %d)\n",
VG_(get_n_errs_found) (),
VG_(get_n_errs_shown) (),
VG_(dyn_vgdb_error));
break;
case 2: // last_error
VG_(show_last_error)();
break;
case 3: // gdbserver_status
VG_(gdbserver_status_output)();
break;
case 4: /* memory */
VG_(print_all_arena_stats) ();
if (VG_(clo_profile_heap))
VG_(print_arena_cc_analysis) ();
wcmd = strtok_r (NULL, " ", &ssaveptr);
if (wcmd != NULL) {
switch (VG_(keyword_id) ("aspacemgr", wcmd, kwd_report_all)) {
case -2:
case -1: break;
case 0:
VG_(am_show_nsegments) (0, "gdbserver v.info memory aspacemgr");
break;
default: tl_assert (0);
}
}
ret = 1;
break;
case 5: /* scheduler */
VG_(show_sched_status) ();
ret = 1;
break;
case 6: /* open_fds */
if (VG_(clo_track_fds))
VG_(show_open_fds) ("");
else
VG_(gdb_printf)
("Valgrind must be started with --track-fds=yes"
" to show open fds\n");
ret = 1;
break;
case 7: /* exectxt */
VG_(print_ExeContext_stats) (True /* with_stacktraces */);
ret = 1;
break;
default:
vg_assert(0);
}
break;
}
case 3: /* v.wait */
wcmd = strtok_r (NULL, " ", &ssaveptr);
if (wcmd != NULL) {
int_value = strtol (wcmd, NULL, 10);
VG_(gdb_printf) ("gdbserver: continuing in %d ms ...\n", int_value);
VG_(poll)(NULL, 0, int_value);
}
VG_(gdb_printf) ("gdbserver: continuing after wait ...\n");
ret = 1;
break;
case 4: /* v.kill */
kill_request ("monitor command request to kill this process\n");
break;
case 5: { /* v.translate */
Addr address;
SizeT verbosity = 0x20;
ret = 1;
VG_(strtok_get_address_and_size) (&address, &verbosity, &ssaveptr);
if (address != (Addr) 0 || verbosity != 0) {
/* we need to force the output to log for the translation trace,
as low level VEX tracing cannot be redirected to gdb. */
int saved_command_output_to_log = command_output_to_log;
int saved_fd = VG_(log_output_sink).fd;
Bool single_stepping_on_entry = valgrind_single_stepping();
int vex_verbosity = verbosity & 0xff;
VG_(log_output_sink).fd = initial_valgrind_sink.fd;
if ((verbosity & 0x100) && !single_stepping_on_entry) {
valgrind_set_single_stepping(True);
// to force gdbserver instrumentation.
}
# if defined(VGA_arm)
// on arm, we need to (potentially) convert this address
// to the thumb form.
address = thumb_pc (address);
# endif
VG_(translate) ( 0 /* dummy ThreadId; irrelevant due to debugging*/,
address,
/*debugging*/True,
(Int) vex_verbosity,
/*bbs_done*/0,
/*allow redir?*/True);
if ((verbosity & 0x100) && !single_stepping_on_entry) {
valgrind_set_single_stepping(False);
// reset single stepping.
}
command_output_to_log = saved_command_output_to_log;
VG_(log_output_sink).fd = saved_fd;
}
break;
}
case 6: /* v.do */
ret = 1;
wcmd = strtok_r (NULL, " ", &ssaveptr);
switch (VG_(keyword_id) ("expensive_sanity_check_general",
wcmd, kwd_report_all)) {
case -2:
case -1: break;
case 0: { /* expensive_sanity_check_general */
// Temporarily bump up sanity level to check e.g. the malloc arenas.
const Int save_clo_sanity_level = VG_(clo_sanity_level);
if (VG_(clo_sanity_level) < 4) VG_(clo_sanity_level) = 4;
VG_(sanity_check_general) (/* force_expensive */ True);
VG_(clo_sanity_level) = save_clo_sanity_level;
break;
}
default: tl_assert (0);
}
break;
default:
vg_assert (0);
}
return ret;
}
void server_main (void)
{
static char status;
static int zignal;
char ch;
int i = 0;
unsigned int len;
CORE_ADDR mem_addr;
zignal = valgrind_wait (&status);
if (VG_MINIMAL_SETJMP(toplevel)) {
dlog(0, "error caused VG_MINIMAL_LONGJMP to server_main\n");
}
while (1) {
unsigned char sig;
int packet_len;
int new_packet_len = -1;
if (resume_reply_packet_needed) {
/* Send the resume reply to reply to last GDB resume
request. */
resume_reply_packet_needed = False;
prepare_resume_reply (own_buf, status, zignal);
putpkt (own_buf);
}
/* If we our status is terminal (exit or fatal signal) get out
as quickly as we can. We won't be able to handle any request
anymore. */
if (status == 'W' || status == 'X') {
return;
}
packet_len = getpkt (own_buf);
if (packet_len <= 0)
break;
i = 0;
ch = own_buf[i++];
switch (ch) {
case 'Q':
handle_set (own_buf, &new_packet_len);
break;
case 'q':
handle_query (own_buf, &new_packet_len);
break;
case 'd':
/* set/unset debugging is done through valgrind debug level. */
own_buf[0] = '\0';
break;
case 'D':
reset_valgrind_sink("gdb detaching from process");
/* When detaching or kill the process, gdb expects to get
an packet OK back. Any other output will make gdb
believes detach did not work. */
write_ok (own_buf);
putpkt (own_buf);
remote_finish (reset_after_error);
remote_open (VG_(clo_vgdb_prefix));
myresume (0, 0);
resume_reply_packet_needed = False;
return;
case '!':
/* We can not use the extended protocol with valgrind,
because we can not restart the running
program. So return unrecognized. */
own_buf[0] = '\0';
break;
case '?':
prepare_resume_reply (own_buf, status, zignal);
break;
case 'H':
if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's') {
unsigned long gdb_id, thread_id;
gdb_id = strtoul (&own_buf[2], NULL, 16);
thread_id = gdb_id_to_thread_id (gdb_id);
if (thread_id == 0) {
write_enn (own_buf);
break;
}
if (own_buf[1] == 'g') {
general_thread = thread_id;
set_desired_inferior (1);
} else if (own_buf[1] == 'c') {
cont_thread = thread_id;
} else if (own_buf[1] == 's') {
step_thread = thread_id;
}
write_ok (own_buf);
} else {
/* Silently ignore it so that gdb can extend the protocol
without compatibility headaches. */
own_buf[0] = '\0';
}
break;
case 'g':
set_desired_inferior (1);
registers_to_string (own_buf);
break;
case 'G':
set_desired_inferior (1);
registers_from_string (&own_buf[1]);
write_ok (own_buf);
break;
case 'P': {
int regno;
char *regbytes;
Bool mod;
ThreadState *tst;
regno = strtol(&own_buf[1], NULL, 16);
regbytes = strchr(&own_buf[0], '=') + 1;
set_desired_inferior (1);
tst = (ThreadState *) inferior_target_data (current_inferior);
/* Only accept changing registers in "runnable state3.
In fact, it would be ok to change most of the registers
except a few "sensitive" registers such as the PC, SP, BP.
We assume we do not need to very specific here, and that we
can just refuse all of these. */
if (tst->status == VgTs_Runnable || tst->status == VgTs_Yielding) {
supply_register_from_string (regno, regbytes, &mod);
write_ok (own_buf);
} else {
/* at least from gdb 6.6 onwards, an E. error
reply is shown to the user. So, we do an error
msg which both is accepted by gdb as an error msg
and is readable by the user. */
VG_(sprintf)
(own_buf,
"E.\n"
"ERROR changing register %s regno %d\n"
"gdb commands changing registers (pc, sp, ...) (e.g. 'jump',\n"
"set pc, calling from gdb a function in the debugged process, ...)\n"
"can only be accepted if the thread is VgTs_Runnable or VgTs_Yielding state\n"
"Thread status is %s\n",
find_register_by_number (regno)->name, regno,
VG_(name_of_ThreadStatus)(tst->status));
if (VG_(clo_verbosity) > 1)
VG_(umsg) ("%s\n", own_buf);
}
break;
}
case 'm':
decode_m_packet (&own_buf[1], &mem_addr, &len);
if (valgrind_read_memory (mem_addr, mem_buf, len) == 0)
convert_int_to_ascii (mem_buf, own_buf, len);
else
write_enn (own_buf);
break;
case 'M':
decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
if (valgrind_write_memory (mem_addr, mem_buf, len) == 0)
write_ok (own_buf);
else
write_enn (own_buf);
break;
case 'X':
if (decode_X_packet (&own_buf[1], packet_len - 1,
&mem_addr, &len, mem_buf) < 0
|| valgrind_write_memory (mem_addr, mem_buf, len) != 0)
write_enn (own_buf);
else
write_ok (own_buf);
break;
case 'C':
convert_ascii_to_int (own_buf + 1, &sig, 1);
if (target_signal_to_host_p (sig))
zignal = target_signal_to_host (sig);
else
zignal = 0;
set_desired_inferior (0);
myresume (0, zignal);
return; // return control to valgrind
case 'S':
convert_ascii_to_int (own_buf + 1, &sig, 1);
if (target_signal_to_host_p (sig))
zignal = target_signal_to_host (sig);
else
zignal = 0;
set_desired_inferior (0);
myresume (1, zignal);
return; // return control to valgrind
case 'c':
set_desired_inferior (0);
myresume (0, 0);
return; // return control to valgrind
case 's':
set_desired_inferior (0);
myresume (1, 0);
return; // return control to valgrind
case 'Z': {
char *lenptr;
char *dataptr;
CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
int zlen = strtol (lenptr + 1, &dataptr, 16);
char type = own_buf[1];
if (type < '0' || type > '4') {
/* Watchpoint command type unrecognized. */
own_buf[0] = '\0';
} else {
int res;
res = valgrind_insert_watchpoint (type, addr, zlen);
if (res == 0)
write_ok (own_buf);
else if (res == 1)
/* Unsupported. */
own_buf[0] = '\0';
else
write_enn (own_buf);
}
break;
}
case 'z': {
char *lenptr;
char *dataptr;
CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
int zlen = strtol (lenptr + 1, &dataptr, 16);
char type = own_buf[1];
if (type < '0' || type > '4') {
/* Watchpoint command type unrecognized. */
own_buf[0] = '\0';
} else {
int res;
res = valgrind_remove_watchpoint (type, addr, zlen);
if (res == 0)
write_ok (own_buf);
else if (res == 1)
/* Unsupported. */
own_buf[0] = '\0';
else
write_enn (own_buf);
}
break;
}
case 'k':
kill_request("Gdb request to kill this process\n");
break;
case 'T': {
unsigned long gdb_id, thread_id;
gdb_id = strtoul (&own_buf[1], NULL, 16);
thread_id = gdb_id_to_thread_id (gdb_id);
if (thread_id == 0) {
write_enn (own_buf);
break;
}
if (valgrind_thread_alive (thread_id))
write_ok (own_buf);
else
write_enn (own_buf);
break;
}
case 'R':
/* Restarting the inferior is only supported in the
extended protocol.
=> It is a request we don't understand. Respond with an
empty packet so that gdb knows that we don't support this
request. */
own_buf[0] = '\0';
break;
case 'v':
/* Extended (long) request. */
handle_v_requests (own_buf, &status, &zignal);
break;
default:
/* It is a request we don't understand. Respond with an
empty packet so that gdb knows that we don't support this
request. */
own_buf[0] = '\0';
break;
}
if (new_packet_len != -1)
putpkt_binary (own_buf, new_packet_len);
else
putpkt (own_buf);
if (status == 'W')
VG_(umsg) ("\nChild exited with status %d\n", zignal);
if (status == 'X')
VG_(umsg) ("\nChild terminated with signal = 0x%x (%s)\n",
target_signal_to_host (zignal),
target_signal_to_name (zignal));
if (status == 'W' || status == 'X') {
VG_(umsg) ("Process exiting\n");
VG_(exit) (0);
}
}
/* We come here when getpkt fails => close the connection,
and re-open. Then return control to valgrind.
We return the control to valgrind as we assume that
the connection was closed due to vgdb having finished
to execute a command. */
if (VG_(clo_verbosity) > 1)
VG_(umsg) ("Remote side has terminated connection. "
"GDBserver will reopen the connection.\n");
remote_finish (reset_after_error);
remote_open (VG_(clo_vgdb_prefix));
myresume (0, 0);
resume_reply_packet_needed = False;
return;
}
/* handle_gdb_valgrind_command handles the provided mon string command.
If command is recognised, return 1 else return 0.
Note that in case of ambiguous command, 1 is returned.
*sink_wanted_at_return is modified if one of the commands
'v.set *_output' is handled.
*/
static
int handle_gdb_valgrind_command (char *mon, OutputSink *sink_wanted_at_return)
{
UWord ret = 0;
char s[strlen(mon)+1]; /* copy for strtok_r */
char *wcmd;
HChar *ssaveptr;
const char *endptr;
int kwdid;
int int_value;
vg_assert (initial_valgrind_sink_saved);
strcpy (s, mon);
wcmd = strtok_r (s, " ", &ssaveptr);
/* NB: if possible, avoid introducing a new command below which
starts with the same 3 first letters as an already existing
command. This ensures a shorter abbreviation for the user. */
switch (VG_(keyword_id) ("help v.set v.info v.wait v.kill v.translate"
" v.do",
wcmd, kwd_report_duplicated_matches)) {
case -2:
ret = 1;
break;
case -1:
break;
case 0: /* help */
ret = 1;
wcmd = strtok_r (NULL, " ", &ssaveptr);
if (wcmd == NULL) {
int_value = 0;
} else {
switch (VG_(keyword_id) ("debug", wcmd, kwd_report_all)) {
case -2: int_value = 0; break;
case -1: int_value = 0; break;
case 0: int_value = 1; break;
default: vg_assert (0);
}
}
VG_(gdb_printf) (
"general valgrind monitor commands:\n"
" help [debug] : monitor command help. With debug: + debugging commands\n"
" v.wait [<ms>] : sleep <ms> (default 0) then continue\n"
" v.info all_errors : show all errors found so far\n"
" v.info last_error : show last error found\n"
" v.info location <addr> : show information about location <addr>\n"
" v.info n_errs_found [msg] : show the nr of errors found so far and the given msg\n"
" v.info open_fds : show open file descriptors (only if --track-fds=yes)\n"
" v.kill : kill the Valgrind process\n"
" v.set gdb_output : set valgrind output to gdb\n"
" v.set log_output : set valgrind output to log\n"
" v.set mixed_output : set valgrind output to log, interactive output to gdb\n"
" v.set merge-recursive-frames <num> : merge recursive calls in max <num> frames\n"
" v.set vgdb-error <errornr> : debug me at error >= <errornr> \n");
if (int_value) { VG_(gdb_printf) (
"debugging valgrind internals monitor commands:\n"
" v.do expensive_sanity_check_general : do an expensive sanity check now\n"
" v.info gdbserver_status : show gdbserver status\n"
" v.info memory [aspacemgr] : show valgrind heap memory stats\n"
" (with aspacemgr arg, also shows valgrind segments on log ouput)\n"
" v.info exectxt : show stacktraces and stats of all execontexts\n"
" v.info scheduler : show valgrind thread state and stacktrace\n"
" v.info stats : show various valgrind and tool stats\n"
" v.info unwind <addr> [<len>] : show unwind debug info for <addr> .. <addr+len>\n"
" v.set debuglog <level> : set valgrind debug log level to <level>\n"
" v.set hostvisibility [yes*|no] : (en/dis)ables access by gdb/gdbserver to\n"
" Valgrind internal host status/memory\n"
" v.translate <addr> [<traceflags>] : debug translation of <addr> with <traceflags>\n"
" (default traceflags 0b00100000 : show after instrumentation)\n"
" An additional flag 0b100000000 allows to show gdbserver instrumentation\n");
}
break;
case 1: /* v.set */
ret = 1;
wcmd = strtok_r (NULL, " ", &ssaveptr);
switch (kwdid = VG_(keyword_id)
("vgdb-error debuglog merge-recursive-frames"
" gdb_output log_output mixed_output hostvisibility",
wcmd, kwd_report_all)) {
case -2:
case -1:
break;
case 0: /* vgdb-error */
case 1: /* debuglog */
case 2: /* merge-recursive-frames */
wcmd = strtok_r (NULL, " ", &ssaveptr);
if (wcmd == NULL) {
int_value = 0;
endptr = "empty"; /* to report an error below */
} else {
HChar *the_end;
int_value = strtol (wcmd, &the_end, 10);
endptr = the_end;
}
if (*endptr != '\0') {
VG_(gdb_printf) ("missing or malformed integer value\n");
} else if (kwdid == 0) {
VG_(printf) ("vgdb-error value changed from %d to %d\n",
VG_(dyn_vgdb_error), int_value);
VG_(dyn_vgdb_error) = int_value;
} else if (kwdid == 1) {
VG_(printf) ("debuglog value changed from %d to %d\n",
VG_(debugLog_getLevel)(), int_value);
VG_(debugLog_startup) (int_value, "gdbsrv");
} else if (kwdid == 2) {
VG_(printf)
("merge-recursive-frames value changed from %d to %d\n",
VG_(clo_merge_recursive_frames), int_value);
VG_(clo_merge_recursive_frames) = int_value;
} else {
vg_assert (0);
}
break;
case 3: /* gdb_output */
(*sink_wanted_at_return).fd = -2;
command_output_to_log = False;
VG_(gdb_printf) ("valgrind output will go to gdb\n");
break;
case 4: /* log_output */
(*sink_wanted_at_return).fd = initial_valgrind_sink.fd;
command_output_to_log = True;
VG_(gdb_printf) ("valgrind output will go to log\n");
break;
case 5: /* mixed output */
(*sink_wanted_at_return).fd = initial_valgrind_sink.fd;
command_output_to_log = False;
VG_(gdb_printf)
("valgrind output will go to log, "
"interactive output will go to gdb\n");
break;
case 6: /* hostvisibility */
wcmd = strtok_r (NULL, " ", &ssaveptr);
if (wcmd != NULL) {
switch (VG_(keyword_id) ("yes no", wcmd, kwd_report_all)) {
case -2:
case -1: break;
case 0:
hostvisibility = True;
break;
case 1:
hostvisibility = False;
break;
default: vg_assert (0);
}
} else {
hostvisibility = True;
}
if (hostvisibility) {
const DebugInfo *tooldi
= VG_(find_DebugInfo) ((Addr)handle_gdb_valgrind_command);
/* Normally, we should always find the tooldi. In case we
do not, suggest a 'likely somewhat working' address: */
const Addr tool_text_start
= tooldi ?
VG_(DebugInfo_get_text_avma) (tooldi) : 0x38000000;
const NSegment *toolseg
= tooldi ?
VG_(am_find_nsegment) (VG_(DebugInfo_get_text_avma) (tooldi))
: NULL;
VG_(gdb_printf)
("Enabled access to Valgrind memory/status by GDB\n"
"If not yet done, tell GDB which valgrind file(s) to use, "
"typically:\n"
"add-symbol-file %s %p\n",
toolseg ? VG_(am_get_filename)(toolseg)
: "<toolfile> <address> e.g.",
(void*)tool_text_start);
} else
VG_(gdb_printf)
("Disabled access to Valgrind memory/status by GDB\n");
break;
default:
vg_assert (0);
}
break;
case 2: /* v.info */ {
ret = 1;
wcmd = strtok_r (NULL, " ", &ssaveptr);
switch (kwdid = VG_(keyword_id)
("all_errors n_errs_found last_error gdbserver_status memory"
" scheduler stats open_fds exectxt location unwind",
wcmd, kwd_report_all)) {
case -2:
case -1:
break;
case 0: // all_errors
// A verbosity of minimum 2 is needed to show the errors.
VG_(show_all_errors)(/* verbosity */ 2, /* xml */ False);
break;
case 1: // n_errs_found
VG_(printf) ("n_errs_found %d n_errs_shown %d (vgdb-error %d) %s\n",
VG_(get_n_errs_found) (),
VG_(get_n_errs_shown) (),
VG_(dyn_vgdb_error),
wordn (mon, 3));
break;
case 2: // last_error
VG_(show_last_error)();
break;
case 3: // gdbserver_status
VG_(gdbserver_status_output)();
break;
case 4: /* memory */
VG_(printf) ("%'13llu bytes have already been mmap-ed ANONYMOUS.\n",
VG_(am_get_anonsize_total)());
VG_(print_all_arena_stats) ();
if (VG_(clo_profile_heap))
VG_(print_arena_cc_analysis) ();
wcmd = strtok_r (NULL, " ", &ssaveptr);
if (wcmd != NULL) {
switch (VG_(keyword_id) ("aspacemgr", wcmd, kwd_report_all)) {
case -2:
case -1: break;
case 0:
VG_(am_show_nsegments) (0, "gdbserver v.info memory aspacemgr");
break;
default: vg_assert (0);
}
}
ret = 1;
break;
case 5: /* scheduler */
VG_(show_sched_status) (True, // host_stacktrace
True, // stack_usage
True); // exited_threads
ret = 1;
break;
case 6: /* stats */
VG_(print_all_stats)(False, /* Memory stats */
True /* Tool stats */);
ret = 1;
break;
case 7: /* open_fds */
if (VG_(clo_track_fds))
VG_(show_open_fds) ("");
else
VG_(gdb_printf)
("Valgrind must be started with --track-fds=yes"
" to show open fds\n");
ret = 1;
break;
case 8: /* exectxt */
VG_(print_ExeContext_stats) (True /* with_stacktraces */);
ret = 1;
break;
case 9: { /* location */
/* Note: we prefer 'v.info location' and not 'v.info address' as
v.info address is inconsistent with the GDB (native)
command 'info address' which gives the address for a symbol.
GDB equivalent command of 'v.info location' is 'info symbol'. */
Addr address;
SizeT dummy_sz = 0x1234;
if (VG_(strtok_get_address_and_size) (&address,
&dummy_sz, &ssaveptr)) {
// If tool provides location information, use that.
if (VG_(needs).info_location) {
VG_TDICT_CALL(tool_info_location, address);
}
// If tool does not provide location info, use the common one.
// Also use the common to compare with tool when debug log is set.
if (!VG_(needs).info_location || VG_(debugLog_getLevel)() > 0 ) {
AddrInfo ai;
ai.tag = Addr_Undescribed;
VG_(describe_addr) (address, &ai);
VG_(pp_addrinfo) (address, &ai);
VG_(clear_addrinfo) (&ai);
}
}
ret = 1;
break;
}
case 10: { /* unwind */
Addr address;
SizeT sz = 1;
if (VG_(strtok_get_address_and_size) (&address,
&sz, &ssaveptr)) {
VG_(ppUnwindInfo) (address, address + sz - 1);
}
ret = 1;
break;
}
default:
vg_assert(0);
}
break;
}
case 3: /* v.wait */
wcmd = strtok_r (NULL, " ", &ssaveptr);
if (wcmd != NULL) {
int_value = strtol (wcmd, NULL, 10);
VG_(printf) ("gdbserver: continuing in %d ms ...\n", int_value);
VG_(poll)(NULL, 0, int_value);
}
VG_(printf) ("gdbserver: continuing after wait ...\n");
ret = 1;
break;
case 4: /* v.kill */
kill_request ("monitor command request to kill this process\n");
break;
case 5: { /* v.translate */
Addr address;
SizeT verbosity = 0x20;
ret = 1;
if (VG_(strtok_get_address_and_size) (&address, &verbosity, &ssaveptr)) {
/* we need to force the output to log for the translation trace,
as low level VEX tracing cannot be redirected to gdb. */
int saved_command_output_to_log = command_output_to_log;
int saved_fd = VG_(log_output_sink).fd;
Bool single_stepping_on_entry = valgrind_single_stepping();
int vex_verbosity = verbosity & 0xff;
VG_(log_output_sink).fd = initial_valgrind_sink.fd;
if ((verbosity & 0x100) && !single_stepping_on_entry) {
valgrind_set_single_stepping(True);
// to force gdbserver instrumentation.
}
# if defined(VGA_arm)
// on arm, we need to (potentially) convert this address
// to the thumb form.
address = thumb_pc (address);
# endif
VG_(translate) ( 0 /* dummy ThreadId; irrelevant due to debugging*/,
address,
/*debugging*/True,
(Int) vex_verbosity,
/*bbs_done*/0,
/*allow redir?*/True);
if ((verbosity & 0x100) && !single_stepping_on_entry) {
valgrind_set_single_stepping(False);
// reset single stepping.
}
command_output_to_log = saved_command_output_to_log;
VG_(log_output_sink).fd = saved_fd;
}
break;
}
case 6: /* v.do */
ret = 1;
wcmd = strtok_r (NULL, " ", &ssaveptr);
switch (VG_(keyword_id) ("expensive_sanity_check_general",
wcmd, kwd_report_all)) {
case -2:
case -1: break;
case 0: { /* expensive_sanity_check_general */
// Temporarily bump up sanity level to check e.g. the malloc arenas.
const Int save_clo_sanity_level = VG_(clo_sanity_level);
if (VG_(clo_sanity_level) < 4) VG_(clo_sanity_level) = 4;
VG_(sanity_check_general) (/* force_expensive */ True);
VG_(clo_sanity_level) = save_clo_sanity_level;
break;
}
default: vg_assert (0);
}
break;
default:
vg_assert (0);
}
return ret;
}
