gdb/nat/linux-procfs.c

   1 /* Linux-specific PROCFS manipulation routines.
   2    Copyright (C) 2009-2015 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include "common-defs.h"
  20 #include "linux-procfs.h"
  21 #include "filestuff.h"
  22 #include <dirent.h>
  23 #include <sys/stat.h>
  24
  25 /* Return the TGID of LWPID from /proc/pid/status.  Returns -1 if not
  26    found.  */
  27
  28 static int
  29 linux_proc_get_int (pid_t lwpid, const char *field, int warn)
  30 {
  31   size_t field_len = strlen (field);
  32   FILE *status_file;
  33   char buf[100];
  34   int retval = -1;
  35
  36   snprintf (buf, sizeof (buf), "/proc/%d/status", (int) lwpid);
  37   status_file = gdb_fopen_cloexec (buf, "r");
  38   if (status_file == NULL)
  39     {
  40       if (warn)
  41         warning (_("unable to open /proc file '%s'"), buf);
  42       return -1;
  43     }
  44
  45   while (fgets (buf, sizeof (buf), status_file))
  46     if (strncmp (buf, field, field_len) == 0 && buf[field_len] == ':')
  47       {
  48         retval = strtol (&buf[field_len + 1], NULL, 10);
  49         break;
  50       }
  51
  52   fclose (status_file);
  53   return retval;
  54 }
  55
  56 /* Return the TGID of LWPID from /proc/pid/status.  Returns -1 if not
  57    found.  */
  58
  59 int
  60 linux_proc_get_tgid (pid_t lwpid)
  61 {
  62   return linux_proc_get_int (lwpid, "Tgid", 1);
  63 }
  64
  65 /* See linux-procfs.h.  */
  66
  67 pid_t
  68 linux_proc_get_tracerpid_nowarn (pid_t lwpid)
  69 {
  70   return linux_proc_get_int (lwpid, "TracerPid", 0);
  71 }
  72
  73 /* Fill in BUFFER, a buffer with BUFFER_SIZE bytes with the 'State'
  74    line of /proc/PID/status.  Returns -1 on failure to open the /proc
  75    file, 1 if the line is found, and 0 if not found.  If WARN, warn on
  76    failure to open the /proc file.  */
  77
  78 static int
  79 linux_proc_pid_get_state (pid_t pid, char *buffer, size_t buffer_size,
  80                           int warn)
  81 {
  82   FILE *procfile;
  83   int have_state;
  84
  85   xsnprintf (buffer, buffer_size, "/proc/%d/status", (int) pid);
  86   procfile = gdb_fopen_cloexec (buffer, "r");
  87   if (procfile == NULL)
  88     {
  89       if (warn)
  90         warning (_("unable to open /proc file '%s'"), buffer);
  91       return -1;
  92     }
  93
  94   have_state = 0;
  95   while (fgets (buffer, buffer_size, procfile) != NULL)
  96     if (startswith (buffer, "State:"))
  97       {
  98         have_state = 1;
  99         break;
 100       }
 101   fclose (procfile);
 102   return have_state;
 103 }
 104
 105 /* See linux-procfs.h declaration.  */
 106
 107 int
 108 linux_proc_pid_is_gone (pid_t pid)
 109 {
 110   char buffer[100];
 111   int have_state;
 112
 113   have_state = linux_proc_pid_get_state (pid, buffer, sizeof buffer, 0);
 114   if (have_state < 0)
 115     {
 116       /* If we can't open the status file, assume the thread has
 117          disappeared.  */
 118       return 1;
 119     }
 120   else if (have_state == 0)
 121     {
 122       /* No "State:" line, assume thread is alive.  */
 123       return 0;
 124     }
 125   else
 126     {
 127       return (strstr (buffer, "Z (") != NULL
 128               || strstr (buffer, "X (") != NULL);
 129     }
 130 }
 131
 132 /* Return non-zero if 'State' of /proc/PID/status contains STATE.  If
 133    WARN, warn on failure to open the /proc file.  */
 134
 135 static int
 136 linux_proc_pid_has_state (pid_t pid, const char *state, int warn)
 137 {
 138   char buffer[100];
 139   int have_state;
 140
 141   have_state = linux_proc_pid_get_state (pid, buffer, sizeof buffer, warn);
 142   return (have_state > 0 && strstr (buffer, state) != NULL);
 143 }
 144
 145 /* Detect `T (stopped)' in `/proc/PID/status'.
 146    Other states including `T (tracing stop)' are reported as false.  */
 147
 148 int
 149 linux_proc_pid_is_stopped (pid_t pid)
 150 {
 151   return linux_proc_pid_has_state (pid, "T (stopped)", 1);
 152 }
 153
 154 /* Detect `T (tracing stop)' in `/proc/PID/status'.
 155    Other states including `T (stopped)' are reported as false.  */
 156
 157 int
 158 linux_proc_pid_is_trace_stopped_nowarn (pid_t pid)
 159 {
 160   return linux_proc_pid_has_state (pid, "T (tracing stop)", 1);
 161 }
 162
 163 /* Return non-zero if PID is a zombie.  If WARN, warn on failure to
 164    open the /proc file.  */
 165
 166 static int
 167 linux_proc_pid_is_zombie_maybe_warn (pid_t pid, int warn)
 168 {
 169   return linux_proc_pid_has_state (pid, "Z (zombie)", warn);
 170 }
 171
 172 /* See linux-procfs.h declaration.  */
 173
 174 int
 175 linux_proc_pid_is_zombie_nowarn (pid_t pid)
 176 {
 177   return linux_proc_pid_is_zombie_maybe_warn (pid, 0);
 178 }
 179
 180 /* See linux-procfs.h declaration.  */
 181
 182 int
 183 linux_proc_pid_is_zombie (pid_t pid)
 184 {
 185   return linux_proc_pid_is_zombie_maybe_warn (pid, 1);
 186 }
 187
 188 /* See linux-procfs.h declaration.  */
 189
 190 char *
 191 linux_proc_pid_get_ns (pid_t pid, const char *ns)
 192 {
 193   char buf[100];
 194   char nsval[64];
 195   int ret;
 196   xsnprintf (buf, sizeof (buf), "/proc/%d/ns/%s", (int) pid, ns);
 197   ret = readlink (buf, nsval, sizeof (nsval));
 198   if (0 < ret && ret < sizeof (nsval))
 199     {
 200       nsval[ret] = '\0';
 201       return xstrdup (nsval);
 202     }
 203
 204   return NULL;
 205 }
 206
 207 /* See linux-procfs.h.  */
 208
 209 void
 210 linux_proc_attach_tgid_threads (pid_t pid,
 211                                 linux_proc_attach_lwp_func attach_lwp)
 212 {
 213   DIR *dir;
 214   char pathname[128];
 215   int new_threads_found;
 216   int iterations;
 217
 218   if (linux_proc_get_tgid (pid) != pid)
 219     return;
 220
 221   xsnprintf (pathname, sizeof (pathname), "/proc/%ld/task", (long) pid);
 222   dir = opendir (pathname);
 223   if (dir == NULL)
 224     {
 225       warning (_("Could not open /proc/%ld/task."), (long) pid);
 226       return;
 227     }
 228
 229   /* Scan the task list for existing threads.  While we go through the
 230      threads, new threads may be spawned.  Cycle through the list of
 231      threads until we have done two iterations without finding new
 232      threads.  */
 233   for (iterations = 0; iterations < 2; iterations++)
 234     {
 235       struct dirent *dp;
 236
 237       new_threads_found = 0;
 238       while ((dp = readdir (dir)) != NULL)
 239         {
 240           unsigned long lwp;
 241
 242           /* Fetch one lwp.  */
 243           lwp = strtoul (dp->d_name, NULL, 10);
 244           if (lwp != 0)
 245             {
 246               ptid_t ptid = ptid_build (pid, lwp, 0);
 247
 248               if (attach_lwp (ptid))
 249                 new_threads_found = 1;
 250             }
 251         }
 252
 253       if (new_threads_found)
 254         {
 255           /* Start over.  */
 256           iterations = -1;
 257         }
 258
 259       rewinddir (dir);
 260     }
 261
 262   closedir (dir);
 263 }
 264
 265 /* See linux-procfs.h.  */
 266
 267 int
 268 linux_proc_task_list_dir_exists (pid_t pid)
 269 {
 270   char pathname[128];
 271   struct stat buf;
 272
 273   xsnprintf (pathname, sizeof (pathname), "/proc/%ld/task", (long) pid);
 274   return (stat (pathname, &buf) == 0);
 275 }
 276
 277 /* See linux-procfs.h.  */
 278
 279 char *
 280 linux_proc_pid_to_exec_file (int pid)
 281 {
 282   static char buf[PATH_MAX];
 283   char name[PATH_MAX];
 284   ssize_t len;
 285
 286   xsnprintf (name, PATH_MAX, "/proc/%d/exe", pid);
 287   len = readlink (name, buf, PATH_MAX - 1);
 288   if (len <= 0)
 289     strcpy (buf, name);
 290   else
 291     buf[len] = '\0';
 292
 293   return buf;
 294 }