| /* Linux-specific functions to retrieve OS data. | |
| Copyright (C) 2009-2012 Free Software Foundation, Inc. | |
| This file is part of GDB. | |
| This program is free software; you can redistribute it and/or modify | |
| it under the terms of the GNU General Public License as published by | |
| the Free Software Foundation; either version 3 of the License, or | |
| (at your option) any later version. | |
| This program is distributed in the hope that it will be useful, | |
| but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| GNU General Public License for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with this program. If not, see <http://www.gnu.org/licenses/>. */ | |
| #ifdef GDBSERVER | |
| #include "server.h" | |
| #else | |
| #include "defs.h" | |
| #endif | |
| #include "linux-osdata.h" | |
| #include <sys/types.h> | |
| #include <sys/stat.h> | |
| #include <dirent.h> | |
| #include <ctype.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <utmp.h> | |
| #include <time.h> | |
| #include <unistd.h> | |
| #include <pwd.h> | |
| #include <grp.h> | |
| #include <netdb.h> | |
| #include <netinet/in.h> | |
| #include <arpa/inet.h> | |
| #include "xml-utils.h" | |
| #include "buffer.h" | |
| #include "gdb_assert.h" | |
| #include "gdb_dirent.h" | |
| int | |
| linux_common_core_of_thread (ptid_t ptid) | |
| { | |
| char filename[sizeof ("/proc//task//stat") | |
| + 2 * 20 /* decimal digits for 2 numbers, max 2^64 bit each */ | |
| + 1]; | |
| FILE *f; | |
| char *content = NULL; | |
| char *p; | |
| char *ts = 0; | |
| int content_read = 0; | |
| int i; | |
| int core; | |
| sprintf (filename, "/proc/%d/task/%ld/stat", | |
| ptid_get_pid (ptid), ptid_get_lwp (ptid)); | |
| f = fopen (filename, "r"); | |
| if (!f) | |
| return -1; | |
| for (;;) | |
| { | |
| int n; | |
| content = xrealloc (content, content_read + 1024); | |
| n = fread (content + content_read, 1, 1024, f); | |
| content_read += n; | |
| if (n < 1024) | |
| { | |
| content[content_read] = '\0'; | |
| break; | |
| } | |
| } | |
| p = strchr (content, '('); | |
| /* Skip ")". */ | |
| if (p != NULL) | |
| p = strchr (p, ')'); | |
| if (p != NULL) | |
| p++; | |
| /* If the first field after program name has index 0, then core number is | |
| the field with index 36. There's no constant for that anywhere. */ | |
| if (p != NULL) | |
| p = strtok_r (p, " ", &ts); | |
| for (i = 0; p != NULL && i != 36; ++i) | |
| p = strtok_r (NULL, " ", &ts); | |
| if (p == NULL || sscanf (p, "%d", &core) == 0) | |
| core = -1; | |
| xfree (content); | |
| fclose (f); | |
| return core; | |
| } | |
| static void | |
| command_from_pid (char *command, int maxlen, pid_t pid) | |
| { | |
| char *stat_path = xstrprintf ("/proc/%d/stat", pid); | |
| FILE *fp = fopen (stat_path, "r"); | |
| command[0] = '\0'; | |
| if (fp) | |
| { | |
| /* sizeof (cmd) should be greater or equal to TASK_COMM_LEN (in | |
| include/linux/sched.h in the Linux kernel sources) plus two | |
| (for the brackets). */ | |
| char cmd[32]; | |
| pid_t stat_pid; | |
| int items_read = fscanf (fp, "%d %32s", &stat_pid, cmd); | |
| if (items_read == 2 && pid == stat_pid) | |
| { | |
| cmd[strlen (cmd) - 1] = '\0'; /* Remove trailing parenthesis. */ | |
| strncpy (command, cmd + 1, maxlen); /* Ignore leading parenthesis. */ | |
| } | |
| fclose (fp); | |
| } | |
| else | |
| { | |
| /* Return the PID if a /proc entry for the process cannot be found. */ | |
| snprintf (command, maxlen, "%d", pid); | |
| } | |
| command[maxlen - 1] = '\0'; /* Ensure string is null-terminated. */ | |
| xfree (stat_path); | |
| } | |
| /* Returns the command-line of the process with the given PID. The returned | |
| string needs to be freed using xfree after use. */ | |
| static char * | |
| commandline_from_pid (pid_t pid) | |
| { | |
| char *pathname = xstrprintf ("/proc/%d/cmdline", pid); | |
| char *commandline = NULL; | |
| FILE *f = fopen (pathname, "r"); | |
| if (f) | |
| { | |
| size_t len = 0; | |
| while (!feof (f)) | |
| { | |
| char buf[1024]; | |
| size_t read_bytes = fread (buf, 1, sizeof (buf), f); | |
| if (read_bytes) | |
| { | |
| commandline = (char *) xrealloc (commandline, len + read_bytes + 1); | |
| memcpy (commandline + len, buf, read_bytes); | |
| len += read_bytes; | |
| } | |
| } | |
| fclose (f); | |
| if (commandline) | |
| { | |
| size_t i; | |
| /* Replace null characters with spaces. */ | |
| for (i = 0; i < len; ++i) | |
| if (commandline[i] == '\0') | |
| commandline[i] = ' '; | |
| commandline[len] = '\0'; | |
| } | |
| else | |
| { | |
| /* Return the command in square brackets if the command-line is empty. */ | |
| commandline = (char *) xmalloc (32); | |
| commandline[0] = '['; | |
| command_from_pid (commandline + 1, 31, pid); | |
| len = strlen (commandline); | |
| if (len < 31) | |
| strcat (commandline, "]"); | |
| } | |
| } | |
| xfree (pathname); | |
| return commandline; | |
| } | |
| static void | |
| user_from_uid (char *user, int maxlen, uid_t uid) | |
| { | |
| struct passwd *pwentry = getpwuid (uid); | |
| if (pwentry) | |
| { | |
| strncpy (user, pwentry->pw_name, maxlen); | |
| user[maxlen - 1] = '\0'; /* Ensure that the user name is null-terminated. */ | |
| } | |
| else | |
| user[0] = '\0'; | |
| } | |
| static int | |
| get_process_owner (uid_t *owner, pid_t pid) | |
| { | |
| struct stat statbuf; | |
| char procentry[sizeof ("/proc/4294967295")]; | |
| sprintf (procentry, "/proc/%d", pid); | |
| if (stat (procentry, &statbuf) == 0 && S_ISDIR (statbuf.st_mode)) | |
| { | |
| *owner = statbuf.st_uid; | |
| return 0; | |
| } | |
| else | |
| return -1; | |
| } | |
| static int | |
| get_number_of_cpu_cores (void) | |
| { | |
| int cores = 0; | |
| FILE *f = fopen ("/proc/cpuinfo", "r"); | |
| while (!feof (f)) | |
| { | |
| char buf[512]; | |
| char *p = fgets (buf, sizeof (buf), f); | |
| if (p && strncmp (buf, "processor", 9) == 0) | |
| ++cores; | |
| } | |
| fclose (f); | |
| return cores; | |
| } | |
| /* CORES points to an array of at least get_number_of_cpu_cores () elements. */ | |
| static int | |
| get_cores_used_by_process (pid_t pid, int *cores) | |
| { | |
| char taskdir[sizeof ("/proc/4294967295/task")]; | |
| DIR *dir; | |
| struct dirent *dp; | |
| int task_count = 0; | |
| sprintf (taskdir, "/proc/%d/task", pid); | |
| dir = opendir (taskdir); | |
| if (dir) | |
| { | |
| while ((dp = readdir (dir)) != NULL) | |
| { | |
| pid_t tid; | |
| int core; | |
| if (!isdigit (dp->d_name[0]) | |
| || NAMELEN (dp) > sizeof ("4294967295") - 1) | |
| continue; | |
| tid = atoi (dp->d_name); | |
| core = linux_common_core_of_thread (ptid_build (pid, tid, 0)); | |
| if (core >= 0) | |
| { | |
| ++cores[core]; | |
| ++task_count; | |
| } | |
| } | |
| closedir (dir); | |
| } | |
| return task_count; | |
| } | |
| static LONGEST | |
| linux_xfer_osdata_processes (gdb_byte *readbuf, | |
| ULONGEST offset, LONGEST len) | |
| { | |
| /* We make the process list snapshot when the object starts to be read. */ | |
| static const char *buf; | |
| static LONGEST len_avail = -1; | |
| static struct buffer buffer; | |
| if (offset == 0) | |
| { | |
| DIR *dirp; | |
| if (len_avail != -1 && len_avail != 0) | |
| buffer_free (&buffer); | |
| len_avail = 0; | |
| buf = NULL; | |
| buffer_init (&buffer); | |
| buffer_grow_str (&buffer, "<osdata type=\"processes\">\n"); | |
| dirp = opendir ("/proc"); | |
| if (dirp) | |
| { | |
| const int num_cores = get_number_of_cpu_cores (); | |
| struct dirent *dp; | |
| while ((dp = readdir (dirp)) != NULL) | |
| { | |
| pid_t pid; | |
| uid_t owner; | |
| char user[UT_NAMESIZE]; | |
| char *command_line; | |
| int *cores; | |
| int task_count; | |
| char *cores_str; | |
| int i; | |
| if (!isdigit (dp->d_name[0]) | |
| || NAMELEN (dp) > sizeof ("4294967295") - 1) | |
| continue; | |
| sscanf (dp->d_name, "%d", &pid); | |
| command_line = commandline_from_pid (pid); | |
| if (get_process_owner (&owner, pid) == 0) | |
| user_from_uid (user, sizeof (user), owner); | |
| else | |
| strcpy (user, "?"); | |
| /* Find CPU cores used by the process. */ | |
| cores = (int *) xcalloc (num_cores, sizeof (int)); | |
| task_count = get_cores_used_by_process (pid, cores); | |
| cores_str = (char *) xcalloc (task_count, sizeof ("4294967295") + 1); | |
| for (i = 0; i < num_cores && task_count > 0; ++i) | |
| if (cores[i]) | |
| { | |
| char core_str[sizeof ("4294967205")]; | |
| sprintf (core_str, "%d", i); | |
| strcat (cores_str, core_str); | |
| task_count -= cores[i]; | |
| if (task_count > 0) | |
| strcat (cores_str, ","); | |
| } | |
| xfree (cores); | |
| buffer_xml_printf ( | |
| &buffer, | |
| "<item>" | |
| "<column name=\"pid\">%d</column>" | |
| "<column name=\"user\">%s</column>" | |
| "<column name=\"command\">%s</column>" | |
| "<column name=\"cores\">%s</column>" | |
| "</item>", | |
| pid, | |
| user, | |
| command_line ? command_line : "", | |
| cores_str); | |
| xfree (command_line); | |
| xfree (cores_str); | |
| } | |
| closedir (dirp); | |
| } | |
| buffer_grow_str0 (&buffer, "</osdata>\n"); | |
| buf = buffer_finish (&buffer); | |
| len_avail = strlen (buf); | |
| } | |
| if (offset >= len_avail) | |
| { | |
| /* Done. Get rid of the buffer. */ | |
| buffer_free (&buffer); | |
| buf = NULL; | |
| len_avail = 0; | |
| return 0; | |
| } | |
| if (len > len_avail - offset) | |
| len = len_avail - offset; | |
| memcpy (readbuf, buf + offset, len); | |
| return len; | |
| } | |
| static LONGEST | |
| linux_xfer_osdata_threads (gdb_byte *readbuf, | |
| ULONGEST offset, LONGEST len) | |
| { | |
| /* We make the process list snapshot when the object starts to be read. */ | |
| static const char *buf; | |
| static LONGEST len_avail = -1; | |
| static struct buffer buffer; | |
| if (offset == 0) | |
| { | |
| DIR *dirp; | |
| if (len_avail != -1 && len_avail != 0) | |
| buffer_free (&buffer); | |
| len_avail = 0; | |
| buf = NULL; | |
| buffer_init (&buffer); | |
| buffer_grow_str (&buffer, "<osdata type=\"threads\">\n"); | |
| dirp = opendir ("/proc"); | |
| if (dirp) | |
| { | |
| struct dirent *dp; | |
| while ((dp = readdir (dirp)) != NULL) | |
| { | |
| struct stat statbuf; | |
| char procentry[sizeof ("/proc/4294967295")]; | |
| if (!isdigit (dp->d_name[0]) | |
| || NAMELEN (dp) > sizeof ("4294967295") - 1) | |
| continue; | |
| sprintf (procentry, "/proc/%s", dp->d_name); | |
| if (stat (procentry, &statbuf) == 0 | |
| && S_ISDIR (statbuf.st_mode)) | |
| { | |
| DIR *dirp2; | |
| char *pathname; | |
| pid_t pid; | |
| char command[32]; | |
| pathname = xstrprintf ("/proc/%s/task", dp->d_name); | |
| pid = atoi (dp->d_name); | |
| command_from_pid (command, sizeof (command), pid); | |
| dirp2 = opendir (pathname); | |
| if (dirp2) | |
| { | |
| struct dirent *dp2; | |
| while ((dp2 = readdir (dirp2)) != NULL) | |
| { | |
| pid_t tid; | |
| int core; | |
| if (!isdigit (dp2->d_name[0]) | |
| || NAMELEN (dp2) > sizeof ("4294967295") - 1) | |
| continue; | |
| tid = atoi (dp2->d_name); | |
| core = linux_common_core_of_thread (ptid_build (pid, tid, 0)); | |
| buffer_xml_printf ( | |
| &buffer, | |
| "<item>" | |
| "<column name=\"pid\">%d</column>" | |
| "<column name=\"command\">%s</column>" | |
| "<column name=\"tid\">%d</column>" | |
| "<column name=\"core\">%d</column>" | |
| "</item>", | |
| pid, | |
| command, | |
| tid, | |
| core); | |
| } | |
| closedir (dirp2); | |
| } | |
| xfree (pathname); | |
| } | |
| } | |
| closedir (dirp); | |
| } | |
| buffer_grow_str0 (&buffer, "</osdata>\n"); | |
| buf = buffer_finish (&buffer); | |
| len_avail = strlen (buf); | |
| } | |
| if (offset >= len_avail) | |
| { | |
| /* Done. Get rid of the buffer. */ | |
| buffer_free (&buffer); | |
| buf = NULL; | |
| len_avail = 0; | |
| return 0; | |
| } | |
| if (len > len_avail - offset) | |
| len = len_avail - offset; | |
| memcpy (readbuf, buf + offset, len); | |
| return len; | |
| } | |
| struct osdata_type { | |
| char *type; | |
| char *description; | |
| LONGEST (*getter) (gdb_byte *readbuf, ULONGEST offset, LONGEST len); | |
| } osdata_table[] = { | |
| { "processes", "Listing of all processes", linux_xfer_osdata_processes }, | |
| { "threads", "Listing of all threads", linux_xfer_osdata_threads }, | |
| { NULL, NULL, NULL } | |
| }; | |
| LONGEST | |
| linux_common_xfer_osdata (const char *annex, gdb_byte *readbuf, | |
| ULONGEST offset, LONGEST len) | |
| { | |
| if (!annex || *annex == '\0') | |
| { | |
| static const char *buf; | |
| static LONGEST len_avail = -1; | |
| static struct buffer buffer; | |
| if (offset == 0) | |
| { | |
| int i; | |
| if (len_avail != -1 && len_avail != 0) | |
| buffer_free (&buffer); | |
| len_avail = 0; | |
| buf = NULL; | |
| buffer_init (&buffer); | |
| buffer_grow_str (&buffer, "<osdata type=\"types\">\n"); | |
| for (i = 0; osdata_table[i].type; ++i) | |
| buffer_xml_printf ( | |
| &buffer, | |
| "<item>" | |
| "<column name=\"Type\">%s</column>" | |
| "<column name=\"Description\">%s</column>" | |
| "</item>", | |
| osdata_table[i].type, | |
| osdata_table[i].description); | |
| buffer_grow_str0 (&buffer, "</osdata>\n"); | |
| buf = buffer_finish (&buffer); | |
| len_avail = strlen (buf); | |
| } | |
| if (offset >= len_avail) | |
| { | |
| /* Done. Get rid of the buffer. */ | |
| buffer_free (&buffer); | |
| buf = NULL; | |
| len_avail = 0; | |
| return 0; | |
| } | |
| if (len > len_avail - offset) | |
| len = len_avail - offset; | |
| memcpy (readbuf, buf + offset, len); | |
| return len; | |
| } | |
| else | |
| { | |
| int i; | |
| for (i = 0; osdata_table[i].type; ++i) | |
| { | |
| if (strcmp (annex, osdata_table[i].type) == 0) | |
| { | |
| gdb_assert (readbuf); | |
| return (osdata_table[i].getter) (readbuf, offset, len); | |
| } | |
| } | |
| return 0; | |
| } | |
| } | |