proc.c revision 0475ac36f22c9531cd0e0ba7d02cee5a1c5c67ea
1/* 2 * This file is part of ltrace. 3 * Copyright (C) 2011,2012 Petr Machata, Red Hat Inc. 4 * Copyright (C) 2010 Zachary T Welch, CodeSourcery 5 * Copyright (C) 2010 Joe Damato 6 * Copyright (C) 1998,2008,2009 Juan Cespedes 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License as 10 * published by the Free Software Foundation; either version 2 of the 11 * License, or (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 21 * 02110-1301 USA 22 */ 23 24#define _GNU_SOURCE /* For getline. */ 25#include "config.h" 26 27#include <sys/stat.h> 28#include <sys/syscall.h> 29#include <sys/types.h> 30#include <ctype.h> 31#include <dirent.h> 32#include <errno.h> 33#include <fcntl.h> 34#include <inttypes.h> 35#include <link.h> 36#include <signal.h> 37#include <stdio.h> 38#include <stdlib.h> 39#include <string.h> 40#include <unistd.h> 41 42#include "backend.h" 43#include "breakpoint.h" 44#include "config.h" 45#include "debug.h" 46#include "events.h" 47#include "library.h" 48#include "ltrace-elf.h" 49#include "proc.h" 50 51/* /proc/pid doesn't exist just after the fork, and sometimes `ltrace' 52 * couldn't open it to find the executable. So it may be necessary to 53 * have a bit delay 54 */ 55 56#define MAX_DELAY 100000 /* 100000 microseconds = 0.1 seconds */ 57 58#define PROC_PID_FILE(VAR, FORMAT, PID) \ 59 char VAR[strlen(FORMAT) + 6]; \ 60 sprintf(VAR, FORMAT, PID) 61 62/* 63 * Returns a (malloc'd) file name corresponding to a running pid 64 */ 65char * 66pid2name(pid_t pid) { 67 if (!kill(pid, 0)) { 68 int delay = 0; 69 70 PROC_PID_FILE(proc_exe, "/proc/%d/exe", pid); 71 72 while (delay < MAX_DELAY) { 73 if (!access(proc_exe, F_OK)) { 74 return strdup(proc_exe); 75 } 76 delay += 1000; /* 1 milisecond */ 77 } 78 } 79 return NULL; 80} 81 82static FILE * 83open_status_file(pid_t pid) 84{ 85 PROC_PID_FILE(fn, "/proc/%d/status", pid); 86 /* Don't complain if we fail. This would typically happen 87 when the process is about to terminate, and these files are 88 not available anymore. This function is called from the 89 event loop, and we don't want to clutter the output just 90 because the process terminates. */ 91 return fopen(fn, "r"); 92} 93 94static char * 95find_line_starting(FILE * file, const char * prefix, size_t len) 96{ 97 char * line = NULL; 98 size_t line_len = 0; 99 while (!feof(file)) { 100 if (getline(&line, &line_len, file) < 0) 101 return NULL; 102 if (strncmp(line, prefix, len) == 0) 103 return line; 104 } 105 return NULL; 106} 107 108static void 109each_line_starting(FILE *file, const char *prefix, 110 enum callback_status (*cb)(const char *line, 111 const char *prefix, 112 void *data), 113 void *data) 114{ 115 size_t len = strlen(prefix); 116 char * line; 117 while ((line = find_line_starting(file, prefix, len)) != NULL) { 118 enum callback_status st = (*cb)(line, prefix, data); 119 free(line); 120 if (st == CBS_STOP) 121 return; 122 } 123} 124 125static enum callback_status 126process_leader_cb(const char *line, const char *prefix, void *data) 127{ 128 pid_t * pidp = data; 129 *pidp = atoi(line + strlen(prefix)); 130 return CBS_STOP; 131} 132 133pid_t 134process_leader(pid_t pid) 135{ 136 pid_t tgid = 0; 137 FILE * file = open_status_file(pid); 138 if (file != NULL) { 139 each_line_starting(file, "Tgid:\t", &process_leader_cb, &tgid); 140 fclose(file); 141 } 142 143 return tgid; 144} 145 146static enum callback_status 147process_stopped_cb(const char *line, const char *prefix, void *data) 148{ 149 char c = line[strlen(prefix)]; 150 // t:tracing stop, T:job control stop 151 *(int *)data = (c == 't' || c == 'T'); 152 return CBS_STOP; 153} 154 155int 156process_stopped(pid_t pid) 157{ 158 int is_stopped = -1; 159 FILE * file = open_status_file(pid); 160 if (file != NULL) { 161 each_line_starting(file, "State:\t", &process_stopped_cb, 162 &is_stopped); 163 fclose(file); 164 } 165 return is_stopped; 166} 167 168static enum callback_status 169process_status_cb(const char *line, const char *prefix, void *data) 170{ 171 const char * status = line + strlen(prefix); 172 const char c = *status; 173 174#define RETURN(C) do { \ 175 *(enum process_status *)data = C; \ 176 return CBS_STOP; \ 177 } while (0) 178 179 switch (c) { 180 case 'Z': RETURN(ps_zombie); 181 case 't': RETURN(ps_tracing_stop); 182 case 'T': 183 /* This can be either "T (stopped)" or, for older 184 * kernels, "T (tracing stop)". */ 185 if (!strcmp(status, "T (stopped)\n")) 186 RETURN(ps_stop); 187 else if (!strcmp(status, "T (tracing stop)\n")) 188 RETURN(ps_tracing_stop); 189 else { 190 fprintf(stderr, "Unknown process status: %s", 191 status); 192 RETURN(ps_stop); /* Some sort of stop 193 * anyway. */ 194 } 195 case 'D': 196 case 'S': RETURN(ps_sleeping); 197 } 198 199 RETURN(ps_other); 200#undef RETURN 201} 202 203enum process_status 204process_status(pid_t pid) 205{ 206 enum process_status ret = ps_invalid; 207 FILE * file = open_status_file(pid); 208 if (file != NULL) { 209 each_line_starting(file, "State:\t", &process_status_cb, &ret); 210 fclose(file); 211 if (ret == ps_invalid) 212 fprintf(stderr, "process_status %d: %s", pid, 213 strerror(errno)); 214 } else 215 /* If the file is not present, the process presumably 216 * exited already. */ 217 ret = ps_zombie; 218 219 return ret; 220} 221 222static int 223all_digits(const char *str) 224{ 225 while (isdigit(*str)) 226 str++; 227 return !*str; 228} 229 230int 231process_tasks(pid_t pid, pid_t **ret_tasks, size_t *ret_n) 232{ 233 PROC_PID_FILE(fn, "/proc/%d/task", pid); 234 DIR * d = opendir(fn); 235 if (d == NULL) 236 return -1; 237 238 pid_t *tasks = NULL; 239 size_t n = 0; 240 size_t alloc = 0; 241 242 while (1) { 243 struct dirent entry; 244 struct dirent *result; 245 if (readdir_r(d, &entry, &result) != 0) { 246 free(tasks); 247 return -1; 248 } 249 if (result == NULL) 250 break; 251 if (result->d_type == DT_DIR && all_digits(result->d_name)) { 252 pid_t npid = atoi(result->d_name); 253 if (n >= alloc) { 254 alloc = alloc > 0 ? (2 * alloc) : 8; 255 pid_t *ntasks = realloc(tasks, 256 sizeof(*tasks) * alloc); 257 if (ntasks == NULL) { 258 free(tasks); 259 return -1; 260 } 261 tasks = ntasks; 262 } 263 if (n >= alloc) 264 abort(); 265 tasks[n++] = npid; 266 } 267 } 268 269 closedir(d); 270 271 *ret_tasks = tasks; 272 *ret_n = n; 273 return 0; 274} 275 276/* On native 64-bit system, we need to be careful when handling cross 277 * tracing. This select appropriate pointer depending on host and 278 * target architectures. XXX Really we should abstract this into the 279 * ABI object, as theorized about somewhere on pmachata/revamp 280 * branch. */ 281static void * 282select_32_64(struct Process *proc, void *p32, void *p64) 283{ 284 if (sizeof(long) == 4 || proc->mask_32bit) 285 return p32; 286 else 287 return p64; 288} 289 290static int 291fetch_dyn64(struct Process *proc, arch_addr_t *addr, Elf64_Dyn *ret) 292{ 293 if (umovebytes(proc, *addr, ret, sizeof(*ret)) != sizeof(*ret)) 294 return -1; 295 *addr += sizeof(*ret); 296 return 0; 297} 298 299static int 300fetch_dyn32(struct Process *proc, arch_addr_t *addr, Elf64_Dyn *ret) 301{ 302 Elf32_Dyn dyn; 303 if (umovebytes(proc, *addr, &dyn, sizeof(dyn)) != sizeof(dyn)) 304 return -1; 305 306 *addr += sizeof(dyn); 307 ret->d_tag = dyn.d_tag; 308 ret->d_un.d_val = dyn.d_un.d_val; 309 310 return 0; 311} 312 313static int (* 314dyn_fetcher(struct Process *proc))(struct Process *, 315 arch_addr_t *, Elf64_Dyn *) 316{ 317 return select_32_64(proc, fetch_dyn32, fetch_dyn64); 318} 319 320int 321proc_find_dynamic_entry_addr(struct Process *proc, arch_addr_t src_addr, 322 int d_tag, arch_addr_t *ret) 323{ 324 debug(DEBUG_FUNCTION, "find_dynamic_entry()"); 325 326 if (ret == NULL || src_addr == 0 || d_tag < 0) 327 return -1; 328 329 int i = 0; 330 while (1) { 331 Elf64_Dyn entry; 332 if (dyn_fetcher(proc)(proc, &src_addr, &entry) < 0 333 || entry.d_tag == DT_NULL 334 || i++ > 100) { /* Arbitrary cut-off so that we 335 * don't loop forever if the 336 * binary is corrupted. */ 337 debug(2, "Couldn't find address for dtag!"); 338 return -1; 339 } 340 341 if (entry.d_tag == d_tag) { 342 /* XXX The double cast should be removed when 343 * arch_addr_t becomes integral type. */ 344 *ret = (arch_addr_t)(uintptr_t)entry.d_un.d_val; 345 debug(2, "found address: %p in dtag %d", *ret, d_tag); 346 return 0; 347 } 348 } 349} 350 351/* Our own type for representing 32-bit linkmap. We can't rely on the 352 * definition in link.h, because that's only accurate for our host 353 * architecture, not for target architecture (where the traced process 354 * runs). */ 355#define LT_LINK_MAP(BITS) \ 356 { \ 357 Elf##BITS##_Addr l_addr; \ 358 Elf##BITS##_Addr l_name; \ 359 Elf##BITS##_Addr l_ld; \ 360 Elf##BITS##_Addr l_next; \ 361 Elf##BITS##_Addr l_prev; \ 362 } 363struct lt_link_map_32 LT_LINK_MAP(32); 364struct lt_link_map_64 LT_LINK_MAP(64); 365 366static int 367fetch_lm64(struct Process *proc, arch_addr_t addr, 368 struct lt_link_map_64 *ret) 369{ 370 if (umovebytes(proc, addr, ret, sizeof(*ret)) != sizeof(*ret)) 371 return -1; 372 return 0; 373} 374 375static int 376fetch_lm32(struct Process *proc, arch_addr_t addr, 377 struct lt_link_map_64 *ret) 378{ 379 struct lt_link_map_32 lm; 380 if (umovebytes(proc, addr, &lm, sizeof(lm)) != sizeof(lm)) 381 return -1; 382 383 ret->l_addr = lm.l_addr; 384 ret->l_name = lm.l_name; 385 ret->l_ld = lm.l_ld; 386 ret->l_next = lm.l_next; 387 ret->l_prev = lm.l_prev; 388 389 return 0; 390} 391 392static int (* 393lm_fetcher(struct Process *proc))(struct Process *, 394 arch_addr_t, struct lt_link_map_64 *) 395{ 396 return select_32_64(proc, fetch_lm32, fetch_lm64); 397} 398 399/* The same as above holds for struct r_debug. */ 400#define LT_R_DEBUG(BITS) \ 401 { \ 402 int r_version; \ 403 Elf##BITS##_Addr r_map; \ 404 Elf##BITS##_Addr r_brk; \ 405 int r_state; \ 406 Elf##BITS##_Addr r_ldbase; \ 407 } 408 409struct lt_r_debug_32 LT_R_DEBUG(32); 410struct lt_r_debug_64 LT_R_DEBUG(64); 411 412static int 413fetch_rd64(struct Process *proc, arch_addr_t addr, 414 struct lt_r_debug_64 *ret) 415{ 416 if (umovebytes(proc, addr, ret, sizeof(*ret)) != sizeof(*ret)) 417 return -1; 418 return 0; 419} 420 421static int 422fetch_rd32(struct Process *proc, arch_addr_t addr, 423 struct lt_r_debug_64 *ret) 424{ 425 struct lt_r_debug_32 rd; 426 if (umovebytes(proc, addr, &rd, sizeof(rd)) != sizeof(rd)) 427 return -1; 428 429 ret->r_version = rd.r_version; 430 ret->r_map = rd.r_map; 431 ret->r_brk = rd.r_brk; 432 ret->r_state = rd.r_state; 433 ret->r_ldbase = rd.r_ldbase; 434 435 return 0; 436} 437 438static int (* 439rdebug_fetcher(struct Process *proc))(struct Process *, 440 arch_addr_t, struct lt_r_debug_64 *) 441{ 442 return select_32_64(proc, fetch_rd32, fetch_rd64); 443} 444 445static int 446fetch_auxv64_entry(int fd, Elf64_auxv_t *ret) 447{ 448 /* Reaching EOF is as much problem as not reading whole 449 * entry. */ 450 return read(fd, ret, sizeof(*ret)) == sizeof(*ret) ? 0 : -1; 451} 452 453static int 454fetch_auxv32_entry(int fd, Elf64_auxv_t *ret) 455{ 456 Elf32_auxv_t auxv; 457 if (read(fd, &auxv, sizeof(auxv)) != sizeof(auxv)) 458 return -1; 459 460 ret->a_type = auxv.a_type; 461 ret->a_un.a_val = auxv.a_un.a_val; 462 return 0; 463} 464 465static int (* 466auxv_fetcher(struct Process *proc))(int, Elf64_auxv_t *) 467{ 468 return select_32_64(proc, fetch_auxv32_entry, fetch_auxv64_entry); 469} 470 471static void 472crawl_linkmap(struct Process *proc, struct lt_r_debug_64 *dbg) 473{ 474 debug (DEBUG_FUNCTION, "crawl_linkmap()"); 475 476 if (!dbg || !dbg->r_map) { 477 debug(2, "Debug structure or it's linkmap are NULL!"); 478 return; 479 } 480 481 /* XXX The double cast should be removed when 482 * arch_addr_t becomes integral type. */ 483 arch_addr_t addr = (arch_addr_t)(uintptr_t)dbg->r_map; 484 485 while (addr != 0) { 486 struct lt_link_map_64 rlm; 487 if (lm_fetcher(proc)(proc, addr, &rlm) < 0) { 488 debug(2, "Unable to read link map"); 489 return; 490 } 491 492 arch_addr_t key = addr; 493 /* XXX The double cast should be removed when 494 * arch_addr_t becomes integral type. */ 495 addr = (arch_addr_t)(uintptr_t)rlm.l_next; 496 if (rlm.l_name == 0) { 497 debug(2, "Name of mapped library is NULL"); 498 return; 499 } 500 501 char lib_name[BUFSIZ]; 502 /* XXX The double cast should be removed when 503 * arch_addr_t becomes integral type. */ 504 umovebytes(proc, (arch_addr_t)(uintptr_t)rlm.l_name, 505 lib_name, sizeof(lib_name)); 506 507 if (*lib_name == '\0') { 508 /* VDSO. No associated file, XXX but we might 509 * load it from the address space of the 510 * process. */ 511 continue; 512 } 513 514 /* Do we have that library already? */ 515 if (proc_each_library(proc, NULL, library_with_key_cb, &key)) 516 continue; 517 518 struct library *lib = malloc(sizeof(*lib)); 519 if (lib == NULL) { 520 fail: 521 if (lib != NULL) 522 library_destroy(lib); 523 fprintf(stderr, "Couldn't load ELF object %s: %s\n", 524 lib_name, strerror(errno)); 525 continue; 526 } 527 library_init(lib, LT_LIBTYPE_DSO); 528 529 if (ltelf_read_library(lib, proc, lib_name, rlm.l_addr) < 0) 530 goto fail; 531 532 lib->key = key; 533 proc_add_library(proc, lib); 534 } 535 return; 536} 537 538/* A struct stored at proc->debug. */ 539struct debug_struct 540{ 541 arch_addr_t debug_addr; 542 int state; 543}; 544 545static int 546load_debug_struct(struct Process *proc, struct lt_r_debug_64 *ret) 547{ 548 debug(DEBUG_FUNCTION, "load_debug_struct"); 549 550 struct debug_struct *debug = proc->debug; 551 552 if (rdebug_fetcher(proc)(proc, debug->debug_addr, ret) < 0) { 553 debug(2, "This process does not have a debug structure!\n"); 554 return -1; 555 } 556 557 return 0; 558} 559 560static void 561rdebug_bp_on_hit(struct breakpoint *bp, struct Process *proc) 562{ 563 debug(DEBUG_FUNCTION, "arch_check_dbg"); 564 565 struct lt_r_debug_64 rdbg; 566 if (load_debug_struct(proc, &rdbg) < 0) { 567 debug(2, "Unable to load debug structure!"); 568 return; 569 } 570 571 struct debug_struct *debug = proc->debug; 572 if (rdbg.r_state == RT_CONSISTENT) { 573 debug(2, "Linkmap is now consistent"); 574 if (debug->state == RT_ADD) { 575 debug(2, "Adding DSO to linkmap"); 576 //data.proc = proc; 577 crawl_linkmap(proc, &rdbg); 578 //&data); 579 } else if (debug->state == RT_DELETE) { 580 debug(2, "Removing DSO from linkmap"); 581 } else { 582 debug(2, "Unexpected debug state!"); 583 } 584 } 585 586 debug->state = rdbg.r_state; 587} 588 589#ifndef ARCH_HAVE_FIND_DL_DEBUG 590int 591arch_find_dl_debug(struct Process *proc, arch_addr_t dyn_addr, 592 arch_addr_t *ret) 593{ 594 return proc_find_dynamic_entry_addr(proc, dyn_addr, DT_DEBUG, ret); 595} 596#endif 597 598int 599linkmap_init(struct Process *proc, arch_addr_t dyn_addr) 600{ 601 debug(DEBUG_FUNCTION, "linkmap_init()"); 602 603 struct debug_struct *debug = malloc(sizeof(*debug)); 604 if (debug == NULL) { 605 fprintf(stderr, "couldn't allocate debug struct: %s\n", 606 strerror(errno)); 607 fail: 608 proc->debug = NULL; 609 free(debug); 610 return -1; 611 } 612 proc->debug = debug; 613 614 if (arch_find_dl_debug(proc, dyn_addr, &debug->debug_addr) == -1) { 615 debug(2, "Couldn't find debug structure!"); 616 goto fail; 617 } 618 619 int status; 620 struct lt_r_debug_64 rdbg; 621 if ((status = load_debug_struct(proc, &rdbg)) < 0) { 622 debug(2, "No debug structure or no memory to allocate one!"); 623 return status; 624 } 625 626 /* XXX The double cast should be removed when 627 * arch_addr_t becomes integral type. */ 628 arch_addr_t addr = (arch_addr_t)(uintptr_t)rdbg.r_brk; 629 if (arch_translate_address_dyn(proc, addr, &addr) < 0) 630 goto fail; 631 632 struct breakpoint *rdebug_bp = insert_breakpoint(proc, addr, NULL); 633 static struct bp_callbacks rdebug_callbacks = { 634 .on_hit = rdebug_bp_on_hit, 635 }; 636 rdebug_bp->cbs = &rdebug_callbacks; 637 638 crawl_linkmap(proc, &rdbg); 639 640 return 0; 641} 642 643int 644task_kill (pid_t pid, int sig) 645{ 646 // Taken from GDB 647 int ret; 648 649 errno = 0; 650 ret = syscall (__NR_tkill, pid, sig); 651 return ret; 652} 653 654void 655process_removed(struct Process *proc) 656{ 657 delete_events_for(proc); 658} 659 660int 661process_get_entry(struct Process *proc, 662 arch_addr_t *entryp, 663 arch_addr_t *interp_biasp) 664{ 665 PROC_PID_FILE(fn, "/proc/%d/auxv", proc->pid); 666 int fd = open(fn, O_RDONLY); 667 if (fd == -1) { 668 fail: 669 fprintf(stderr, "couldn't read %s: %s", fn, strerror(errno)); 670 done: 671 if (fd != -1) 672 close(fd); 673 return fd == -1 ? -1 : 0; 674 } 675 676 arch_addr_t at_entry = 0; 677 arch_addr_t at_bias = 0; 678 while (1) { 679 Elf64_auxv_t entry; 680 if (auxv_fetcher(proc)(fd, &entry) < 0) 681 goto fail; 682 683 switch (entry.a_type) { 684 case AT_BASE: 685 /* XXX The double cast should be removed when 686 * arch_addr_t becomes integral type. */ 687 at_bias = (arch_addr_t)(uintptr_t)entry.a_un.a_val; 688 continue; 689 690 case AT_ENTRY: 691 /* XXX The double cast should be removed when 692 * arch_addr_t becomes integral type. */ 693 at_entry = (arch_addr_t)(uintptr_t)entry.a_un.a_val; 694 default: 695 continue; 696 697 case AT_NULL: 698 break; 699 } 700 break; 701 } 702 703 if (entryp != NULL) 704 *entryp = at_entry; 705 if (interp_biasp != NULL) 706 *interp_biasp = at_bias; 707 goto done; 708} 709