linux-procfs: Introduce enum proc_state

Parse the process's /proc/PID/status state into an enum instead of the
current scheme of passing state strings around.

gdb/ChangeLog:
2016-07-25  Pedro Alves  <palves@redhat.com>

	* nat/linux-procfs.c (enum proc_state): New enum.
	(parse_proc_status_state): New function.
	(linux_proc_pid_get_state): Replace output string buffer parameter
	with an output proc_state parameter.  Use parse_proc_status_state.
	(linux_proc_pid_is_gone): Adjust to use proc_state values.
	(linux_proc_pid_has_state): Change type of 'state' parameter; now
	an enum proc_state.  Adjust to linux_proc_pid_get_state interface
	change.
	(linux_proc_pid_is_stopped)
	(linux_proc_pid_is_trace_stopped_nowarn)
	(linux_proc_pid_is_zombie_maybe_warn): Adjust to
	linux_proc_pid_get_state interface change.

1 files changed, 64 insertions, 19 deletions

diff --git a/gdb/nat/linux-procfs.c b/gdb/nat/linux-procfs.c
index e2ea1d6..5d63e1b 100644
--- a/gdb/nat/linux-procfs.c
+++ b/gdb/nat/linux-procfs.c
@@ -70,19 +70,66 @@ 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 a PROC_STATE out of STATE, a buffer with the state found in
+   the 'State:' line of /proc/PID/status.  */
+
+static enum proc_state
+parse_proc_status_state (const char *state)
+{
+  state = skip_spaces_const (state);
+
+  switch (state[0])
+    {
+    case 'T':
+      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 +139,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 +155,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,23 +171,20 @@ 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'.
@@ -148,16 +193,16 @@ linux_proc_pid_has_state (pid_t pid, const char *state, int warn)
 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 +211,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.  */