1 /* Linux-specific functions to retrieve OS data. 2 3 Copyright (C) 2009-2012 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #ifdef GDBSERVER 21 #include "server.h" 22 #else 23 #include "defs.h" 24 #endif 25 26 #include "linux-osdata.h" 27 28 #include <sys/types.h> 29 #include <sys/stat.h> 30 #include <dirent.h> 31 #include <ctype.h> 32 #include <stdlib.h> 33 #include <string.h> 34 #include <utmp.h> 35 #include <time.h> 36 #include <unistd.h> 37 #include <pwd.h> 38 #include <grp.h> 39 #include <netdb.h> 40 #include <netinet/in.h> 41 #include <arpa/inet.h> 42 43 #include "xml-utils.h" 44 #include "buffer.h" 45 #include "gdb_assert.h" 46 #include "gdb_dirent.h" 47 48 int 49 linux_common_core_of_thread (ptid_t ptid) 50 { 51 char filename[sizeof ("/proc//task//stat") 52 + 2 * 20 /* decimal digits for 2 numbers, max 2^64 bit each */ 53 + 1]; 54 FILE *f; 55 char *content = NULL; 56 char *p; 57 char *ts = 0; 58 int content_read = 0; 59 int i; 60 int core; 61 62 sprintf (filename, "/proc/%d/task/%ld/stat", 63 ptid_get_pid (ptid), ptid_get_lwp (ptid)); 64 f = fopen (filename, "r"); 65 if (!f) 66 return -1; 67 68 for (;;) 69 { 70 int n; 71 content = xrealloc (content, content_read + 1024); 72 n = fread (content + content_read, 1, 1024, f); 73 content_read += n; 74 if (n < 1024) 75 { 76 content[content_read] = '\0'; 77 break; 78 } 79 } 80 81 p = strchr (content, '('); 82 83 /* Skip ")". */ 84 if (p != NULL) 85 p = strchr (p, ')'); 86 if (p != NULL) 87 p++; 88 89 /* If the first field after program name has index 0, then core number is 90 the field with index 36. There's no constant for that anywhere. */ 91 if (p != NULL) 92 p = strtok_r (p, " ", &ts); 93 for (i = 0; p != NULL && i != 36; ++i) 94 p = strtok_r (NULL, " ", &ts); 95 96 if (p == NULL || sscanf (p, "%d", &core) == 0) 97 core = -1; 98 99 xfree (content); 100 fclose (f); 101 102 return core; 103 } 104 105 static void 106 command_from_pid (char *command, int maxlen, pid_t pid) 107 { 108 char *stat_path = xstrprintf ("/proc/%d/stat", pid); 109 FILE *fp = fopen (stat_path, "r"); 110 111 command[0] = '\0'; 112 113 if (fp) 114 { 115 /* sizeof (cmd) should be greater or equal to TASK_COMM_LEN (in 116 include/linux/sched.h in the Linux kernel sources) plus two 117 (for the brackets). */ 118 char cmd[32]; 119 pid_t stat_pid; 120 int items_read = fscanf (fp, "%d %32s", &stat_pid, cmd); 121 122 if (items_read == 2 && pid == stat_pid) 123 { 124 cmd[strlen (cmd) - 1] = '\0'; /* Remove trailing parenthesis. */ 125 strncpy (command, cmd + 1, maxlen); /* Ignore leading parenthesis. */ 126 } 127 128 fclose (fp); 129 } 130 else 131 { 132 /* Return the PID if a /proc entry for the process cannot be found. */ 133 snprintf (command, maxlen, "%d", pid); 134 } 135 136 command[maxlen - 1] = '\0'; /* Ensure string is null-terminated. */ 137 138 xfree (stat_path); 139 } 140 141 /* Returns the command-line of the process with the given PID. The returned 142 string needs to be freed using xfree after use. */ 143 144 static char * 145 commandline_from_pid (pid_t pid) 146 { 147 char *pathname = xstrprintf ("/proc/%d/cmdline", pid); 148 char *commandline = NULL; 149 FILE *f = fopen (pathname, "r"); 150 151 if (f) 152 { 153 size_t len = 0; 154 155 while (!feof (f)) 156 { 157 char buf[1024]; 158 size_t read_bytes = fread (buf, 1, sizeof (buf), f); 159 160 if (read_bytes) 161 { 162 commandline = (char *) xrealloc (commandline, len + read_bytes + 1); 163 memcpy (commandline + len, buf, read_bytes); 164 len += read_bytes; 165 } 166 } 167 168 fclose (f); 169 170 if (commandline) 171 { 172 size_t i; 173 174 /* Replace null characters with spaces. */ 175 for (i = 0; i < len; ++i) 176 if (commandline[i] == '\0') 177 commandline[i] = ' '; 178 179 commandline[len] = '\0'; 180 } 181 else 182 { 183 /* Return the command in square brackets if the command-line is empty. */ 184 commandline = (char *) xmalloc (32); 185 commandline[0] = '['; 186 command_from_pid (commandline + 1, 31, pid); 187 188 len = strlen (commandline); 189 if (len < 31) 190 strcat (commandline, "]"); 191 } 192 } 193 194 xfree (pathname); 195 196 return commandline; 197 } 198 199 static void 200 user_from_uid (char *user, int maxlen, uid_t uid) 201 { 202 struct passwd *pwentry = getpwuid (uid); 203 204 if (pwentry) 205 { 206 strncpy (user, pwentry->pw_name, maxlen); 207 user[maxlen - 1] = '\0'; /* Ensure that the user name is null-terminated. */ 208 } 209 else 210 user[0] = '\0'; 211 } 212 213 static int 214 get_process_owner (uid_t *owner, pid_t pid) 215 { 216 struct stat statbuf; 217 char procentry[sizeof ("/proc/4294967295")]; 218 219 sprintf (procentry, "/proc/%d", pid); 220 221 if (stat (procentry, &statbuf) == 0 && S_ISDIR (statbuf.st_mode)) 222 { 223 *owner = statbuf.st_uid; 224 return 0; 225 } 226 else 227 return -1; 228 } 229 230 static int 231 get_number_of_cpu_cores (void) 232 { 233 int cores = 0; 234 FILE *f = fopen ("/proc/cpuinfo", "r"); 235 236 while (!feof (f)) 237 { 238 char buf[512]; 239 char *p = fgets (buf, sizeof (buf), f); 240 241 if (p && strncmp (buf, "processor", 9) == 0) 242 ++cores; 243 } 244 245 fclose (f); 246 247 return cores; 248 } 249 250 /* CORES points to an array of at least get_number_of_cpu_cores () elements. */ 251 252 static int 253 get_cores_used_by_process (pid_t pid, int *cores) 254 { 255 char taskdir[sizeof ("/proc/4294967295/task")]; 256 DIR *dir; 257 struct dirent *dp; 258 int task_count = 0; 259 260 sprintf (taskdir, "/proc/%d/task", pid); 261 dir = opendir (taskdir); 262 if (dir) 263 { 264 while ((dp = readdir (dir)) != NULL) 265 { 266 pid_t tid; 267 int core; 268 269 if (!isdigit (dp->d_name[0]) 270 || NAMELEN (dp) > sizeof ("4294967295") - 1) 271 continue; 272 273 tid = atoi (dp->d_name); 274 core = linux_common_core_of_thread (ptid_build (pid, tid, 0)); 275 276 if (core >= 0) 277 { 278 ++cores[core]; 279 ++task_count; 280 } 281 } 282 283 closedir (dir); 284 } 285 286 return task_count; 287 } 288 289 static LONGEST 290 linux_xfer_osdata_processes (gdb_byte *readbuf, 291 ULONGEST offset, LONGEST len) 292 { 293 /* We make the process list snapshot when the object starts to be read. */ 294 static const char *buf; 295 static LONGEST len_avail = -1; 296 static struct buffer buffer; 297 298 if (offset == 0) 299 { 300 DIR *dirp; 301 302 if (len_avail != -1 && len_avail != 0) 303 buffer_free (&buffer); 304 len_avail = 0; 305 buf = NULL; 306 buffer_init (&buffer); 307 buffer_grow_str (&buffer, "<osdata type=\"processes\">\n"); 308 309 dirp = opendir ("/proc"); 310 if (dirp) 311 { 312 const int num_cores = get_number_of_cpu_cores (); 313 struct dirent *dp; 314 315 while ((dp = readdir (dirp)) != NULL) 316 { 317 pid_t pid; 318 uid_t owner; 319 char user[UT_NAMESIZE]; 320 char *command_line; 321 int *cores; 322 int task_count; 323 char *cores_str; 324 int i; 325 326 if (!isdigit (dp->d_name[0]) 327 || NAMELEN (dp) > sizeof ("4294967295") - 1) 328 continue; 329 330 sscanf (dp->d_name, "%d", &pid); 331 command_line = commandline_from_pid (pid); 332 333 if (get_process_owner (&owner, pid) == 0) 334 user_from_uid (user, sizeof (user), owner); 335 else 336 strcpy (user, "?"); 337 338 /* Find CPU cores used by the process. */ 339 cores = (int *) xcalloc (num_cores, sizeof (int)); 340 task_count = get_cores_used_by_process (pid, cores); 341 cores_str = (char *) xcalloc (task_count, sizeof ("4294967295") + 1); 342 343 for (i = 0; i < num_cores && task_count > 0; ++i) 344 if (cores[i]) 345 { 346 char core_str[sizeof ("4294967205")]; 347 348 sprintf (core_str, "%d", i); 349 strcat (cores_str, core_str); 350 351 task_count -= cores[i]; 352 if (task_count > 0) 353 strcat (cores_str, ","); 354 } 355 356 xfree (cores); 357 358 buffer_xml_printf ( 359 &buffer, 360 "<item>" 361 "<column name=\"pid\">%d</column>" 362 "<column name=\"user\">%s</column>" 363 "<column name=\"command\">%s</column>" 364 "<column name=\"cores\">%s</column>" 365 "</item>", 366 pid, 367 user, 368 command_line ? command_line : "", 369 cores_str); 370 371 xfree (command_line); 372 xfree (cores_str); 373 } 374 375 closedir (dirp); 376 } 377 378 buffer_grow_str0 (&buffer, "</osdata>\n"); 379 buf = buffer_finish (&buffer); 380 len_avail = strlen (buf); 381 } 382 383 if (offset >= len_avail) 384 { 385 /* Done. Get rid of the buffer. */ 386 buffer_free (&buffer); 387 buf = NULL; 388 len_avail = 0; 389 return 0; 390 } 391 392 if (len > len_avail - offset) 393 len = len_avail - offset; 394 memcpy (readbuf, buf + offset, len); 395 396 return len; 397 } 398 399 static LONGEST 400 linux_xfer_osdata_threads (gdb_byte *readbuf, 401 ULONGEST offset, LONGEST len) 402 { 403 /* We make the process list snapshot when the object starts to be read. */ 404 static const char *buf; 405 static LONGEST len_avail = -1; 406 static struct buffer buffer; 407 408 if (offset == 0) 409 { 410 DIR *dirp; 411 412 if (len_avail != -1 && len_avail != 0) 413 buffer_free (&buffer); 414 len_avail = 0; 415 buf = NULL; 416 buffer_init (&buffer); 417 buffer_grow_str (&buffer, "<osdata type=\"threads\">\n"); 418 419 dirp = opendir ("/proc"); 420 if (dirp) 421 { 422 struct dirent *dp; 423 424 while ((dp = readdir (dirp)) != NULL) 425 { 426 struct stat statbuf; 427 char procentry[sizeof ("/proc/4294967295")]; 428 429 if (!isdigit (dp->d_name[0]) 430 || NAMELEN (dp) > sizeof ("4294967295") - 1) 431 continue; 432 433 sprintf (procentry, "/proc/%s", dp->d_name); 434 if (stat (procentry, &statbuf) == 0 435 && S_ISDIR (statbuf.st_mode)) 436 { 437 DIR *dirp2; 438 char *pathname; 439 pid_t pid; 440 char command[32]; 441 442 pathname = xstrprintf ("/proc/%s/task", dp->d_name); 443 444 pid = atoi (dp->d_name); 445 command_from_pid (command, sizeof (command), pid); 446 447 dirp2 = opendir (pathname); 448 449 if (dirp2) 450 { 451 struct dirent *dp2; 452 453 while ((dp2 = readdir (dirp2)) != NULL) 454 { 455 pid_t tid; 456 int core; 457 458 if (!isdigit (dp2->d_name[0]) 459 || NAMELEN (dp2) > sizeof ("4294967295") - 1) 460 continue; 461 462 tid = atoi (dp2->d_name); 463 core = linux_common_core_of_thread (ptid_build (pid, tid, 0)); 464 465 buffer_xml_printf ( 466 &buffer, 467 "<item>" 468 "<column name=\"pid\">%d</column>" 469 "<column name=\"command\">%s</column>" 470 "<column name=\"tid\">%d</column>" 471 "<column name=\"core\">%d</column>" 472 "</item>", 473 pid, 474 command, 475 tid, 476 core); 477 } 478 479 closedir (dirp2); 480 } 481 482 xfree (pathname); 483 } 484 } 485 486 closedir (dirp); 487 } 488 489 buffer_grow_str0 (&buffer, "</osdata>\n"); 490 buf = buffer_finish (&buffer); 491 len_avail = strlen (buf); 492 } 493 494 if (offset >= len_avail) 495 { 496 /* Done. Get rid of the buffer. */ 497 buffer_free (&buffer); 498 buf = NULL; 499 len_avail = 0; 500 return 0; 501 } 502 503 if (len > len_avail - offset) 504 len = len_avail - offset; 505 memcpy (readbuf, buf + offset, len); 506 507 return len; 508 } 509 510 struct osdata_type { 511 char *type; 512 char *description; 513 LONGEST (*getter) (gdb_byte *readbuf, ULONGEST offset, LONGEST len); 514 } osdata_table[] = { 515 { "processes", "Listing of all processes", linux_xfer_osdata_processes }, 516 { "threads", "Listing of all threads", linux_xfer_osdata_threads }, 517 { NULL, NULL, NULL } 518 }; 519 520 LONGEST 521 linux_common_xfer_osdata (const char *annex, gdb_byte *readbuf, 522 ULONGEST offset, LONGEST len) 523 { 524 if (!annex || *annex == '\0') 525 { 526 static const char *buf; 527 static LONGEST len_avail = -1; 528 static struct buffer buffer; 529 530 if (offset == 0) 531 { 532 int i; 533 534 if (len_avail != -1 && len_avail != 0) 535 buffer_free (&buffer); 536 len_avail = 0; 537 buf = NULL; 538 buffer_init (&buffer); 539 buffer_grow_str (&buffer, "<osdata type=\"types\">\n"); 540 541 for (i = 0; osdata_table[i].type; ++i) 542 buffer_xml_printf ( 543 &buffer, 544 "<item>" 545 "<column name=\"Type\">%s</column>" 546 "<column name=\"Description\">%s</column>" 547 "</item>", 548 osdata_table[i].type, 549 osdata_table[i].description); 550 551 buffer_grow_str0 (&buffer, "</osdata>\n"); 552 buf = buffer_finish (&buffer); 553 len_avail = strlen (buf); 554 } 555 556 if (offset >= len_avail) 557 { 558 /* Done. Get rid of the buffer. */ 559 buffer_free (&buffer); 560 buf = NULL; 561 len_avail = 0; 562 return 0; 563 } 564 565 if (len > len_avail - offset) 566 len = len_avail - offset; 567 memcpy (readbuf, buf + offset, len); 568 569 return len; 570 } 571 else 572 { 573 int i; 574 575 for (i = 0; osdata_table[i].type; ++i) 576 { 577 if (strcmp (annex, osdata_table[i].type) == 0) 578 { 579 gdb_assert (readbuf); 580 581 return (osdata_table[i].getter) (readbuf, offset, len); 582 } 583 } 584 585 return 0; 586 } 587 } 588 589