make the remote target store thread ids in ptid_t.tid

Pedro Alves
2008-06-25T22:52:23Z

[-- Attachment #1: Type: text/plain, Size: 1453 bytes --]

Hi,

Currently, remote.c stores thread ids in the ptid.pid field, which
isn't good for multi-process support. We need to be able to store
the {pid,tid} tuple in ptids to uniquely identify threads, when we
go multi-process.

So, I've made this patch to switch it into using ptid.tid, so
we get the ptid.pid field for storing real pids.

There are several hacks that we have to preserve due to the way
the protocol worked before vCont was around, and due to sometimes
GDB not knowing about the remote threads. One of those is the
MAGIC_NULL_PTID "mechanism" which is used to have something
non-null in inferior_ptid when connected with stubs that
don't support any of the optional remote protocol extensions
related to thread support (T AA thread:TID, qC, qfThreadInfo, etc.).

I've tested this extensivelly by talking to a native gdbserver,
and native gdbserver with vCont disabled, and then also with a
gdbserver with vCont and all thread related packets and fields
disabled, to simulate old stubs and stubs that don't support
threads at all.

I didn't see any regression, and diffing the remote protocol
debug output logs in the cripled gdbserver cases showed no
differences (apart from thread ids, of course).

Does it look OK?

A good thing is that magic_null_ptid actually becomes safe and
unambigous, because a ptid_equal with a ptid of a real
thread id will always return false. I'm relying on that
property on the next patch.

--
Pedro Alves

[-- Attachment #2: 001-remote_pid_tid.diff --]
[-- Type: text/x-diff, Size: 19348 bytes --]

2008-06-25 Pedro Alves <pedro@codesourcery.com>

Use ptid_t.tid to store thread ids instead of ptid_t.pid.

* remote.c (magic_null_ptid, not_sent_ptid, any_thread_ptid): New
globals.
(general_thread, continue_thread): Change type to ptid_t.
(record_currthread): Take a ptid_t parameter instead of an
integer.
(MAGIC_NULL_PID): Delete.
(set_thread): Take a ptid_t parameter and adjust.
(set_general_thread, set_continue_thread): New.
(remote_thread_alive, remote_newthread_step)
(remote_current_thread, remote_find_new_threads)
(remote_threads_info, remote_start_remote, remote_vcont_resume)
(remote_resume_1, remote_wait, extended_remote_create_inferior_1)
(threadalive_test, remote_pid_to_str)
(remote_get_thread_local_address): Adjust.
(_initialize_remote): Initialize magic_null_ptid, not_sent_ptid
and any_thread_ptid.

---
gdb/remote.c | 238 +++++++++++++++++++++++++++++++++++++----------------------
1 file changed, 151 insertions(+), 87 deletions(-)

Index: src/gdb/remote.c
===================================================================
--- src.orig/gdb/remote.c 2008-06-25 11:22:37.000000000 +0100
+++ src/gdb/remote.c 2008-06-25 17:13:25.000000000 +0100
@@ -138,7 +138,8 @@ static void remote_interrupt_twice (int

static void interrupt_query (void);

-static void set_thread (int, int);
+static void set_general_thread (struct ptid ptid);
+static void set_continue_thread (struct ptid ptid);

static int remote_thread_alive (ptid_t);

@@ -180,7 +181,7 @@ static ptid_t remote_current_thread (pti

static void remote_find_new_threads (void);

-static void record_currthread (int currthread);
+static void record_currthread (ptid_t currthread);

static int fromhex (int a);

@@ -1063,11 +1064,16 @@ static struct async_signal_handler *sigi

\f

+static ptid_t magic_null_ptid;
+static ptid_t not_sent_ptid;
+static ptid_t any_thread_ptid;
+
+/* These are the threads which we last sent to the remote system. The
+ TID member will be -1 for all or -2 for not sent yet. */
+
+static ptid_t general_thread;
+static ptid_t continue_thread;

-/* These are the threads which we last sent to the remote system.
- -1 for all or -2 for not sent yet. */
-static int general_thread;
-static int continue_thread;

/* Call this function as a result of
1) A halt indication (T packet) containing a thread id
@@ -1076,14 +1082,14 @@ static int continue_thread;
*/

static void
-record_currthread (int currthread)
+record_currthread (ptid_t currthread)
{
general_thread = currthread;

/* If this is a new thread, add it to GDB's thread list.
If we leave it up to WFI to do this, bad things will happen. */
- if (!in_thread_list (pid_to_ptid (currthread)))
- add_thread (pid_to_ptid (currthread));
+ if (!in_thread_list (currthread))
+ add_thread (currthread);
}

static char *last_pass_packet;
@@ -1145,44 +1151,66 @@ remote_pass_signals (void)
}
}

-#define MAGIC_NULL_PID 42000
-
+/* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
+ MINUS_ONE_PTID, set the thread to -1, so the stub returns the
+ thread. If GEN is set, set the general thread, if not, then set
+ the step/continue thread. */
static void
-set_thread (int th, int gen)
+set_thread (struct ptid ptid, int gen)
{
struct remote_state *rs = get_remote_state ();
+ ptid_t state = gen ? general_thread : continue_thread;
char *buf = rs->buf;
- int state = gen ? general_thread : continue_thread;
+ char *endbuf = rs->buf + get_remote_packet_size ();

- if (state == th)
+ if (ptid_equal (state, ptid))
return;

- buf[0] = 'H';
- buf[1] = gen ? 'g' : 'c';
- if (th == MAGIC_NULL_PID)
+ *buf++ = 'H';
+ *buf++ = gen ? 'g' : 'c';
+ if (ptid_equal (ptid, magic_null_ptid))
+ xsnprintf (buf, endbuf - buf, "0");
+ else if (ptid_equal (ptid, any_thread_ptid))
+ xsnprintf (buf, endbuf - buf, "0");
+ else if (ptid_equal (ptid, minus_one_ptid))
+ xsnprintf (buf, endbuf - buf, "-1");
+ else
{
- buf[2] = '0';
- buf[3] = '\0';
+ int tid = ptid_get_tid (ptid);
+ if (tid < 0)
+ xsnprintf (buf, endbuf - buf, "-%x", -tid);
+ else
+ xsnprintf (buf, endbuf - buf, "%x", tid);
}
- else if (th < 0)
- xsnprintf (&buf[2], get_remote_packet_size () - 2, "-%x", -th);
- else
- xsnprintf (&buf[2], get_remote_packet_size () - 2, "%x", th);
- putpkt (buf);
+ putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
if (gen)
- general_thread = th;
+ general_thread = ptid;
else
- continue_thread = th;
+ continue_thread = ptid;
}
+
+static void
+set_general_thread (struct ptid ptid)
+{
+ set_thread (ptid, 1);
+}
+
+static void
+set_continue_thread (struct ptid ptid)
+{
+ set_thread (ptid, 0);
+}
+
\f
-/* Return nonzero if the thread TH is still alive on the remote system. */
+/* Return nonzero if the thread PTID is still alive on the remote
+ system. */

static int
remote_thread_alive (ptid_t ptid)
{
struct remote_state *rs = get_remote_state ();
- int tid = PIDGET (ptid);
+ int tid = ptid_get_tid (ptid);

if (tid < 0)
xsnprintf (rs->buf, get_remote_packet_size (), "T-%08x", -tid);
@@ -1802,7 +1830,7 @@ remote_get_threadlist (int startflag, th

/* remote_find_new_threads retrieves the thread list and for each
thread in the list, looks up the thread in GDB's internal list,
- ading the thread if it does not already exist. This involves
+ adding the thread if it does not already exist. This involves
getting partial thread lists from the remote target so, polling the
quit_flag is required. */

@@ -1853,9 +1881,8 @@ remote_threadlist_iterator (rmt_thread_a
static int
remote_newthread_step (threadref *ref, void *context)
{
- ptid_t ptid;
-
- ptid = pid_to_ptid (threadref_to_int (ref));
+ int pid = ptid_get_pid (inferior_ptid);
+ ptid_t ptid = ptid_build (pid, 0, threadref_to_int (ref));

if (!in_thread_list (ptid))
add_thread (ptid);
@@ -1868,16 +1895,23 @@ static ptid_t
remote_current_thread (ptid_t oldpid)
{
struct remote_state *rs = get_remote_state ();
+ char *p = rs->buf;
+ int tid;
+ int pid;

putpkt ("qC");
getpkt (&rs->buf, &rs->buf_size, 0);
if (rs->buf[0] == 'Q' && rs->buf[1] == 'C')
- /* Use strtoul here, so we'll correctly parse values whose highest
- bit is set. The protocol carries them as a simple series of
- hex digits; in the absence of a sign, strtol will see such
- values as positive numbers out of range for signed 'long', and
- return LONG_MAX to indicate an overflow. */
- return pid_to_ptid (strtoul (&rs->buf[2], NULL, 16));
+ {
+ /* Use strtoul here, so we'll correctly parse values whose
+ highest bit is set. The protocol carries them as a simple
+ series of hex digits; in the absence of a sign, strtol will
+ see such values as positive numbers out of range for signed
+ 'long', and return LONG_MAX to indicate an overflow. */
+ tid = strtoul (&rs->buf[2], NULL, 16);
+ pid = ptid_get_pid (oldpid);
+ return ptid_build (pid, 0, tid);
+ }
else
return oldpid;
}
@@ -1891,7 +1925,8 @@ remote_find_new_threads (void)
{
remote_threadlist_iterator (remote_newthread_step, 0,
CRAZY_MAX_THREADS);
- if (PIDGET (inferior_ptid) == MAGIC_NULL_PID) /* ack ack ack */
+ if (ptid_equal (inferior_ptid, magic_null_ptid))
+ /* We don't know the current thread yet. Query it. */
inferior_ptid = remote_current_thread (inferior_ptid);
}

@@ -1908,6 +1943,8 @@ remote_threads_info (void)
struct remote_state *rs = get_remote_state ();
char *bufp;
int tid;
+ int pid;
+ ptid_t new_thread;

if (remote_desc == 0) /* paranoia */
error (_("Command can only be used when connected to the remote target."));
@@ -1930,8 +1967,10 @@ remote_threads_info (void)
positive numbers out of range for signed 'long',
and return LONG_MAX to indicate an overflow. */
tid = strtoul (bufp, &bufp, 16);
- if (tid != 0 && !in_thread_list (pid_to_ptid (tid)))
- add_thread (pid_to_ptid (tid));
+ pid = ptid_get_pid (inferior_ptid);
+ new_thread = ptid_build (pid, 0, tid);
+ if (tid != 0 && !in_thread_list (new_thread))
+ add_thread (new_thread);
}
while (*bufp++ == ','); /* comma-separated list */
putpkt ("qsThreadInfo");
@@ -1974,8 +2013,8 @@ remote_threads_extra_info (struct thread

if (use_threadextra_query)
{
- xsnprintf (rs->buf, get_remote_packet_size (), "qThreadExtraInfo,%x",
- PIDGET (tp->ptid));
+ xsnprintf (rs->buf, get_remote_packet_size (), "qThreadExtraInfo,%lx",
+ ptid_get_tid (tp->ptid));
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
if (rs->buf[0] != 0)
@@ -1991,7 +2030,7 @@ remote_threads_extra_info (struct thread
use_threadextra_query = 0;
set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
| TAG_MOREDISPLAY | TAG_DISPLAY;
- int_to_threadref (&id, PIDGET (tp->ptid));
+ int_to_threadref (&id, ptid_get_tid (tp->ptid));
if (remote_get_threadinfo (&id, set, &threadinfo))
if (threadinfo.active)
{
@@ -2251,7 +2290,7 @@ remote_start_remote (struct ui_out *uiou
}

/* Let the stub know that we want it to return the thread. */
- set_thread (-1, 0);
+ set_continue_thread (minus_one_ptid);

/* Without this, some commands which require an active target
(such as kill) won't work. This variable serves (at least)
@@ -2260,7 +2299,7 @@ remote_start_remote (struct ui_out *uiou
These functions should be split out into seperate variables,
especially since GDB will someday have a notion of debugging
several processes. */
- inferior_ptid = pid_to_ptid (MAGIC_NULL_PID);
+ inferior_ptid = magic_null_ptid;

/* Now, if we have thread information, update inferior_ptid. */
inferior_ptid = remote_current_thread (inferior_ptid);
@@ -2690,8 +2729,8 @@ remote_open_1 (char *name, int from_tty,
init_all_packet_configs ();
rs->explicit_packet_size = 0;

- general_thread = -2;
- continue_thread = -2;
+ general_thread = not_sent_ptid;
+ continue_thread = not_sent_ptid;

/* Probe for ability to use "ThreadInfo" query, as required. */
use_threadinfo_query = 1;
@@ -2891,6 +2930,10 @@ extended_remote_attach_1 (struct target_

target_mark_running (target);
inferior_ptid = pid_to_ptid (pid);
+
+ /* Now, if we have thread information, update inferior_ptid. */
+ inferior_ptid = remote_current_thread (inferior_ptid);
+
attach_flag = 1;

/* Next, if the target can specify a description, read it. We do
@@ -3020,10 +3063,10 @@ remote_vcont_probe (struct remote_state

/* Resume the remote inferior by using a "vCont" packet. The thread
to be resumed is PTID; STEP and SIGGNAL indicate whether the
- resumed thread should be single-stepped and/or signalled. If PTID's
- PID is -1, then all threads are resumed; the thread to be stepped and/or
- signalled is given in the global INFERIOR_PTID. This function returns
- non-zero iff it resumes the inferior.
+ resumed thread should be single-stepped and/or signalled. If PTID
+ equals minus_one_ptid, then all threads are resumed; the thread to
+ be stepped and/or signalled is given in the global INFERIOR_PTID.
+ This function returns non-zero iff it resumes the inferior.

This function issues a strict subset of all possible vCont commands at the
moment. */
@@ -3032,7 +3075,6 @@ static int
remote_vcont_resume (ptid_t ptid, int step, enum target_signal siggnal)
{
struct remote_state *rs = get_remote_state ();
- int pid = PIDGET (ptid);
char *outbuf;
struct cleanup *old_cleanup;

@@ -3046,11 +3088,12 @@ remote_vcont_resume (ptid_t ptid, int st
about overflowing BUF. Should there be a generic
"multi-part-packet" packet? */

- if (PIDGET (inferior_ptid) == MAGIC_NULL_PID)
+ if (ptid_equal (ptid, magic_null_ptid))
{
- /* MAGIC_NULL_PTID means that we don't have any active threads, so we
- don't have any PID numbers the inferior will understand. Make sure
- to only send forms that do not specify a PID. */
+ /* MAGIC_NULL_PTID means that we don't have any active threads,
+ so we don't have any TID numbers the inferior will
+ understand. Make sure to only send forms that do not specify
+ a TID. */
if (step && siggnal != TARGET_SIGNAL_0)
outbuf = xstrprintf ("vCont;S%02x", siggnal);
else if (step)
@@ -3060,31 +3103,31 @@ remote_vcont_resume (ptid_t ptid, int st
else
outbuf = xstrprintf ("vCont;c");
}
- else if (pid == -1)
+ else if (ptid_equal (ptid, minus_one_ptid))
{
/* Resume all threads, with preference for INFERIOR_PTID. */
+ int tid = ptid_get_tid (inferior_ptid);
if (step && siggnal != TARGET_SIGNAL_0)
- outbuf = xstrprintf ("vCont;S%02x:%x;c", siggnal,
- PIDGET (inferior_ptid));
+ outbuf = xstrprintf ("vCont;S%02x:%x;c", siggnal, tid);
else if (step)
- outbuf = xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid));
+ outbuf = xstrprintf ("vCont;s:%x;c", tid);
else if (siggnal != TARGET_SIGNAL_0)
- outbuf = xstrprintf ("vCont;C%02x:%x;c", siggnal,
- PIDGET (inferior_ptid));
+ outbuf = xstrprintf ("vCont;C%02x:%x;c", siggnal, tid);
else
outbuf = xstrprintf ("vCont;c");
}
else
{
/* Scheduler locking; resume only PTID. */
+ int tid = ptid_get_tid (ptid);
if (step && siggnal != TARGET_SIGNAL_0)
- outbuf = xstrprintf ("vCont;S%02x:%x", siggnal, pid);
+ outbuf = xstrprintf ("vCont;S%02x:%x", siggnal, tid);
else if (step)
- outbuf = xstrprintf ("vCont;s:%x", pid);
+ outbuf = xstrprintf ("vCont;s:%x", tid);
else if (siggnal != TARGET_SIGNAL_0)
- outbuf = xstrprintf ("vCont;C%02x:%x", siggnal, pid);
+ outbuf = xstrprintf ("vCont;C%02x:%x", siggnal, tid);
else
- outbuf = xstrprintf ("vCont;c:%x", pid);
+ outbuf = xstrprintf ("vCont;c:%x", tid);
}

gdb_assert (outbuf && strlen (outbuf) < get_remote_packet_size ());
@@ -3108,7 +3151,6 @@ remote_resume (ptid_t ptid, int step, en
{
struct remote_state *rs = get_remote_state ();
char *buf;
- int pid = PIDGET (ptid);

last_sent_signal = siggnal;
last_sent_step = step;
@@ -3120,11 +3162,12 @@ remote_resume (ptid_t ptid, int step, en
if (remote_vcont_resume (ptid, step, siggnal))
goto done;

- /* All other supported resume packets do use Hc, so call set_thread. */
- if (pid == -1)
- set_thread (0, 0); /* Run any thread. */
+ /* All other supported resume packets do use Hc, so set the continue
+ thread. */
+ if (ptid_equal (ptid, minus_one_ptid))
+ set_continue_thread (any_thread_ptid);
else
- set_thread (pid, 0); /* Run this thread. */
+ set_continue_thread (ptid);

buf = rs->buf;
if (siggnal != TARGET_SIGNAL_0)
@@ -3347,9 +3390,7 @@ remote_console_output (char *msg)
}

/* Wait until the remote machine stops, then return,
- storing status in STATUS just as `wait' would.
- Returns "pid", which in the case of a multi-threaded
- remote OS, is the thread-id. */
+ storing status in STATUS just as `wait' would. */

static ptid_t
remote_wait (ptid_t ptid, struct target_waitstatus *status)
@@ -3357,6 +3398,7 @@ remote_wait (ptid_t ptid, struct target_
struct remote_state *rs = get_remote_state ();
struct remote_arch_state *rsa = get_remote_arch_state ();
ULONGEST thread_num = -1;
+ ULONGEST process_num = -1;
ULONGEST addr;
int solibs_changed = 0;

@@ -3453,7 +3495,6 @@ Packet: '%s'\n"),
if (strncmp (p, "thread", p1 - p) == 0)
{
p_temp = unpack_varlen_hex (++p1, &thread_num);
- record_currthread (thread_num);
p = p_temp;
}
else if ((strncmp (p, "watch", p1 - p) == 0)
@@ -3575,8 +3616,12 @@ Packet: '%s'\n"),
got_status:
if (thread_num != -1)
{
- return pid_to_ptid (thread_num);
+ ptid_t ptid;
+ ptid = ptid_build (ptid_get_pid (inferior_ptid), 0, thread_num);
+ record_currthread (ptid);
+ return ptid;
}
+
return inferior_ptid;
}

@@ -3779,7 +3824,7 @@ remote_fetch_registers (struct regcache
struct remote_arch_state *rsa = get_remote_arch_state ();
int i;

- set_thread (PIDGET (inferior_ptid), 1);
+ set_general_thread (inferior_ptid);

if (regnum >= 0)
{
@@ -3928,7 +3973,7 @@ remote_store_registers (struct regcache
struct remote_arch_state *rsa = get_remote_arch_state ();
int i;

- set_thread (PIDGET (inferior_ptid), 1);
+ set_general_thread (inferior_ptid);

if (regnum >= 0)
{
@@ -5107,7 +5152,7 @@ extended_remote_mourn_1 (struct target_o
/* Assume that the target has been restarted. Set inferior_ptid
so that bits of core GDB realizes there's something here, e.g.,
so that the user can say "kill" again. */
- inferior_ptid = pid_to_ptid (MAGIC_NULL_PID);
+ inferior_ptid = magic_null_ptid;
}
else
{
@@ -5221,7 +5266,7 @@ extended_remote_create_inferior_1 (char

/* Now mark the inferior as running before we do anything else. */
attach_flag = 0;
- inferior_ptid = pid_to_ptid (MAGIC_NULL_PID);
+ inferior_ptid = magic_null_ptid;
target_mark_running (&extended_remote_ops);

/* Get updated offsets, if the stub uses qOffsets. */
@@ -6143,7 +6188,7 @@ threadset_test_cmd (char *cmd, int tty)
int sample_thread = SAMPLE_THREAD;

printf_filtered (_("Remote threadset test\n"));
- set_thread (sample_thread, 1);
+ set_general_thread (sample_thread);
}

@@ -6151,8 +6196,10 @@ static void
threadalive_test (char *cmd, int tty)
{
int sample_thread = SAMPLE_THREAD;
+ int pid = ptid_get_pid (inferior_ptid);
+ ptid_t ptid = ptid_build (pid, 0, sample_thread);

- if (remote_thread_alive (pid_to_ptid (sample_thread)))
+ if (remote_thread_alive (ptid))
printf_filtered ("PASS: Thread alive test\n");
else
printf_filtered ("FAIL: Thread alive test\n");
@@ -6265,10 +6312,21 @@ Fetch and print the remote list of threa
static char *
remote_pid_to_str (ptid_t ptid)
{
- static char buf[32];
+ static char buf[64];

- xsnprintf (buf, sizeof buf, "Thread %d", ptid_get_pid (ptid));
- return buf;
+ if (ptid_equal (magic_null_ptid, ptid))
+ {
+ xsnprintf (buf, sizeof buf, "Thread ");
+ return buf;
+ }
+ else if (ptid_get_tid (ptid) != 0)
+ {
+ xsnprintf (buf, sizeof buf, "Thread %ld",
+ ptid_get_tid (ptid));
+ return buf;
+ }
+
+ return normal_pid_to_str (ptid);
}

/* Get the address of the thread local variable in OBJFILE which is
@@ -6285,7 +6343,7 @@ remote_get_thread_local_address (ptid_t

strcpy (p, "qGetTLSAddr:");
p += strlen (p);
- p += hexnumstr (p, PIDGET (ptid));
+ p += hexnumstr (p, ptid_get_tid (ptid));
*p++ = ',';
p += hexnumstr (p, offset);
*p++ = ',';
@@ -7479,4 +7537,10 @@ Tells gdb whether to control the remote

/* Eventually initialize fileio. See fileio.c */
initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist);
+
+ /* Take advantage of the fact that the LWP field is not used, to tag
+ special ptids with it set to != 0. */
+ magic_null_ptid = ptid_build (0, 1, -1);
+ not_sent_ptid = ptid_build (0, 1, -2);
+ any_thread_ptid = ptid_build (0, 1, 0);
}