/* Main code for remote server for GDB.
- Copyright (C) 1989-2018 Free Software Foundation, Inc.
+ Copyright (C) 1989-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "server.h"
#include "gdbthread.h"
-#include "agent.h"
+#include "common/agent.h"
#include "notif.h"
#include "tdesc.h"
-#include "rsp-low.h"
-#include "signals-state-save-restore.h"
+#include "common/rsp-low.h"
+#include "common/signals-state-save-restore.h"
#include <ctype.h>
#include <unistd.h>
#if HAVE_SIGNAL_H
#include <signal.h>
#endif
-#include "gdb_vecs.h"
-#include "gdb_wait.h"
-#include "btrace-common.h"
-#include "filestuff.h"
+#include "common/gdb_vecs.h"
+#include "common/gdb_wait.h"
+#include "common/btrace-common.h"
+#include "common/filestuff.h"
#include "tracepoint.h"
#include "dll.h"
#include "hostio.h"
#include <vector>
-#include "common-inferior.h"
-#include "job-control.h"
-#include "environ.h"
+#include "common/common-inferior.h"
+#include "common/job-control.h"
+#include "common/environ.h"
#include "filenames.h"
-#include "pathstuff.h"
+#include "common/pathstuff.h"
#include "common/selftest.h"
+#include "common/scope-exit.h"
#define require_running_or_return(BUF) \
if (!target_running ()) \
relative to a single stop reply. We keep a queue of these to
push to GDB in non-stop mode. */
-struct vstop_notif
+struct vstop_notif : public notif_event
{
- struct notif_event base;
-
/* Thread or process that got the event. */
ptid_t ptid;
btrace configuration. */
static struct btrace_config current_btrace_conf;
-DEFINE_QUEUE_P (notif_event_p);
-
/* The client remote protocol state. */
static client_state g_client_state;
static void
queue_stop_reply (ptid_t ptid, struct target_waitstatus *status)
{
- struct vstop_notif *new_notif = XNEW (struct vstop_notif);
+ struct vstop_notif *new_notif = new struct vstop_notif;
new_notif->ptid = ptid;
new_notif->status = *status;
- notif_event_enque (¬if_stop, (struct notif_event *) new_notif);
+ notif_event_enque (¬if_stop, new_notif);
}
-static int
-remove_all_on_match_ptid (QUEUE (notif_event_p) *q,
- QUEUE_ITER (notif_event_p) *iter,
- struct notif_event *event,
- void *data)
+static bool
+remove_all_on_match_ptid (struct notif_event *event, ptid_t filter_ptid)
{
- ptid_t filter_ptid = *(ptid_t *) data;
struct vstop_notif *vstop_event = (struct vstop_notif *) event;
- if (vstop_event->ptid.matches (filter_ptid))
- {
- if (q->free_func != NULL)
- q->free_func (event);
-
- QUEUE_remove_elem (notif_event_p, q, iter);
- }
-
- return 1;
+ return vstop_event->ptid.matches (filter_ptid);
}
/* See server.h. */
void
discard_queued_stop_replies (ptid_t ptid)
{
- QUEUE_iterate (notif_event_p, notif_stop.queue,
- remove_all_on_match_ptid, &ptid);
+ std::list<notif_event *>::iterator iter, next, end;
+ end = notif_stop.queue.end ();
+ for (iter = notif_stop.queue.begin (); iter != end; iter = next)
+ {
+ next = iter;
+ ++next;
+
+ if (remove_all_on_match_ptid (*iter, ptid))
+ {
+ delete *iter;
+ notif_stop.queue.erase (iter);
+ }
+ }
}
static void
prepare_resume_reply (own_buf, vstop->ptid, &vstop->status);
}
-/* QUEUE_iterate callback helper for in_queued_stop_replies. */
+/* Helper for in_queued_stop_replies. */
-static int
-in_queued_stop_replies_ptid (QUEUE (notif_event_p) *q,
- QUEUE_ITER (notif_event_p) *iter,
- struct notif_event *event,
- void *data)
+static bool
+in_queued_stop_replies_ptid (struct notif_event *event, ptid_t filter_ptid)
{
- ptid_t filter_ptid = *(ptid_t *) data;
struct vstop_notif *vstop_event = (struct vstop_notif *) event;
if (vstop_event->ptid.matches (filter_ptid))
- return 0;
+ return true;
/* Don't resume fork children that GDB does not know about yet. */
if ((vstop_event->status.kind == TARGET_WAITKIND_FORKED
|| vstop_event->status.kind == TARGET_WAITKIND_VFORKED)
&& vstop_event->status.value.related_pid.matches (filter_ptid))
- return 0;
+ return true;
- return 1;
+ return false;
}
/* See server.h. */
int
in_queued_stop_replies (ptid_t ptid)
{
- return !QUEUE_iterate (notif_event_p, notif_stop.queue,
- in_queued_stop_replies_ptid, &ptid);
+ for (notif_event *event : notif_stop.queue)
+ {
+ if (in_queued_stop_replies_ptid (event, ptid))
+ return true;
+ }
+
+ return false;
}
struct notif_server notif_stop =
{
- "vStopped", "Stop", NULL, vstop_notif_reply,
+ "vStopped", "Stop", {}, vstop_notif_reply,
};
static int
/* myattach should return -1 if attaching is unsupported,
0 if it succeeded, and call error() otherwise. */
+ if (find_process_pid (pid) != nullptr)
+ error ("Already attached to process %d\n", pid);
+
if (myattach (pid) != 0)
return -1;
return 0;
}
-extern int remote_debug;
-
/* Decode a qXfer read request. Return 0 if everything looks OK,
or -1 otherwise. */
return -1;
}
- TRY
+ try
{
if (strcmp (op, "bts") == 0)
handle_btrace_enable_bts (thread);
write_ok (own_buf);
}
- CATCH (exception, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &exception)
{
- sprintf (own_buf, "E.%s", exception.message);
+ sprintf (own_buf, "E.%s", exception.what ());
}
- END_CATCH
return 1;
}
fprintf (stderr, "Detaching from process %d\n", process->pid);
stop_tracing ();
- if (detach_inferior (process->pid) != 0)
+
+ /* We'll need this after PROCESS has been destroyed. */
+ int pid = process->pid;
+
+ if (detach_inferior (process) != 0)
write_enn (own_buf);
else
{
- discard_queued_stop_replies (ptid_t (process->pid));
+ discard_queued_stop_replies (ptid_t (pid));
write_ok (own_buf);
if (extended_protocol || target_running ())
and instead treat this like a normal program exit. */
cs.last_status.kind = TARGET_WAITKIND_EXITED;
cs.last_status.value.integer = 0;
- cs.last_ptid = ptid_t (process->pid);
+ cs.last_ptid = ptid_t (pid);
current_thread = NULL;
}
/* If we are attached, then we can exit. Otherwise, we
need to hang around doing nothing, until the child is
gone. */
- join_inferior (process->pid);
+ join_inferior (pid);
exit (0);
}
}
write_enn (own_buf);
}
}
+ else if (strcmp (mon, "set debug-file") == 0)
+ debug_set_output (nullptr);
+ else if (startswith (mon, "set debug-file "))
+ debug_set_output (mon + sizeof ("set debug-file ") - 1);
else if (strcmp (mon, "help") == 0)
monitor_show_help ();
else if (strcmp (mon, "exit") == 0)
{
buffer_free (&cache);
- TRY
+ try
{
result = target_read_btrace (thread->btrace, &cache, type);
if (result != 0)
memcpy (cs.own_buf, cache.buffer, cache.used_size);
}
- CATCH (exception, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &exception)
{
- sprintf (cs.own_buf, "E.%s", exception.message);
+ sprintf (cs.own_buf, "E.%s", exception.what ());
result = -1;
}
- END_CATCH
if (result != 0)
return -3;
{
buffer_free (&cache);
- TRY
+ try
{
result = target_read_btrace_conf (thread->btrace, &cache);
if (result != 0)
memcpy (cs.own_buf, cache.buffer, cache.used_size);
}
- CATCH (exception, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &exception)
{
- sprintf (cs.own_buf, "E.%s", exception.message);
+ sprintf (cs.own_buf, "E.%s", exception.what ());
result = -1;
}
- END_CATCH
if (result != 0)
return -3;
pid = strtol (p, NULL, 16);
else
pid = signal_pid;
- if (pid != 0 && kill_inferior (pid) == 0)
+
+ process_info *proc = find_process_pid (pid);
+
+ if (proc != nullptr && kill_inferior (proc) == 0)
{
cs.last_status.kind = TARGET_WAITKIND_SIGNALLED;
cs.last_status.value.sig = GDB_SIGNAL_KILL;
manage the thread's last_status field. */
if (the_target->thread_stopped == NULL)
{
- struct vstop_notif *new_notif = XNEW (struct vstop_notif);
+ struct vstop_notif *new_notif = new struct vstop_notif;
new_notif->ptid = thread->id;
new_notif->status = thread->last_status;
/* Pass the last stop reply back to GDB, but don't notify
yet. */
- notif_event_enque (¬if_stop,
- (struct notif_event *) new_notif);
+ notif_event_enque (¬if_stop, new_notif);
}
else
{
/* If the last event thread is not found for some reason, look
for some other thread that might have an event to report. */
if (thread == NULL)
- thread = find_thread ([] (thread_info *thread)
+ thread = find_thread ([] (thread_info *thr_arg)
{
- return thread->status_pending_p;
+ return thr_arg->status_pending_p;
});
/* If we're still out of luck, simply pick the first thread in
gdbserver_version (void)
{
printf ("GNU gdbserver %s%s\n"
- "Copyright (C) 2018 Free Software Foundation, Inc.\n"
+ "Copyright (C) 2019 Free Software Foundation, Inc.\n"
"gdbserver is free software, covered by the "
"GNU General Public License.\n"
"This gdbserver was configured as \"%s\"\n",
"Debug options:\n"
"\n"
" --debug Enable general debugging output.\n"
- " --debug-format=opt1[,opt2,...]\n"
+ " --debug-format=OPT1[,OPT2,...]\n"
" Specify extra content in debugging output.\n"
" Options:\n"
" all\n"
" none\n"
" timestamp\n"
" --remote-debug Enable remote protocol debugging output.\n"
- " --disable-packet=opt1[,opt2,...]\n"
+ " --disable-packet=OPT1[,OPT2,...]\n"
" Disable support for RSP packets or features.\n"
" Options:\n"
" vCont, Tthread, qC, qfThreadInfo and \n"
static void
kill_inferior_callback (process_info *process)
{
- int pid = process->pid;
-
- kill_inferior (pid);
- discard_queued_stop_replies (ptid_t (pid));
+ kill_inferior (process);
+ discard_queued_stop_replies (ptid_t (process->pid));
}
/* Call this when exiting gdbserver with possible inferiors that need
int pid = process->pid;
if (process->attached)
- detach_inferior (pid);
+ detach_inferior (process);
else
- kill_inferior (pid);
+ kill_inferior (process);
discard_queued_stop_replies (ptid_t (pid));
});
/* Value that will be passed to exit(3) when gdbserver exits. */
static int exit_code;
-/* Cleanup version of detach_or_kill_for_exit. */
+/* Wrapper for detach_or_kill_for_exit that catches and prints
+ errors. */
static void
-detach_or_kill_for_exit_cleanup (void *ignore)
+detach_or_kill_for_exit_cleanup ()
{
-
- TRY
+ try
{
detach_or_kill_for_exit ();
}
-
- CATCH (exception, RETURN_MASK_ALL)
+ catch (const gdb_exception &exception)
{
fflush (stdout);
- fprintf (stderr, "Detach or kill failed: %s\n", exception.message);
+ fprintf (stderr, "Detach or kill failed: %s\n",
+ exception.what ());
exit_code = 1;
}
- END_CATCH
}
/* Main function. This is called by the real "main" function,
}
else if (strcmp (*next_arg, "--remote-debug") == 0)
remote_debug = 1;
+ else if (startswith (*next_arg, "--debug-file="))
+ debug_set_output ((*next_arg) + sizeof ("--debug-file=") -1);
else if (strcmp (*next_arg, "--disable-packet") == 0)
{
gdbserver_show_disableable (stdout);
initialize_event_loop ();
if (target_supports_tracepoints ())
initialize_tracepoint ();
- initialize_notif ();
mem_buf = (unsigned char *) xmalloc (PBUFSIZ);
#if GDB_SELF_TEST
selftests::run_tests (selftest_filter);
#else
- printf (_("Selftests are not available in a non-development build.\n"));
+ printf (_("Selftests have been disabled for this build.\n"));
#endif
throw_quit ("Quit");
}
int i, n;
n = argc - (next_arg - argv);
- program_path.set (gdb::unique_xmalloc_ptr<char> (xstrdup (next_arg[0])));
+ program_path.set (make_unique_xstrdup (next_arg[0]));
for (i = 1; i < n; i++)
program_args.push_back (xstrdup (next_arg[i]));
program_args.push_back (NULL);
cs.last_status.value.integer = 0;
cs.last_ptid = minus_one_ptid;
}
- make_cleanup (detach_or_kill_for_exit_cleanup, NULL);
+
+ SCOPE_EXIT { detach_or_kill_for_exit_cleanup (); };
/* Don't report shared library events on the initial connection,
even if some libraries are preloaded. Avoids the "stopped by
remote_open (port);
- TRY
+ try
{
/* Wait for events. This will return when all event sources
are removed from the event loop. */
}
}
}
- CATCH (exception, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &exception)
{
fflush (stdout);
- fprintf (stderr, "gdbserver: %s\n", exception.message);
+ fprintf (stderr, "gdbserver: %s\n", exception.what ());
if (response_needed)
{
if (run_once)
throw_quit ("Quit");
}
- END_CATCH
}
}
main (int argc, char *argv[])
{
- TRY
+ try
{
captured_main (argc, argv);
}
- CATCH (exception, RETURN_MASK_ALL)
+ catch (const gdb_exception &exception)
{
if (exception.reason == RETURN_ERROR)
{
fflush (stdout);
- fprintf (stderr, "%s\n", exception.message);
+ fprintf (stderr, "%s\n", exception.what ());
fprintf (stderr, "Exiting\n");
exit_code = 1;
}
exit (exit_code);
}
- END_CATCH
gdb_assert_not_reached ("captured_main should never return");
}
client_state &cs = get_client_state ();
int signal;
unsigned int len;
- int res;
CORE_ADDR mem_addr;
unsigned char sig;
int packet_len;
}
break;
case 'm':
- require_running_or_break (cs.own_buf);
- decode_m_packet (&cs.own_buf[1], &mem_addr, &len);
- res = gdb_read_memory (mem_addr, mem_buf, len);
- if (res < 0)
- write_enn (cs.own_buf);
- else
- bin2hex (mem_buf, cs.own_buf, res);
+ {
+ require_running_or_break (cs.own_buf);
+ decode_m_packet (&cs.own_buf[1], &mem_addr, &len);
+ int res = gdb_read_memory (mem_addr, mem_buf, len);
+ if (res < 0)
+ write_enn (cs.own_buf);
+ else
+ bin2hex (mem_buf, cs.own_buf, res);
+ }
break;
case 'M':
require_running_or_break (cs.own_buf);
static void
push_stop_notification (ptid_t ptid, struct target_waitstatus *status)
{
- struct vstop_notif *vstop_notif = XNEW (struct vstop_notif);
+ struct vstop_notif *vstop_notif = new struct vstop_notif;
vstop_notif->status = *status;
vstop_notif->ptid = ptid;
/* Push Stop notification. */
- notif_push (¬if_stop, (struct notif_event *) vstop_notif);
+ notif_push (¬if_stop, vstop_notif);
}
/* Event-loop callback for target events. */
projects / deliverable / binutils-gdb.git / blobdiff