From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 12608 invoked by alias); 25 Jun 2008 22:52:23 -0000 Received: (qmail 12597 invoked by uid 22791); 25 Jun 2008 22:52:21 -0000 X-Spam-Check-By: sourceware.org Received: from mail.codesourcery.com (HELO mail.codesourcery.com) (65.74.133.4) by sourceware.org (qpsmtpd/0.31) with ESMTP; Wed, 25 Jun 2008 22:52:03 +0000 Received: (qmail 6040 invoked from network); 25 Jun 2008 22:52:00 -0000 Received: from unknown (HELO orlando.local) (pedro@127.0.0.2) by mail.codesourcery.com with ESMTPA; 25 Jun 2008 22:52:00 -0000 From: Pedro Alves To: gdb-patches@sourceware.org Subject: make the remote target store thread ids in ptid_t.tid Date: Wed, 25 Jun 2008 23:11:00 -0000 User-Agent: KMail/1.9.9 MIME-Version: 1.0 Content-Type: Multipart/Mixed; boundary="Boundary-00=_PwsYIkzE1AGCHaR" Message-Id: <200806252351.59167.pedro@codesourcery.com> X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2008-06/txt/msg00460.txt.bz2 --Boundary-00=_PwsYIkzE1AGCHaR Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit Content-Disposition: inline Content-length: 1453 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 --Boundary-00=_PwsYIkzE1AGCHaR Content-Type: text/x-diff; charset="utf-8"; name="001-remote_pid_tid.diff" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="001-remote_pid_tid.diff" Content-length: 19348 2008-06-25 Pedro Alves 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 +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); +} + -/* 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); } --Boundary-00=_PwsYIkzE1AGCHaR--