1 /* Linux-specific PROCFS manipulation routines. 2 Copyright (C) 2009-2016 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 /* Process states as discovered in the 'State' line of 74 /proc/PID/status. Not all possible states are represented here, 75 only those that we care about. */ 76 77 enum proc_state 78 { 79 /* Some state we don't handle. */ 80 PROC_STATE_UNKNOWN, 81 82 /* Stopped on a signal. */ 83 PROC_STATE_STOPPED, 84 85 /* Tracing stop. */ 86 PROC_STATE_TRACING_STOP, 87 88 /* Dead. */ 89 PROC_STATE_DEAD, 90 91 /* Zombie. */ 92 PROC_STATE_ZOMBIE, 93 }; 94 95 /* Parse a PROC_STATE out of STATE, a buffer with the state found in 96 the 'State:' line of /proc/PID/status. */ 97 98 static enum proc_state 99 parse_proc_status_state (const char *state) 100 { 101 state = skip_spaces_const (state); 102 103 switch (state[0]) 104 { 105 case 't': 106 return PROC_STATE_TRACING_STOP; 107 case 'T': 108 /* Before Linux 2.6.33, tracing stop used uppercase T. */ 109 if (strcmp (state, "T (tracing stop)") == 0) 110 return PROC_STATE_TRACING_STOP; 111 else 112 return PROC_STATE_STOPPED; 113 case 'X': 114 return PROC_STATE_DEAD; 115 case 'Z': 116 return PROC_STATE_ZOMBIE; 117 } 118 119 return PROC_STATE_UNKNOWN; 120 } 121 122 123 /* Fill in STATE, a buffer with BUFFER_SIZE bytes with the 'State' 124 line of /proc/PID/status. Returns -1 on failure to open the /proc 125 file, 1 if the line is found, and 0 if not found. If WARN, warn on 126 failure to open the /proc file. */ 127 128 static int 129 linux_proc_pid_get_state (pid_t pid, int warn, enum proc_state *state) 130 { 131 FILE *procfile; 132 int have_state; 133 char buffer[100]; 134 135 xsnprintf (buffer, sizeof (buffer), "/proc/%d/status", (int) pid); 136 procfile = gdb_fopen_cloexec (buffer, "r"); 137 if (procfile == NULL) 138 { 139 if (warn) 140 warning (_("unable to open /proc file '%s'"), buffer); 141 return -1; 142 } 143 144 have_state = 0; 145 while (fgets (buffer, sizeof (buffer), procfile) != NULL) 146 if (startswith (buffer, "State:")) 147 { 148 have_state = 1; 149 *state = parse_proc_status_state (buffer + sizeof ("State:") - 1); 150 break; 151 } 152 fclose (procfile); 153 return have_state; 154 } 155 156 /* See linux-procfs.h declaration. */ 157 158 int 159 linux_proc_pid_is_gone (pid_t pid) 160 { 161 int have_state; 162 enum proc_state state; 163 164 have_state = linux_proc_pid_get_state (pid, 0, &state); 165 if (have_state < 0) 166 { 167 /* If we can't open the status file, assume the thread has 168 disappeared. */ 169 return 1; 170 } 171 else if (have_state == 0) 172 { 173 /* No "State:" line, assume thread is alive. */ 174 return 0; 175 } 176 else 177 return (state == PROC_STATE_ZOMBIE || state == PROC_STATE_DEAD); 178 } 179 180 /* Return non-zero if 'State' of /proc/PID/status contains STATE. If 181 WARN, warn on failure to open the /proc file. */ 182 183 static int 184 linux_proc_pid_has_state (pid_t pid, enum proc_state state, int warn) 185 { 186 int have_state; 187 enum proc_state cur_state; 188 189 have_state = linux_proc_pid_get_state (pid, warn, &cur_state); 190 return (have_state > 0 && cur_state == state); 191 } 192 193 /* Detect `T (stopped)' in `/proc/PID/status'. 194 Other states including `T (tracing stop)' are reported as false. */ 195 196 int 197 linux_proc_pid_is_stopped (pid_t pid) 198 { 199 return linux_proc_pid_has_state (pid, PROC_STATE_STOPPED, 1); 200 } 201 202 /* Detect `t (tracing stop)' in `/proc/PID/status'. 203 Other states including `T (stopped)' are reported as false. */ 204 205 int 206 linux_proc_pid_is_trace_stopped_nowarn (pid_t pid) 207 { 208 return linux_proc_pid_has_state (pid, PROC_STATE_TRACING_STOP, 1); 209 } 210 211 /* Return non-zero if PID is a zombie. If WARN, warn on failure to 212 open the /proc file. */ 213 214 static int 215 linux_proc_pid_is_zombie_maybe_warn (pid_t pid, int warn) 216 { 217 return linux_proc_pid_has_state (pid, PROC_STATE_ZOMBIE, warn); 218 } 219 220 /* See linux-procfs.h declaration. */ 221 222 int 223 linux_proc_pid_is_zombie_nowarn (pid_t pid) 224 { 225 return linux_proc_pid_is_zombie_maybe_warn (pid, 0); 226 } 227 228 /* See linux-procfs.h declaration. */ 229 230 int 231 linux_proc_pid_is_zombie (pid_t pid) 232 { 233 return linux_proc_pid_is_zombie_maybe_warn (pid, 1); 234 } 235 236 /* See linux-procfs.h. */ 237 238 const char * 239 linux_proc_tid_get_name (ptid_t ptid) 240 { 241 #define TASK_COMM_LEN 16 /* As defined in the kernel's sched.h. */ 242 243 static char comm_buf[TASK_COMM_LEN]; 244 char comm_path[100]; 245 FILE *comm_file; 246 const char *comm_val; 247 pid_t pid = ptid_get_pid (ptid); 248 pid_t tid = ptid_lwp_p (ptid) ? ptid_get_lwp (ptid) : ptid_get_pid (ptid); 249 250 xsnprintf (comm_path, sizeof (comm_path), 251 "/proc/%ld/task/%ld/comm", (long) pid, (long) tid); 252 253 comm_file = gdb_fopen_cloexec (comm_path, "r"); 254 if (comm_file == NULL) 255 return NULL; 256 257 comm_val = fgets (comm_buf, sizeof (comm_buf), comm_file); 258 fclose (comm_file); 259 260 if (comm_val != NULL) 261 { 262 int i; 263 264 /* Make sure there is no newline at the end. */ 265 for (i = 0; i < sizeof (comm_buf); i++) 266 { 267 if (comm_buf[i] == '\n') 268 { 269 comm_buf[i] = '\0'; 270 break; 271 } 272 } 273 } 274 275 return comm_val; 276 } 277 278 /* See linux-procfs.h. */ 279 280 void 281 linux_proc_attach_tgid_threads (pid_t pid, 282 linux_proc_attach_lwp_func attach_lwp) 283 { 284 DIR *dir; 285 char pathname[128]; 286 int new_threads_found; 287 int iterations; 288 289 if (linux_proc_get_tgid (pid) != pid) 290 return; 291 292 xsnprintf (pathname, sizeof (pathname), "/proc/%ld/task", (long) pid); 293 dir = opendir (pathname); 294 if (dir == NULL) 295 { 296 warning (_("Could not open /proc/%ld/task."), (long) pid); 297 return; 298 } 299 300 /* Scan the task list for existing threads. While we go through the 301 threads, new threads may be spawned. Cycle through the list of 302 threads until we have done two iterations without finding new 303 threads. */ 304 for (iterations = 0; iterations < 2; iterations++) 305 { 306 struct dirent *dp; 307 308 new_threads_found = 0; 309 while ((dp = readdir (dir)) != NULL) 310 { 311 unsigned long lwp; 312 313 /* Fetch one lwp. */ 314 lwp = strtoul (dp->d_name, NULL, 10); 315 if (lwp != 0) 316 { 317 ptid_t ptid = ptid_build (pid, lwp, 0); 318 319 if (attach_lwp (ptid)) 320 new_threads_found = 1; 321 } 322 } 323 324 if (new_threads_found) 325 { 326 /* Start over. */ 327 iterations = -1; 328 } 329 330 rewinddir (dir); 331 } 332 333 closedir (dir); 334 } 335 336 /* See linux-procfs.h. */ 337 338 int 339 linux_proc_task_list_dir_exists (pid_t pid) 340 { 341 char pathname[128]; 342 struct stat buf; 343 344 xsnprintf (pathname, sizeof (pathname), "/proc/%ld/task", (long) pid); 345 return (stat (pathname, &buf) == 0); 346 } 347 348 /* See linux-procfs.h. */ 349 350 char * 351 linux_proc_pid_to_exec_file (int pid) 352 { 353 static char buf[PATH_MAX]; 354 char name[PATH_MAX]; 355 ssize_t len; 356 357 xsnprintf (name, PATH_MAX, "/proc/%d/exe", pid); 358 len = readlink (name, buf, PATH_MAX - 1); 359 if (len <= 0) 360 strcpy (buf, name); 361 else 362 buf[len] = '\0'; 363 364 return buf; 365 } 366