From patchwork Fri Jul 22 16:04:04 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Pedro Alves X-Patchwork-Id: 13929 Received: (qmail 66860 invoked by alias); 22 Jul 2016 16:04:09 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 66845 invoked by uid 89); 22 Jul 2016 16:04:08 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-3.2 required=5.0 tests=BAYES_00, RP_MATCHES_RCVD, SPF_HELO_PASS autolearn=ham version=3.3.2 spammy=Fill, *state, Dead, Hx-languages-length:5476 X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-GCM-SHA384 encrypted) ESMTPS; Fri, 22 Jul 2016 16:04:07 +0000 Received: from int-mx13.intmail.prod.int.phx2.redhat.com (int-mx13.intmail.prod.int.phx2.redhat.com [10.5.11.26]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 2A69861A0D for ; Fri, 22 Jul 2016 16:04:06 +0000 (UTC) Received: from [127.0.0.1] (ovpn01.gateway.prod.ext.ams2.redhat.com [10.39.146.11]) by int-mx13.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id u6MG44Xp031335; Fri, 22 Jul 2016 12:04:05 -0400 Subject: Re: [patch] Fix for newer kernels with: t (tracing stop) To: Jan Kratochvil , gdb-patches@sourceware.org References: <20160604122904.GA11651@host1.jankratochvil.net> <3132f4e9-8695-ad54-e0ef-c577dbdaba39@redhat.com> From: Pedro Alves Message-ID: <7e8bd23c-d059-56c4-6f49-69275108e7b3@redhat.com> Date: Fri, 22 Jul 2016 17:04:04 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Thunderbird/45.1.1 MIME-Version: 1.0 In-Reply-To: <3132f4e9-8695-ad54-e0ef-c577dbdaba39@redhat.com> On 07/22/2016 04:35 PM, Pedro Alves wrote: > OK. > > I wonder whether it wouldn't simplify things to parse the > state into some new enum lwp_state instead of the current scheme > of passing state strings around. I may give that a try as follow up. > Like this. This one's against current master, however. Turned out to be easy/quick to try. Untested though. I'll rebase if you want to put yours in first. From 9be7dff19a73f6d64dcbb3d9cd7d965ca48c3ed6 Mon Sep 17 00:00:00 2001 From: Pedro Alves Date: Fri, 22 Jul 2016 16:10:00 +0100 Subject: [PATCH] Introduce enum proc_state --- gdb/nat/linux-procfs.c | 86 ++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 66 insertions(+), 20 deletions(-) diff --git a/gdb/nat/linux-procfs.c b/gdb/nat/linux-procfs.c index e2ea1d6..9dd3fd7 100644 --- a/gdb/nat/linux-procfs.c +++ b/gdb/nat/linux-procfs.c @@ -70,19 +70,67 @@ linux_proc_get_tracerpid_nowarn (pid_t lwpid) return linux_proc_get_int (lwpid, "TracerPid", 0); } -/* Fill in BUFFER, a buffer with BUFFER_SIZE bytes with the 'State' +/* Process states as discovered in the 'State' line of + /proc/PID/status. Not all possible states are represented here, + only those that we care about. */ + +enum proc_state +{ + /* Some state we don't handle. */ + PROC_STATE_UNKNOWN, + + /* Stopped on a signal. */ + PROC_STATE_STOPPED, + + /* Tracing stop. */ + PROC_STATE_TRACING_STOP, + + /* Dead. */ + PROC_STATE_DEAD, + + /* Zombie. */ + PROC_STATE_ZOMBIE, +}; + +/* Parse an PROC_STATE out of STATE, a buffer with the 'State' line of + /proc/PID/status. */ + +static enum proc_state +parse_proc_status_state (const char *state) +{ + switch (state[0]) + { + case 't': + return PROC_STATE_TRACING_STOP; + case 'T': + /* Lowercase 't' was introduced in Linux 2.6.33. */ + if (strcmp (state, "T (tracing stop)") == 0) + return PROC_STATE_TRACING_STOP; + else + return PROC_STATE_STOPPED; + case 'X': + return PROC_STATE_DEAD; + case 'Z': + return PROC_STATE_ZOMBIE; + } + + return PROC_STATE_UNKNOWN; +} + + +/* Fill in STATE, a buffer with BUFFER_SIZE bytes with the 'State' line of /proc/PID/status. Returns -1 on failure to open the /proc file, 1 if the line is found, and 0 if not found. If WARN, warn on failure to open the /proc file. */ static int -linux_proc_pid_get_state (pid_t pid, char *buffer, size_t buffer_size, - int warn) +linux_proc_pid_get_state (pid_t pid, int warn, enum proc_state *state) { FILE *procfile; int have_state; + char buffer[100]; - xsnprintf (buffer, buffer_size, "/proc/%d/status", (int) pid); + xsnprintf (buffer, sizeof buffer, "/proc/%d/status", (int) pid); procfile = gdb_fopen_cloexec (buffer, "r"); if (procfile == NULL) { @@ -92,10 +140,11 @@ linux_proc_pid_get_state (pid_t pid, char *buffer, size_t buffer_size, } have_state = 0; - while (fgets (buffer, buffer_size, procfile) != NULL) + while (fgets (buffer, sizeof (buffer), procfile) != NULL) if (startswith (buffer, "State:")) { have_state = 1; + *state = parse_proc_status_state (buffer + sizeof ("State:") - 1); break; } fclose (procfile); @@ -107,10 +156,10 @@ linux_proc_pid_get_state (pid_t pid, char *buffer, size_t buffer_size, int linux_proc_pid_is_gone (pid_t pid) { - char buffer[100]; int have_state; + enum proc_state state; - have_state = linux_proc_pid_get_state (pid, buffer, sizeof buffer, 0); + have_state = linux_proc_pid_get_state (pid, 0, &state); if (have_state < 0) { /* If we can't open the status file, assume the thread has @@ -123,41 +172,38 @@ linux_proc_pid_is_gone (pid_t pid) return 0; } else - { - return (strstr (buffer, "Z (") != NULL - || strstr (buffer, "X (") != NULL); - } + return (state == PROC_STATE_ZOMBIE || state == PROC_STATE_DEAD); } /* Return non-zero if 'State' of /proc/PID/status contains STATE. If WARN, warn on failure to open the /proc file. */ static int -linux_proc_pid_has_state (pid_t pid, const char *state, int warn) +linux_proc_pid_has_state (pid_t pid, enum proc_state state, int warn) { - char buffer[100]; int have_state; + enum proc_state cur_state; - have_state = linux_proc_pid_get_state (pid, buffer, sizeof buffer, warn); - return (have_state > 0 && strstr (buffer, state) != NULL); + have_state = linux_proc_pid_get_state (pid, warn, &cur_state); + return (have_state > 0 && cur_state == state); } /* Detect `T (stopped)' in `/proc/PID/status'. - Other states including `T (tracing stop)' are reported as false. */ + Other states including `t (tracing stop)' are reported as false. */ int linux_proc_pid_is_stopped (pid_t pid) { - return linux_proc_pid_has_state (pid, "T (stopped)", 1); + return linux_proc_pid_has_state (pid, PROC_STATE_STOPPED, 1); } -/* Detect `T (tracing stop)' in `/proc/PID/status'. +/* Detect `t (tracing stop)' in `/proc/PID/status'. Other states including `T (stopped)' are reported as false. */ int linux_proc_pid_is_trace_stopped_nowarn (pid_t pid) { - return linux_proc_pid_has_state (pid, "T (tracing stop)", 1); + return linux_proc_pid_has_state (pid, PROC_STATE_TRACING_STOP, 1); } /* Return non-zero if PID is a zombie. If WARN, warn on failure to @@ -166,7 +212,7 @@ linux_proc_pid_is_trace_stopped_nowarn (pid_t pid) static int linux_proc_pid_is_zombie_maybe_warn (pid_t pid, int warn) { - return linux_proc_pid_has_state (pid, "Z (zombie)", warn); + return linux_proc_pid_has_state (pid, PROC_STATE_ZOMBIE, warn); } /* See linux-procfs.h declaration. */