1 /* Machine independent support for Solaris /proc (process file system) for GDB. 2 3 Copyright (C) 1999-2020 Free Software Foundation, Inc. 4 5 Written by Michael Snyder at Cygnus Solutions. 6 Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others. 7 8 This file is part of GDB. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 22 23 #include "defs.h" 24 #include "inferior.h" 25 #include "infrun.h" 26 #include "target.h" 27 #include "gdbcore.h" 28 #include "elf-bfd.h" /* for elfcore_write_* */ 29 #include "gdbcmd.h" 30 #include "gdbthread.h" 31 #include "regcache.h" 32 #include "inf-child.h" 33 #include "nat/fork-inferior.h" 34 #include "gdbarch.h" 35 36 #include <sys/procfs.h> 37 #include <sys/fault.h> 38 #include <sys/syscall.h> 39 #include "gdbsupport/gdb_wait.h" 40 #include <signal.h> 41 #include <ctype.h> 42 #include "gdb_bfd.h" 43 #include "inflow.h" 44 #include "auxv.h" 45 #include "procfs.h" 46 #include "observable.h" 47 #include "gdbsupport/scoped_fd.h" 48 #include "gdbsupport/pathstuff.h" 49 50 /* This module provides the interface between GDB and the 51 /proc file system, which is used on many versions of Unix 52 as a means for debuggers to control other processes. 53 54 /proc works by imitating a file system: you open a simulated file 55 that represents the process you wish to interact with, and perform 56 operations on that "file" in order to examine or change the state 57 of the other process. 58 59 The most important thing to know about /proc and this module is 60 that there are two very different interfaces to /proc: 61 62 One that uses the ioctl system call, and another that uses read 63 and write system calls. 64 65 This module supports only the Solaris version of the read/write 66 interface. */ 67 68 #include <sys/types.h> 69 #include <dirent.h> /* opendir/readdir, for listing the LWP's */ 70 71 #include <fcntl.h> /* for O_RDONLY */ 72 #include <unistd.h> /* for "X_OK" */ 73 #include <sys/stat.h> /* for struct stat */ 74 75 /* Note: procfs-utils.h must be included after the above system header 76 files, because it redefines various system calls using macros. 77 This may be incompatible with the prototype declarations. */ 78 79 #include "proc-utils.h" 80 81 /* Prototypes for supply_gregset etc. */ 82 #include "gregset.h" 83 84 /* =================== TARGET_OPS "MODULE" =================== */ 85 86 /* This module defines the GDB target vector and its methods. */ 87 88 89 static enum target_xfer_status procfs_xfer_memory (gdb_byte *, 90 const gdb_byte *, 91 ULONGEST, ULONGEST, 92 ULONGEST *); 93 94 class procfs_target final : public inf_child_target 95 { 96 public: 97 void create_inferior (const char *, const std::string &, 98 char **, int) override; 99 100 void kill () override; 101 102 void mourn_inferior () override; 103 104 void attach (const char *, int) override; 105 void detach (inferior *inf, int) override; 106 107 void resume (ptid_t, int, enum gdb_signal) override; 108 ptid_t wait (ptid_t, struct target_waitstatus *, int) override; 109 110 void fetch_registers (struct regcache *, int) override; 111 void store_registers (struct regcache *, int) override; 112 113 enum target_xfer_status xfer_partial (enum target_object object, 114 const char *annex, 115 gdb_byte *readbuf, 116 const gdb_byte *writebuf, 117 ULONGEST offset, ULONGEST len, 118 ULONGEST *xfered_len) override; 119 120 void pass_signals (gdb::array_view<const unsigned char>) override; 121 122 void files_info () override; 123 124 void update_thread_list () override; 125 126 bool thread_alive (ptid_t ptid) override; 127 128 std::string pid_to_str (ptid_t) override; 129 130 char *pid_to_exec_file (int pid) override; 131 132 thread_control_capabilities get_thread_control_capabilities () override 133 { return tc_schedlock; } 134 135 /* find_memory_regions support method for gcore */ 136 int find_memory_regions (find_memory_region_ftype func, void *data) 137 override; 138 139 char *make_corefile_notes (bfd *, int *) override; 140 141 bool info_proc (const char *, enum info_proc_what) override; 142 143 #if PR_MODEL_NATIVE == PR_MODEL_LP64 144 int auxv_parse (gdb_byte **readptr, 145 gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) 146 override; 147 #endif 148 149 bool stopped_by_watchpoint () override; 150 151 int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type, 152 struct expression *) override; 153 154 int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type, 155 struct expression *) override; 156 157 int region_ok_for_hw_watchpoint (CORE_ADDR, int) override; 158 159 int can_use_hw_breakpoint (enum bptype, int, int) override; 160 bool stopped_data_address (CORE_ADDR *) override; 161 162 void procfs_init_inferior (int pid); 163 }; 164 165 static procfs_target the_procfs_target; 166 167 #if PR_MODEL_NATIVE == PR_MODEL_LP64 168 /* When GDB is built as 64-bit application on Solaris, the auxv data 169 is presented in 64-bit format. We need to provide a custom parser 170 to handle that. */ 171 int 172 procfs_target::auxv_parse (gdb_byte **readptr, 173 gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) 174 { 175 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); 176 gdb_byte *ptr = *readptr; 177 178 if (endptr == ptr) 179 return 0; 180 181 if (endptr - ptr < 8 * 2) 182 return -1; 183 184 *typep = extract_unsigned_integer (ptr, 4, byte_order); 185 ptr += 8; 186 /* The size of data is always 64-bit. If the application is 32-bit, 187 it will be zero extended, as expected. */ 188 *valp = extract_unsigned_integer (ptr, 8, byte_order); 189 ptr += 8; 190 191 *readptr = ptr; 192 return 1; 193 } 194 #endif 195 196 /* =================== END, TARGET_OPS "MODULE" =================== */ 197 198 /* =================== STRUCT PROCINFO "MODULE" =================== */ 199 200 /* FIXME: this comment will soon be out of date W.R.T. threads. */ 201 202 /* The procinfo struct is a wrapper to hold all the state information 203 concerning a /proc process. There should be exactly one procinfo 204 for each process, and since GDB currently can debug only one 205 process at a time, that means there should be only one procinfo. 206 All of the LWP's of a process can be accessed indirectly thru the 207 single process procinfo. 208 209 However, against the day when GDB may debug more than one process, 210 this data structure is kept in a list (which for now will hold no 211 more than one member), and many functions will have a pointer to a 212 procinfo as an argument. 213 214 There will be a separate procinfo structure for use by the (not yet 215 implemented) "info proc" command, so that we can print useful 216 information about any random process without interfering with the 217 inferior's procinfo information. */ 218 219 /* format strings for /proc paths */ 220 #define CTL_PROC_NAME_FMT "/proc/%d/ctl" 221 #define AS_PROC_NAME_FMT "/proc/%d/as" 222 #define MAP_PROC_NAME_FMT "/proc/%d/map" 223 #define STATUS_PROC_NAME_FMT "/proc/%d/status" 224 #define MAX_PROC_NAME_SIZE sizeof("/proc/999999/lwp/0123456789/lwpstatus") 225 226 typedef struct procinfo { 227 struct procinfo *next; 228 int pid; /* Process ID */ 229 int tid; /* Thread/LWP id */ 230 231 /* process state */ 232 int was_stopped; 233 int ignore_next_sigstop; 234 235 int ctl_fd; /* File descriptor for /proc control file */ 236 int status_fd; /* File descriptor for /proc status file */ 237 int as_fd; /* File descriptor for /proc as file */ 238 239 char pathname[MAX_PROC_NAME_SIZE]; /* Pathname to /proc entry */ 240 241 fltset_t saved_fltset; /* Saved traced hardware fault set */ 242 sigset_t saved_sigset; /* Saved traced signal set */ 243 sigset_t saved_sighold; /* Saved held signal set */ 244 sysset_t *saved_exitset; /* Saved traced system call exit set */ 245 sysset_t *saved_entryset; /* Saved traced system call entry set */ 246 247 pstatus_t prstatus; /* Current process status info */ 248 249 struct procinfo *thread_list; 250 251 int status_valid : 1; 252 int gregs_valid : 1; 253 int fpregs_valid : 1; 254 int threads_valid: 1; 255 } procinfo; 256 257 static char errmsg[128]; /* shared error msg buffer */ 258 259 /* Function prototypes for procinfo module: */ 260 261 static procinfo *find_procinfo_or_die (int pid, int tid); 262 static procinfo *find_procinfo (int pid, int tid); 263 static procinfo *create_procinfo (int pid, int tid); 264 static void destroy_procinfo (procinfo *p); 265 static void dead_procinfo (procinfo *p, const char *msg, int killp); 266 static int open_procinfo_files (procinfo *p, int which); 267 static void close_procinfo_files (procinfo *p); 268 269 static int iterate_over_mappings 270 (procinfo *pi, find_memory_region_ftype child_func, void *data, 271 int (*func) (struct prmap *map, find_memory_region_ftype child_func, 272 void *data)); 273 274 /* The head of the procinfo list: */ 275 static procinfo *procinfo_list; 276 277 /* Search the procinfo list. Return a pointer to procinfo, or NULL if 278 not found. */ 279 280 static procinfo * 281 find_procinfo (int pid, int tid) 282 { 283 procinfo *pi; 284 285 for (pi = procinfo_list; pi; pi = pi->next) 286 if (pi->pid == pid) 287 break; 288 289 if (pi) 290 if (tid) 291 { 292 /* Don't check threads_valid. If we're updating the 293 thread_list, we want to find whatever threads are already 294 here. This means that in general it is the caller's 295 responsibility to check threads_valid and update before 296 calling find_procinfo, if the caller wants to find a new 297 thread. */ 298 299 for (pi = pi->thread_list; pi; pi = pi->next) 300 if (pi->tid == tid) 301 break; 302 } 303 304 return pi; 305 } 306 307 /* Calls find_procinfo, but errors on failure. */ 308 309 static procinfo * 310 find_procinfo_or_die (int pid, int tid) 311 { 312 procinfo *pi = find_procinfo (pid, tid); 313 314 if (pi == NULL) 315 { 316 if (tid) 317 error (_("procfs: couldn't find pid %d " 318 "(kernel thread %d) in procinfo list."), 319 pid, tid); 320 else 321 error (_("procfs: couldn't find pid %d in procinfo list."), pid); 322 } 323 return pi; 324 } 325 326 /* Wrapper for `open'. The appropriate open call is attempted; if 327 unsuccessful, it will be retried as many times as needed for the 328 EAGAIN and EINTR conditions. 329 330 For other conditions, retry the open a limited number of times. In 331 addition, a short sleep is imposed prior to retrying the open. The 332 reason for this sleep is to give the kernel a chance to catch up 333 and create the file in question in the event that GDB "wins" the 334 race to open a file before the kernel has created it. */ 335 336 static int 337 open_with_retry (const char *pathname, int flags) 338 { 339 int retries_remaining, status; 340 341 retries_remaining = 2; 342 343 while (1) 344 { 345 status = open (pathname, flags); 346 347 if (status >= 0 || retries_remaining == 0) 348 break; 349 else if (errno != EINTR && errno != EAGAIN) 350 { 351 retries_remaining--; 352 sleep (1); 353 } 354 } 355 356 return status; 357 } 358 359 /* Open the file descriptor for the process or LWP. We only open the 360 control file descriptor; the others are opened lazily as needed. 361 Returns the file descriptor, or zero for failure. */ 362 363 enum { FD_CTL, FD_STATUS, FD_AS }; 364 365 static int 366 open_procinfo_files (procinfo *pi, int which) 367 { 368 char tmp[MAX_PROC_NAME_SIZE]; 369 int fd; 370 371 /* This function is getting ALMOST long enough to break up into 372 several. Here is some rationale: 373 374 There are several file descriptors that may need to be open 375 for any given process or LWP. The ones we're interested in are: 376 - control (ctl) write-only change the state 377 - status (status) read-only query the state 378 - address space (as) read/write access memory 379 - map (map) read-only virtual addr map 380 Most of these are opened lazily as they are needed. 381 The pathnames for the 'files' for an LWP look slightly 382 different from those of a first-class process: 383 Pathnames for a process (<proc-id>): 384 /proc/<proc-id>/ctl 385 /proc/<proc-id>/status 386 /proc/<proc-id>/as 387 /proc/<proc-id>/map 388 Pathnames for an LWP (lwp-id): 389 /proc/<proc-id>/lwp/<lwp-id>/lwpctl 390 /proc/<proc-id>/lwp/<lwp-id>/lwpstatus 391 An LWP has no map or address space file descriptor, since 392 the memory map and address space are shared by all LWPs. */ 393 394 /* In this case, there are several different file descriptors that 395 we might be asked to open. The control file descriptor will be 396 opened early, but the others will be opened lazily as they are 397 needed. */ 398 399 strcpy (tmp, pi->pathname); 400 switch (which) { /* Which file descriptor to open? */ 401 case FD_CTL: 402 if (pi->tid) 403 strcat (tmp, "/lwpctl"); 404 else 405 strcat (tmp, "/ctl"); 406 fd = open_with_retry (tmp, O_WRONLY); 407 if (fd < 0) 408 return 0; /* fail */ 409 pi->ctl_fd = fd; 410 break; 411 case FD_AS: 412 if (pi->tid) 413 return 0; /* There is no 'as' file descriptor for an lwp. */ 414 strcat (tmp, "/as"); 415 fd = open_with_retry (tmp, O_RDWR); 416 if (fd < 0) 417 return 0; /* fail */ 418 pi->as_fd = fd; 419 break; 420 case FD_STATUS: 421 if (pi->tid) 422 strcat (tmp, "/lwpstatus"); 423 else 424 strcat (tmp, "/status"); 425 fd = open_with_retry (tmp, O_RDONLY); 426 if (fd < 0) 427 return 0; /* fail */ 428 pi->status_fd = fd; 429 break; 430 default: 431 return 0; /* unknown file descriptor */ 432 } 433 434 return 1; /* success */ 435 } 436 437 /* Allocate a data structure and link it into the procinfo list. 438 First tries to find a pre-existing one (FIXME: why?). Returns the 439 pointer to new procinfo struct. */ 440 441 static procinfo * 442 create_procinfo (int pid, int tid) 443 { 444 procinfo *pi, *parent = NULL; 445 446 pi = find_procinfo (pid, tid); 447 if (pi != NULL) 448 return pi; /* Already exists, nothing to do. */ 449 450 /* Find parent before doing malloc, to save having to cleanup. */ 451 if (tid != 0) 452 parent = find_procinfo_or_die (pid, 0); /* FIXME: should I 453 create it if it 454 doesn't exist yet? */ 455 456 pi = XNEW (procinfo); 457 memset (pi, 0, sizeof (procinfo)); 458 pi->pid = pid; 459 pi->tid = tid; 460 461 pi->saved_entryset = XNEW (sysset_t); 462 pi->saved_exitset = XNEW (sysset_t); 463 464 /* Chain into list. */ 465 if (tid == 0) 466 { 467 xsnprintf (pi->pathname, sizeof (pi->pathname), "/proc/%d", pid); 468 pi->next = procinfo_list; 469 procinfo_list = pi; 470 } 471 else 472 { 473 xsnprintf (pi->pathname, sizeof (pi->pathname), "/proc/%d/lwp/%d", 474 pid, tid); 475 pi->next = parent->thread_list; 476 parent->thread_list = pi; 477 } 478 return pi; 479 } 480 481 /* Close all file descriptors associated with the procinfo. */ 482 483 static void 484 close_procinfo_files (procinfo *pi) 485 { 486 if (pi->ctl_fd > 0) 487 close (pi->ctl_fd); 488 if (pi->as_fd > 0) 489 close (pi->as_fd); 490 if (pi->status_fd > 0) 491 close (pi->status_fd); 492 pi->ctl_fd = pi->as_fd = pi->status_fd = 0; 493 } 494 495 /* Destructor function. Close, unlink and deallocate the object. */ 496 497 static void 498 destroy_one_procinfo (procinfo **list, procinfo *pi) 499 { 500 procinfo *ptr; 501 502 /* Step one: unlink the procinfo from its list. */ 503 if (pi == *list) 504 *list = pi->next; 505 else 506 for (ptr = *list; ptr; ptr = ptr->next) 507 if (ptr->next == pi) 508 { 509 ptr->next = pi->next; 510 break; 511 } 512 513 /* Step two: close any open file descriptors. */ 514 close_procinfo_files (pi); 515 516 /* Step three: free the memory. */ 517 xfree (pi->saved_entryset); 518 xfree (pi->saved_exitset); 519 xfree (pi); 520 } 521 522 static void 523 destroy_procinfo (procinfo *pi) 524 { 525 procinfo *tmp; 526 527 if (pi->tid != 0) /* Destroy a thread procinfo. */ 528 { 529 tmp = find_procinfo (pi->pid, 0); /* Find the parent process. */ 530 destroy_one_procinfo (&tmp->thread_list, pi); 531 } 532 else /* Destroy a process procinfo and all its threads. */ 533 { 534 /* First destroy the children, if any; */ 535 while (pi->thread_list != NULL) 536 destroy_one_procinfo (&pi->thread_list, pi->thread_list); 537 /* Then destroy the parent. Genocide!!! */ 538 destroy_one_procinfo (&procinfo_list, pi); 539 } 540 } 541 542 /* A deleter that calls destroy_procinfo. */ 543 struct procinfo_deleter 544 { 545 void operator() (procinfo *pi) const 546 { 547 destroy_procinfo (pi); 548 } 549 }; 550 551 typedef std::unique_ptr<procinfo, procinfo_deleter> procinfo_up; 552 553 enum { NOKILL, KILL }; 554 555 /* To be called on a non_recoverable error for a procinfo. Prints 556 error messages, optionally sends a SIGKILL to the process, then 557 destroys the data structure. */ 558 559 static void 560 dead_procinfo (procinfo *pi, const char *msg, int kill_p) 561 { 562 char procfile[80]; 563 564 if (pi->pathname) 565 print_sys_errmsg (pi->pathname, errno); 566 else 567 { 568 xsnprintf (procfile, sizeof (procfile), "process %d", pi->pid); 569 print_sys_errmsg (procfile, errno); 570 } 571 if (kill_p == KILL) 572 kill (pi->pid, SIGKILL); 573 574 destroy_procinfo (pi); 575 error ("%s", msg); 576 } 577 578 /* =================== END, STRUCT PROCINFO "MODULE" =================== */ 579 580 /* =================== /proc "MODULE" =================== */ 581 582 /* This "module" is the interface layer between the /proc system API 583 and the gdb target vector functions. This layer consists of access 584 functions that encapsulate each of the basic operations that we 585 need to use from the /proc API. 586 587 The main motivation for this layer is to hide the fact that there 588 were two very different implementations of the /proc API. */ 589 590 static long proc_flags (procinfo *pi); 591 static int proc_why (procinfo *pi); 592 static int proc_what (procinfo *pi); 593 static int proc_set_current_signal (procinfo *pi, int signo); 594 static int proc_get_current_thread (procinfo *pi); 595 static int proc_iterate_over_threads 596 (procinfo *pi, 597 int (*func) (procinfo *, procinfo *, void *), 598 void *ptr); 599 600 static void 601 proc_warn (procinfo *pi, const char *func, int line) 602 { 603 xsnprintf (errmsg, sizeof (errmsg), "procfs: %s line %d, %s", 604 func, line, pi->pathname); 605 print_sys_errmsg (errmsg, errno); 606 } 607 608 static void 609 proc_error (procinfo *pi, const char *func, int line) 610 { 611 xsnprintf (errmsg, sizeof (errmsg), "procfs: %s line %d, %s", 612 func, line, pi->pathname); 613 perror_with_name (errmsg); 614 } 615 616 /* Updates the status struct in the procinfo. There is a 'valid' 617 flag, to let other functions know when this function needs to be 618 called (so the status is only read when it is needed). The status 619 file descriptor is also only opened when it is needed. Returns 620 non-zero for success, zero for failure. */ 621 622 static int 623 proc_get_status (procinfo *pi) 624 { 625 /* Status file descriptor is opened "lazily". */ 626 if (pi->status_fd == 0 && open_procinfo_files (pi, FD_STATUS) == 0) 627 { 628 pi->status_valid = 0; 629 return 0; 630 } 631 632 if (lseek (pi->status_fd, 0, SEEK_SET) < 0) 633 pi->status_valid = 0; /* fail */ 634 else 635 { 636 /* Sigh... I have to read a different data structure, 637 depending on whether this is a main process or an LWP. */ 638 if (pi->tid) 639 pi->status_valid = (read (pi->status_fd, 640 (char *) &pi->prstatus.pr_lwp, 641 sizeof (lwpstatus_t)) 642 == sizeof (lwpstatus_t)); 643 else 644 { 645 pi->status_valid = (read (pi->status_fd, 646 (char *) &pi->prstatus, 647 sizeof (pstatus_t)) 648 == sizeof (pstatus_t)); 649 } 650 } 651 652 if (pi->status_valid) 653 { 654 PROC_PRETTYFPRINT_STATUS (proc_flags (pi), 655 proc_why (pi), 656 proc_what (pi), 657 proc_get_current_thread (pi)); 658 } 659 660 /* The status struct includes general regs, so mark them valid too. */ 661 pi->gregs_valid = pi->status_valid; 662 /* In the read/write multiple-fd model, the status struct includes 663 the fp regs too, so mark them valid too. */ 664 pi->fpregs_valid = pi->status_valid; 665 return pi->status_valid; /* True if success, false if failure. */ 666 } 667 668 /* Returns the process flags (pr_flags field). */ 669 670 static long 671 proc_flags (procinfo *pi) 672 { 673 if (!pi->status_valid) 674 if (!proc_get_status (pi)) 675 return 0; /* FIXME: not a good failure value (but what is?) */ 676 677 return pi->prstatus.pr_lwp.pr_flags; 678 } 679 680 /* Returns the pr_why field (why the process stopped). */ 681 682 static int 683 proc_why (procinfo *pi) 684 { 685 if (!pi->status_valid) 686 if (!proc_get_status (pi)) 687 return 0; /* FIXME: not a good failure value (but what is?) */ 688 689 return pi->prstatus.pr_lwp.pr_why; 690 } 691 692 /* Returns the pr_what field (details of why the process stopped). */ 693 694 static int 695 proc_what (procinfo *pi) 696 { 697 if (!pi->status_valid) 698 if (!proc_get_status (pi)) 699 return 0; /* FIXME: not a good failure value (but what is?) */ 700 701 return pi->prstatus.pr_lwp.pr_what; 702 } 703 704 /* This function is only called when PI is stopped by a watchpoint. 705 Assuming the OS supports it, write to *ADDR the data address which 706 triggered it and return 1. Return 0 if it is not possible to know 707 the address. */ 708 709 static int 710 proc_watchpoint_address (procinfo *pi, CORE_ADDR *addr) 711 { 712 if (!pi->status_valid) 713 if (!proc_get_status (pi)) 714 return 0; 715 716 *addr = (CORE_ADDR) gdbarch_pointer_to_address (target_gdbarch (), 717 builtin_type (target_gdbarch ())->builtin_data_ptr, 718 (gdb_byte *) &pi->prstatus.pr_lwp.pr_info.si_addr); 719 return 1; 720 } 721 722 /* Returns the pr_nsysarg field (number of args to the current 723 syscall). */ 724 725 static int 726 proc_nsysarg (procinfo *pi) 727 { 728 if (!pi->status_valid) 729 if (!proc_get_status (pi)) 730 return 0; 731 732 return pi->prstatus.pr_lwp.pr_nsysarg; 733 } 734 735 /* Returns the pr_sysarg field (pointer to the arguments of current 736 syscall). */ 737 738 static long * 739 proc_sysargs (procinfo *pi) 740 { 741 if (!pi->status_valid) 742 if (!proc_get_status (pi)) 743 return NULL; 744 745 return (long *) &pi->prstatus.pr_lwp.pr_sysarg; 746 } 747 748 /* Set or reset any of the following process flags: 749 PR_FORK -- forked child will inherit trace flags 750 PR_RLC -- traced process runs when last /proc file closed. 751 PR_KLC -- traced process is killed when last /proc file closed. 752 PR_ASYNC -- LWP's get to run/stop independently. 753 754 This function is done using read/write [PCSET/PCRESET/PCUNSET]. 755 756 Arguments: 757 pi -- the procinfo 758 flag -- one of PR_FORK, PR_RLC, or PR_ASYNC 759 mode -- 1 for set, 0 for reset. 760 761 Returns non-zero for success, zero for failure. */ 762 763 enum { FLAG_RESET, FLAG_SET }; 764 765 static int 766 proc_modify_flag (procinfo *pi, long flag, long mode) 767 { 768 long win = 0; /* default to fail */ 769 770 /* These operations affect the process as a whole, and applying them 771 to an individual LWP has the same meaning as applying them to the 772 main process. Therefore, if we're ever called with a pointer to 773 an LWP's procinfo, let's substitute the process's procinfo and 774 avoid opening the LWP's file descriptor unnecessarily. */ 775 776 if (pi->pid != 0) 777 pi = find_procinfo_or_die (pi->pid, 0); 778 779 procfs_ctl_t arg[2]; 780 781 if (mode == FLAG_SET) /* Set the flag (RLC, FORK, or ASYNC). */ 782 arg[0] = PCSET; 783 else /* Reset the flag. */ 784 arg[0] = PCUNSET; 785 786 arg[1] = flag; 787 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg)); 788 789 /* The above operation renders the procinfo's cached pstatus 790 obsolete. */ 791 pi->status_valid = 0; 792 793 if (!win) 794 warning (_("procfs: modify_flag failed to turn %s %s"), 795 flag == PR_FORK ? "PR_FORK" : 796 flag == PR_RLC ? "PR_RLC" : 797 flag == PR_ASYNC ? "PR_ASYNC" : 798 flag == PR_KLC ? "PR_KLC" : 799 "<unknown flag>", 800 mode == FLAG_RESET ? "off" : "on"); 801 802 return win; 803 } 804 805 /* Set the run_on_last_close flag. Process with all threads will 806 become runnable when debugger closes all /proc fds. Returns 807 non-zero for success, zero for failure. */ 808 809 static int 810 proc_set_run_on_last_close (procinfo *pi) 811 { 812 return proc_modify_flag (pi, PR_RLC, FLAG_SET); 813 } 814 815 /* Reset the run_on_last_close flag. The process will NOT become 816 runnable when debugger closes its file handles. Returns non-zero 817 for success, zero for failure. */ 818 819 static int 820 proc_unset_run_on_last_close (procinfo *pi) 821 { 822 return proc_modify_flag (pi, PR_RLC, FLAG_RESET); 823 } 824 825 /* Reset inherit_on_fork flag. If the process forks a child while we 826 are registered for events in the parent, then we will NOT receive 827 events from the child. Returns non-zero for success, zero for 828 failure. */ 829 830 static int 831 proc_unset_inherit_on_fork (procinfo *pi) 832 { 833 return proc_modify_flag (pi, PR_FORK, FLAG_RESET); 834 } 835 836 /* Set PR_ASYNC flag. If one LWP stops because of a debug event 837 (signal etc.), the remaining LWPs will continue to run. Returns 838 non-zero for success, zero for failure. */ 839 840 static int 841 proc_set_async (procinfo *pi) 842 { 843 return proc_modify_flag (pi, PR_ASYNC, FLAG_SET); 844 } 845 846 /* Reset PR_ASYNC flag. If one LWP stops because of a debug event 847 (signal etc.), then all other LWPs will stop as well. Returns 848 non-zero for success, zero for failure. */ 849 850 static int 851 proc_unset_async (procinfo *pi) 852 { 853 return proc_modify_flag (pi, PR_ASYNC, FLAG_RESET); 854 } 855 856 /* Request the process/LWP to stop. Does not wait. Returns non-zero 857 for success, zero for failure. */ 858 859 static int 860 proc_stop_process (procinfo *pi) 861 { 862 int win; 863 864 /* We might conceivably apply this operation to an LWP, and the 865 LWP's ctl file descriptor might not be open. */ 866 867 if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0) 868 return 0; 869 else 870 { 871 procfs_ctl_t cmd = PCSTOP; 872 873 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd)); 874 } 875 876 return win; 877 } 878 879 /* Wait for the process or LWP to stop (block until it does). Returns 880 non-zero for success, zero for failure. */ 881 882 static int 883 proc_wait_for_stop (procinfo *pi) 884 { 885 int win; 886 887 /* We should never have to apply this operation to any procinfo 888 except the one for the main process. If that ever changes for 889 any reason, then take out the following clause and replace it 890 with one that makes sure the ctl_fd is open. */ 891 892 if (pi->tid != 0) 893 pi = find_procinfo_or_die (pi->pid, 0); 894 895 procfs_ctl_t cmd = PCWSTOP; 896 897 set_sigint_trap (); 898 899 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd)); 900 901 clear_sigint_trap (); 902 903 /* We been runnin' and we stopped -- need to update status. */ 904 pi->status_valid = 0; 905 906 return win; 907 } 908 909 /* Make the process or LWP runnable. 910 911 Options (not all are implemented): 912 - single-step 913 - clear current fault 914 - clear current signal 915 - abort the current system call 916 - stop as soon as finished with system call 917 918 Always clears the current fault. PI is the process or LWP to 919 operate on. If STEP is true, set the process or LWP to trap after 920 one instruction. If SIGNO is zero, clear the current signal if 921 any; if non-zero, set the current signal to this one. Returns 922 non-zero for success, zero for failure. */ 923 924 static int 925 proc_run_process (procinfo *pi, int step, int signo) 926 { 927 int win; 928 int runflags; 929 930 /* We will probably have to apply this operation to individual 931 threads, so make sure the control file descriptor is open. */ 932 933 if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0) 934 return 0; 935 936 runflags = PRCFAULT; /* Always clear current fault. */ 937 if (step) 938 runflags |= PRSTEP; 939 if (signo == 0) 940 runflags |= PRCSIG; 941 else if (signo != -1) /* -1 means do nothing W.R.T. signals. */ 942 proc_set_current_signal (pi, signo); 943 944 procfs_ctl_t cmd[2]; 945 946 cmd[0] = PCRUN; 947 cmd[1] = runflags; 948 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd)); 949 950 return win; 951 } 952 953 /* Register to trace signals in the process or LWP. Returns non-zero 954 for success, zero for failure. */ 955 956 static int 957 proc_set_traced_signals (procinfo *pi, sigset_t *sigset) 958 { 959 int win; 960 961 /* We should never have to apply this operation to any procinfo 962 except the one for the main process. If that ever changes for 963 any reason, then take out the following clause and replace it 964 with one that makes sure the ctl_fd is open. */ 965 966 if (pi->tid != 0) 967 pi = find_procinfo_or_die (pi->pid, 0); 968 969 struct { 970 procfs_ctl_t cmd; 971 /* Use char array to avoid alignment issues. */ 972 char sigset[sizeof (sigset_t)]; 973 } arg; 974 975 arg.cmd = PCSTRACE; 976 memcpy (&arg.sigset, sigset, sizeof (sigset_t)); 977 978 win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg)); 979 980 /* The above operation renders the procinfo's cached pstatus obsolete. */ 981 pi->status_valid = 0; 982 983 if (!win) 984 warning (_("procfs: set_traced_signals failed")); 985 return win; 986 } 987 988 /* Register to trace hardware faults in the process or LWP. Returns 989 non-zero for success, zero for failure. */ 990 991 static int 992 proc_set_traced_faults (procinfo *pi, fltset_t *fltset) 993 { 994 int win; 995 996 /* We should never have to apply this operation to any procinfo 997 except the one for the main process. If that ever changes for 998 any reason, then take out the following clause and replace it 999 with one that makes sure the ctl_fd is open. */ 1000 1001 if (pi->tid != 0) 1002 pi = find_procinfo_or_die (pi->pid, 0); 1003 1004 struct { 1005 procfs_ctl_t cmd; 1006 /* Use char array to avoid alignment issues. */ 1007 char fltset[sizeof (fltset_t)]; 1008 } arg; 1009 1010 arg.cmd = PCSFAULT; 1011 memcpy (&arg.fltset, fltset, sizeof (fltset_t)); 1012 1013 win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg)); 1014 1015 /* The above operation renders the procinfo's cached pstatus obsolete. */ 1016 pi->status_valid = 0; 1017 1018 return win; 1019 } 1020 1021 /* Register to trace entry to system calls in the process or LWP. 1022 Returns non-zero for success, zero for failure. */ 1023 1024 static int 1025 proc_set_traced_sysentry (procinfo *pi, sysset_t *sysset) 1026 { 1027 int win; 1028 1029 /* We should never have to apply this operation to any procinfo 1030 except the one for the main process. If that ever changes for 1031 any reason, then take out the following clause and replace it 1032 with one that makes sure the ctl_fd is open. */ 1033 1034 if (pi->tid != 0) 1035 pi = find_procinfo_or_die (pi->pid, 0); 1036 1037 struct { 1038 procfs_ctl_t cmd; 1039 /* Use char array to avoid alignment issues. */ 1040 char sysset[sizeof (sysset_t)]; 1041 } arg; 1042 1043 arg.cmd = PCSENTRY; 1044 memcpy (&arg.sysset, sysset, sizeof (sysset_t)); 1045 1046 win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg)); 1047 1048 /* The above operation renders the procinfo's cached pstatus 1049 obsolete. */ 1050 pi->status_valid = 0; 1051 1052 return win; 1053 } 1054 1055 /* Register to trace exit from system calls in the process or LWP. 1056 Returns non-zero for success, zero for failure. */ 1057 1058 static int 1059 proc_set_traced_sysexit (procinfo *pi, sysset_t *sysset) 1060 { 1061 int win; 1062 1063 /* We should never have to apply this operation to any procinfo 1064 except the one for the main process. If that ever changes for 1065 any reason, then take out the following clause and replace it 1066 with one that makes sure the ctl_fd is open. */ 1067 1068 if (pi->tid != 0) 1069 pi = find_procinfo_or_die (pi->pid, 0); 1070 1071 struct gdb_proc_ctl_pcsexit { 1072 procfs_ctl_t cmd; 1073 /* Use char array to avoid alignment issues. */ 1074 char sysset[sizeof (sysset_t)]; 1075 } arg; 1076 1077 arg.cmd = PCSEXIT; 1078 memcpy (&arg.sysset, sysset, sizeof (sysset_t)); 1079 1080 win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg)); 1081 1082 /* The above operation renders the procinfo's cached pstatus 1083 obsolete. */ 1084 pi->status_valid = 0; 1085 1086 return win; 1087 } 1088 1089 /* Specify the set of blocked / held signals in the process or LWP. 1090 Returns non-zero for success, zero for failure. */ 1091 1092 static int 1093 proc_set_held_signals (procinfo *pi, sigset_t *sighold) 1094 { 1095 int win; 1096 1097 /* We should never have to apply this operation to any procinfo 1098 except the one for the main process. If that ever changes for 1099 any reason, then take out the following clause and replace it 1100 with one that makes sure the ctl_fd is open. */ 1101 1102 if (pi->tid != 0) 1103 pi = find_procinfo_or_die (pi->pid, 0); 1104 1105 struct { 1106 procfs_ctl_t cmd; 1107 /* Use char array to avoid alignment issues. */ 1108 char hold[sizeof (sigset_t)]; 1109 } arg; 1110 1111 arg.cmd = PCSHOLD; 1112 memcpy (&arg.hold, sighold, sizeof (sigset_t)); 1113 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg)); 1114 1115 /* The above operation renders the procinfo's cached pstatus 1116 obsolete. */ 1117 pi->status_valid = 0; 1118 1119 return win; 1120 } 1121 1122 /* Returns the set of signals that are held / blocked. Will also copy 1123 the sigset if SAVE is non-zero. */ 1124 1125 static sigset_t * 1126 proc_get_held_signals (procinfo *pi, sigset_t *save) 1127 { 1128 sigset_t *ret = NULL; 1129 1130 /* We should never have to apply this operation to any procinfo 1131 except the one for the main process. If that ever changes for 1132 any reason, then take out the following clause and replace it 1133 with one that makes sure the ctl_fd is open. */ 1134 1135 if (pi->tid != 0) 1136 pi = find_procinfo_or_die (pi->pid, 0); 1137 1138 if (!pi->status_valid) 1139 if (!proc_get_status (pi)) 1140 return NULL; 1141 1142 ret = &pi->prstatus.pr_lwp.pr_lwphold; 1143 if (save && ret) 1144 memcpy (save, ret, sizeof (sigset_t)); 1145 1146 return ret; 1147 } 1148 1149 /* Returns the set of signals that are traced / debugged. Will also 1150 copy the sigset if SAVE is non-zero. */ 1151 1152 static sigset_t * 1153 proc_get_traced_signals (procinfo *pi, sigset_t *save) 1154 { 1155 sigset_t *ret = NULL; 1156 1157 /* We should never have to apply this operation to any procinfo 1158 except the one for the main process. If that ever changes for 1159 any reason, then take out the following clause and replace it 1160 with one that makes sure the ctl_fd is open. */ 1161 1162 if (pi->tid != 0) 1163 pi = find_procinfo_or_die (pi->pid, 0); 1164 1165 if (!pi->status_valid) 1166 if (!proc_get_status (pi)) 1167 return NULL; 1168 1169 ret = &pi->prstatus.pr_sigtrace; 1170 if (save && ret) 1171 memcpy (save, ret, sizeof (sigset_t)); 1172 1173 return ret; 1174 } 1175 1176 /* Returns the set of hardware faults that are traced /debugged. Will 1177 also copy the faultset if SAVE is non-zero. */ 1178 1179 static fltset_t * 1180 proc_get_traced_faults (procinfo *pi, fltset_t *save) 1181 { 1182 fltset_t *ret = NULL; 1183 1184 /* We should never have to apply this operation to any procinfo 1185 except the one for the main process. If that ever changes for 1186 any reason, then take out the following clause and replace it 1187 with one that makes sure the ctl_fd is open. */ 1188 1189 if (pi->tid != 0) 1190 pi = find_procinfo_or_die (pi->pid, 0); 1191 1192 if (!pi->status_valid) 1193 if (!proc_get_status (pi)) 1194 return NULL; 1195 1196 ret = &pi->prstatus.pr_flttrace; 1197 if (save && ret) 1198 memcpy (save, ret, sizeof (fltset_t)); 1199 1200 return ret; 1201 } 1202 1203 /* Returns the set of syscalls that are traced /debugged on entry. 1204 Will also copy the syscall set if SAVE is non-zero. */ 1205 1206 static sysset_t * 1207 proc_get_traced_sysentry (procinfo *pi, sysset_t *save) 1208 { 1209 sysset_t *ret = NULL; 1210 1211 /* We should never have to apply this operation to any procinfo 1212 except the one for the main process. If that ever changes for 1213 any reason, then take out the following clause and replace it 1214 with one that makes sure the ctl_fd is open. */ 1215 1216 if (pi->tid != 0) 1217 pi = find_procinfo_or_die (pi->pid, 0); 1218 1219 if (!pi->status_valid) 1220 if (!proc_get_status (pi)) 1221 return NULL; 1222 1223 ret = &pi->prstatus.pr_sysentry; 1224 if (save && ret) 1225 memcpy (save, ret, sizeof (sysset_t)); 1226 1227 return ret; 1228 } 1229 1230 /* Returns the set of syscalls that are traced /debugged on exit. 1231 Will also copy the syscall set if SAVE is non-zero. */ 1232 1233 static sysset_t * 1234 proc_get_traced_sysexit (procinfo *pi, sysset_t *save) 1235 { 1236 sysset_t *ret = NULL; 1237 1238 /* We should never have to apply this operation to any procinfo 1239 except the one for the main process. If that ever changes for 1240 any reason, then take out the following clause and replace it 1241 with one that makes sure the ctl_fd is open. */ 1242 1243 if (pi->tid != 0) 1244 pi = find_procinfo_or_die (pi->pid, 0); 1245 1246 if (!pi->status_valid) 1247 if (!proc_get_status (pi)) 1248 return NULL; 1249 1250 ret = &pi->prstatus.pr_sysexit; 1251 if (save && ret) 1252 memcpy (save, ret, sizeof (sysset_t)); 1253 1254 return ret; 1255 } 1256 1257 /* The current fault (if any) is cleared; the associated signal will 1258 not be sent to the process or LWP when it resumes. Returns 1259 non-zero for success, zero for failure. */ 1260 1261 static int 1262 proc_clear_current_fault (procinfo *pi) 1263 { 1264 int win; 1265 1266 /* We should never have to apply this operation to any procinfo 1267 except the one for the main process. If that ever changes for 1268 any reason, then take out the following clause and replace it 1269 with one that makes sure the ctl_fd is open. */ 1270 1271 if (pi->tid != 0) 1272 pi = find_procinfo_or_die (pi->pid, 0); 1273 1274 procfs_ctl_t cmd = PCCFAULT; 1275 1276 win = (write (pi->ctl_fd, (void *) &cmd, sizeof (cmd)) == sizeof (cmd)); 1277 1278 return win; 1279 } 1280 1281 /* Set the "current signal" that will be delivered next to the 1282 process. NOTE: semantics are different from those of KILL. This 1283 signal will be delivered to the process or LWP immediately when it 1284 is resumed (even if the signal is held/blocked); it will NOT 1285 immediately cause another event of interest, and will NOT first 1286 trap back to the debugger. Returns non-zero for success, zero for 1287 failure. */ 1288 1289 static int 1290 proc_set_current_signal (procinfo *pi, int signo) 1291 { 1292 int win; 1293 struct { 1294 procfs_ctl_t cmd; 1295 /* Use char array to avoid alignment issues. */ 1296 char sinfo[sizeof (siginfo_t)]; 1297 } arg; 1298 siginfo_t mysinfo; 1299 process_stratum_target *wait_target; 1300 ptid_t wait_ptid; 1301 struct target_waitstatus wait_status; 1302 1303 /* We should never have to apply this operation to any procinfo 1304 except the one for the main process. If that ever changes for 1305 any reason, then take out the following clause and replace it 1306 with one that makes sure the ctl_fd is open. */ 1307 1308 if (pi->tid != 0) 1309 pi = find_procinfo_or_die (pi->pid, 0); 1310 1311 /* The pointer is just a type alias. */ 1312 get_last_target_status (&wait_target, &wait_ptid, &wait_status); 1313 if (wait_target == &the_procfs_target 1314 && wait_ptid == inferior_ptid 1315 && wait_status.kind == TARGET_WAITKIND_STOPPED 1316 && wait_status.value.sig == gdb_signal_from_host (signo) 1317 && proc_get_status (pi) 1318 && pi->prstatus.pr_lwp.pr_info.si_signo == signo 1319 ) 1320 /* Use the siginfo associated with the signal being 1321 redelivered. */ 1322 memcpy (arg.sinfo, &pi->prstatus.pr_lwp.pr_info, sizeof (siginfo_t)); 1323 else 1324 { 1325 mysinfo.si_signo = signo; 1326 mysinfo.si_code = 0; 1327 mysinfo.si_pid = getpid (); /* ?why? */ 1328 mysinfo.si_uid = getuid (); /* ?why? */ 1329 memcpy (arg.sinfo, &mysinfo, sizeof (siginfo_t)); 1330 } 1331 1332 arg.cmd = PCSSIG; 1333 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg)); 1334 1335 return win; 1336 } 1337 1338 /* The current signal (if any) is cleared, and is not sent to the 1339 process or LWP when it resumes. Returns non-zero for success, zero 1340 for failure. */ 1341 1342 static int 1343 proc_clear_current_signal (procinfo *pi) 1344 { 1345 int win; 1346 1347 /* We should never have to apply this operation to any procinfo 1348 except the one for the main process. If that ever changes for 1349 any reason, then take out the following clause and replace it 1350 with one that makes sure the ctl_fd is open. */ 1351 1352 if (pi->tid != 0) 1353 pi = find_procinfo_or_die (pi->pid, 0); 1354 1355 struct { 1356 procfs_ctl_t cmd; 1357 /* Use char array to avoid alignment issues. */ 1358 char sinfo[sizeof (siginfo_t)]; 1359 } arg; 1360 siginfo_t mysinfo; 1361 1362 arg.cmd = PCSSIG; 1363 /* The pointer is just a type alias. */ 1364 mysinfo.si_signo = 0; 1365 mysinfo.si_code = 0; 1366 mysinfo.si_errno = 0; 1367 mysinfo.si_pid = getpid (); /* ?why? */ 1368 mysinfo.si_uid = getuid (); /* ?why? */ 1369 memcpy (arg.sinfo, &mysinfo, sizeof (siginfo_t)); 1370 1371 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg)); 1372 1373 return win; 1374 } 1375 1376 /* Return the general-purpose registers for the process or LWP 1377 corresponding to PI. Upon failure, return NULL. */ 1378 1379 static gdb_gregset_t * 1380 proc_get_gregs (procinfo *pi) 1381 { 1382 if (!pi->status_valid || !pi->gregs_valid) 1383 if (!proc_get_status (pi)) 1384 return NULL; 1385 1386 return &pi->prstatus.pr_lwp.pr_reg; 1387 } 1388 1389 /* Return the general-purpose registers for the process or LWP 1390 corresponding to PI. Upon failure, return NULL. */ 1391 1392 static gdb_fpregset_t * 1393 proc_get_fpregs (procinfo *pi) 1394 { 1395 if (!pi->status_valid || !pi->fpregs_valid) 1396 if (!proc_get_status (pi)) 1397 return NULL; 1398 1399 return &pi->prstatus.pr_lwp.pr_fpreg; 1400 } 1401 1402 /* Write the general-purpose registers back to the process or LWP 1403 corresponding to PI. Return non-zero for success, zero for 1404 failure. */ 1405 1406 static int 1407 proc_set_gregs (procinfo *pi) 1408 { 1409 gdb_gregset_t *gregs; 1410 int win; 1411 1412 gregs = proc_get_gregs (pi); 1413 if (gregs == NULL) 1414 return 0; /* proc_get_regs has already warned. */ 1415 1416 if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0) 1417 return 0; 1418 else 1419 { 1420 struct { 1421 procfs_ctl_t cmd; 1422 /* Use char array to avoid alignment issues. */ 1423 char gregs[sizeof (gdb_gregset_t)]; 1424 } arg; 1425 1426 arg.cmd = PCSREG; 1427 memcpy (&arg.gregs, gregs, sizeof (arg.gregs)); 1428 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg)); 1429 } 1430 1431 /* Policy: writing the registers invalidates our cache. */ 1432 pi->gregs_valid = 0; 1433 return win; 1434 } 1435 1436 /* Write the floating-pointer registers back to the process or LWP 1437 corresponding to PI. Return non-zero for success, zero for 1438 failure. */ 1439 1440 static int 1441 proc_set_fpregs (procinfo *pi) 1442 { 1443 gdb_fpregset_t *fpregs; 1444 int win; 1445 1446 fpregs = proc_get_fpregs (pi); 1447 if (fpregs == NULL) 1448 return 0; /* proc_get_fpregs has already warned. */ 1449 1450 if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0) 1451 return 0; 1452 else 1453 { 1454 struct { 1455 procfs_ctl_t cmd; 1456 /* Use char array to avoid alignment issues. */ 1457 char fpregs[sizeof (gdb_fpregset_t)]; 1458 } arg; 1459 1460 arg.cmd = PCSFPREG; 1461 memcpy (&arg.fpregs, fpregs, sizeof (arg.fpregs)); 1462 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg)); 1463 } 1464 1465 /* Policy: writing the registers invalidates our cache. */ 1466 pi->fpregs_valid = 0; 1467 return win; 1468 } 1469 1470 /* Send a signal to the proc or lwp with the semantics of "kill()". 1471 Returns non-zero for success, zero for failure. */ 1472 1473 static int 1474 proc_kill (procinfo *pi, int signo) 1475 { 1476 int win; 1477 1478 /* We might conceivably apply this operation to an LWP, and the 1479 LWP's ctl file descriptor might not be open. */ 1480 1481 if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0) 1482 return 0; 1483 else 1484 { 1485 procfs_ctl_t cmd[2]; 1486 1487 cmd[0] = PCKILL; 1488 cmd[1] = signo; 1489 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd)); 1490 } 1491 1492 return win; 1493 } 1494 1495 /* Find the pid of the process that started this one. Returns the 1496 parent process pid, or zero. */ 1497 1498 static int 1499 proc_parent_pid (procinfo *pi) 1500 { 1501 /* We should never have to apply this operation to any procinfo 1502 except the one for the main process. If that ever changes for 1503 any reason, then take out the following clause and replace it 1504 with one that makes sure the ctl_fd is open. */ 1505 1506 if (pi->tid != 0) 1507 pi = find_procinfo_or_die (pi->pid, 0); 1508 1509 if (!pi->status_valid) 1510 if (!proc_get_status (pi)) 1511 return 0; 1512 1513 return pi->prstatus.pr_ppid; 1514 } 1515 1516 /* Convert a target address (a.k.a. CORE_ADDR) into a host address 1517 (a.k.a void pointer)! */ 1518 1519 static void * 1520 procfs_address_to_host_pointer (CORE_ADDR addr) 1521 { 1522 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; 1523 void *ptr; 1524 1525 gdb_assert (sizeof (ptr) == TYPE_LENGTH (ptr_type)); 1526 gdbarch_address_to_pointer (target_gdbarch (), ptr_type, 1527 (gdb_byte *) &ptr, addr); 1528 return ptr; 1529 } 1530 1531 static int 1532 proc_set_watchpoint (procinfo *pi, CORE_ADDR addr, int len, int wflags) 1533 { 1534 struct { 1535 procfs_ctl_t cmd; 1536 char watch[sizeof (prwatch_t)]; 1537 } arg; 1538 prwatch_t pwatch; 1539 1540 /* NOTE: cagney/2003-02-01: Even more horrible hack. Need to 1541 convert a target address into something that can be stored in a 1542 native data structure. */ 1543 pwatch.pr_vaddr = (uintptr_t) procfs_address_to_host_pointer (addr); 1544 pwatch.pr_size = len; 1545 pwatch.pr_wflags = wflags; 1546 arg.cmd = PCWATCH; 1547 memcpy (arg.watch, &pwatch, sizeof (prwatch_t)); 1548 return (write (pi->ctl_fd, &arg, sizeof (arg)) == sizeof (arg)); 1549 } 1550 1551 /* =============== END, non-thread part of /proc "MODULE" =============== */ 1552 1553 /* =================== Thread "MODULE" =================== */ 1554 1555 /* Returns the number of threads for the process. */ 1556 1557 static int 1558 proc_get_nthreads (procinfo *pi) 1559 { 1560 if (!pi->status_valid) 1561 if (!proc_get_status (pi)) 1562 return 0; 1563 1564 /* Only works for the process procinfo, because the LWP procinfos do not 1565 get prstatus filled in. */ 1566 if (pi->tid != 0) /* Find the parent process procinfo. */ 1567 pi = find_procinfo_or_die (pi->pid, 0); 1568 return pi->prstatus.pr_nlwp; 1569 } 1570 1571 /* Return the ID of the thread that had an event of interest. 1572 (ie. the one that hit a breakpoint or other traced event). All 1573 other things being equal, this should be the ID of a thread that is 1574 currently executing. */ 1575 1576 static int 1577 proc_get_current_thread (procinfo *pi) 1578 { 1579 /* Note: this should be applied to the root procinfo for the 1580 process, not to the procinfo for an LWP. If applied to the 1581 procinfo for an LWP, it will simply return that LWP's ID. In 1582 that case, find the parent process procinfo. */ 1583 1584 if (pi->tid != 0) 1585 pi = find_procinfo_or_die (pi->pid, 0); 1586 1587 if (!pi->status_valid) 1588 if (!proc_get_status (pi)) 1589 return 0; 1590 1591 return pi->prstatus.pr_lwp.pr_lwpid; 1592 } 1593 1594 /* Discover the IDs of all the threads within the process, and create 1595 a procinfo for each of them (chained to the parent). Returns 1596 non-zero for success, zero for failure. */ 1597 1598 static int 1599 proc_delete_dead_threads (procinfo *parent, procinfo *thread, void *ignore) 1600 { 1601 if (thread && parent) /* sanity */ 1602 { 1603 thread->status_valid = 0; 1604 if (!proc_get_status (thread)) 1605 destroy_one_procinfo (&parent->thread_list, thread); 1606 } 1607 return 0; /* keep iterating */ 1608 } 1609 1610 static int 1611 proc_update_threads (procinfo *pi) 1612 { 1613 char pathname[MAX_PROC_NAME_SIZE + 16]; 1614 struct dirent *direntry; 1615 procinfo *thread; 1616 gdb_dir_up dirp; 1617 int lwpid; 1618 1619 /* We should never have to apply this operation to any procinfo 1620 except the one for the main process. If that ever changes for 1621 any reason, then take out the following clause and replace it 1622 with one that makes sure the ctl_fd is open. */ 1623 1624 if (pi->tid != 0) 1625 pi = find_procinfo_or_die (pi->pid, 0); 1626 1627 proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL); 1628 1629 /* Note: this brute-force method was originally devised for Unixware 1630 (support removed since), and will also work on Solaris 2.6 and 1631 2.7. The original comment mentioned the existence of a much 1632 simpler and more elegant way to do this on Solaris, but didn't 1633 point out what that was. */ 1634 1635 strcpy (pathname, pi->pathname); 1636 strcat (pathname, "/lwp"); 1637 dirp.reset (opendir (pathname)); 1638 if (dirp == NULL) 1639 proc_error (pi, "update_threads, opendir", __LINE__); 1640 1641 while ((direntry = readdir (dirp.get ())) != NULL) 1642 if (direntry->d_name[0] != '.') /* skip '.' and '..' */ 1643 { 1644 lwpid = atoi (&direntry->d_name[0]); 1645 thread = create_procinfo (pi->pid, lwpid); 1646 if (thread == NULL) 1647 proc_error (pi, "update_threads, create_procinfo", __LINE__); 1648 } 1649 pi->threads_valid = 1; 1650 return 1; 1651 } 1652 1653 /* Given a pointer to a function, call that function once for each lwp 1654 in the procinfo list, until the function returns non-zero, in which 1655 event return the value returned by the function. 1656 1657 Note: this function does NOT call update_threads. If you want to 1658 discover new threads first, you must call that function explicitly. 1659 This function just makes a quick pass over the currently-known 1660 procinfos. 1661 1662 PI is the parent process procinfo. FUNC is the per-thread 1663 function. PTR is an opaque parameter for function. Returns the 1664 first non-zero return value from the callee, or zero. */ 1665 1666 static int 1667 proc_iterate_over_threads (procinfo *pi, 1668 int (*func) (procinfo *, procinfo *, void *), 1669 void *ptr) 1670 { 1671 procinfo *thread, *next; 1672 int retval = 0; 1673 1674 /* We should never have to apply this operation to any procinfo 1675 except the one for the main process. If that ever changes for 1676 any reason, then take out the following clause and replace it 1677 with one that makes sure the ctl_fd is open. */ 1678 1679 if (pi->tid != 0) 1680 pi = find_procinfo_or_die (pi->pid, 0); 1681 1682 for (thread = pi->thread_list; thread != NULL; thread = next) 1683 { 1684 next = thread->next; /* In case thread is destroyed. */ 1685 retval = (*func) (pi, thread, ptr); 1686 if (retval != 0) 1687 break; 1688 } 1689 1690 return retval; 1691 } 1692 1693 /* =================== END, Thread "MODULE" =================== */ 1694 1695 /* =================== END, /proc "MODULE" =================== */ 1696 1697 /* =================== GDB "MODULE" =================== */ 1698 1699 /* Here are all of the gdb target vector functions and their 1700 friends. */ 1701 1702 static void do_attach (ptid_t ptid); 1703 static void do_detach (); 1704 static void proc_trace_syscalls_1 (procinfo *pi, int syscallnum, 1705 int entry_or_exit, int mode, int from_tty); 1706 1707 /* Sets up the inferior to be debugged. Registers to trace signals, 1708 hardware faults, and syscalls. Note: does not set RLC flag: caller 1709 may want to customize that. Returns zero for success (note! 1710 unlike most functions in this module); on failure, returns the LINE 1711 NUMBER where it failed! */ 1712 1713 static int 1714 procfs_debug_inferior (procinfo *pi) 1715 { 1716 fltset_t traced_faults; 1717 sigset_t traced_signals; 1718 sysset_t *traced_syscall_entries; 1719 sysset_t *traced_syscall_exits; 1720 int status; 1721 1722 /* Register to trace hardware faults in the child. */ 1723 prfillset (&traced_faults); /* trace all faults... */ 1724 prdelset (&traced_faults, FLTPAGE); /* except page fault. */ 1725 if (!proc_set_traced_faults (pi, &traced_faults)) 1726 return __LINE__; 1727 1728 /* Initially, register to trace all signals in the child. */ 1729 prfillset (&traced_signals); 1730 if (!proc_set_traced_signals (pi, &traced_signals)) 1731 return __LINE__; 1732 1733 1734 /* Register to trace the 'exit' system call (on entry). */ 1735 traced_syscall_entries = XNEW (sysset_t); 1736 premptyset (traced_syscall_entries); 1737 praddset (traced_syscall_entries, SYS_exit); 1738 praddset (traced_syscall_entries, SYS_lwp_exit); 1739 1740 status = proc_set_traced_sysentry (pi, traced_syscall_entries); 1741 xfree (traced_syscall_entries); 1742 if (!status) 1743 return __LINE__; 1744 1745 /* Method for tracing exec syscalls. */ 1746 traced_syscall_exits = XNEW (sysset_t); 1747 premptyset (traced_syscall_exits); 1748 praddset (traced_syscall_exits, SYS_execve); 1749 praddset (traced_syscall_exits, SYS_lwp_create); 1750 praddset (traced_syscall_exits, SYS_lwp_exit); 1751 1752 status = proc_set_traced_sysexit (pi, traced_syscall_exits); 1753 xfree (traced_syscall_exits); 1754 if (!status) 1755 return __LINE__; 1756 1757 return 0; 1758 } 1759 1760 void 1761 procfs_target::attach (const char *args, int from_tty) 1762 { 1763 int pid; 1764 1765 pid = parse_pid_to_attach (args); 1766 1767 if (pid == getpid ()) 1768 error (_("Attaching GDB to itself is not a good idea...")); 1769 1770 if (from_tty) 1771 { 1772 const char *exec_file = get_exec_file (0); 1773 1774 if (exec_file) 1775 printf_filtered (_("Attaching to program `%s', %s\n"), 1776 exec_file, target_pid_to_str (ptid_t (pid)).c_str ()); 1777 else 1778 printf_filtered (_("Attaching to %s\n"), 1779 target_pid_to_str (ptid_t (pid)).c_str ()); 1780 1781 fflush (stdout); 1782 } 1783 do_attach (ptid_t (pid)); 1784 if (!target_is_pushed (this)) 1785 push_target (this); 1786 } 1787 1788 void 1789 procfs_target::detach (inferior *inf, int from_tty) 1790 { 1791 int pid = inferior_ptid.pid (); 1792 1793 if (from_tty) 1794 { 1795 const char *exec_file; 1796 1797 exec_file = get_exec_file (0); 1798 if (exec_file == NULL) 1799 exec_file = ""; 1800 1801 printf_filtered (_("Detaching from program: %s, %s\n"), exec_file, 1802 target_pid_to_str (ptid_t (pid)).c_str ()); 1803 } 1804 1805 do_detach (); 1806 1807 switch_to_no_thread (); 1808 detach_inferior (inf); 1809 maybe_unpush_target (); 1810 } 1811 1812 static void 1813 do_attach (ptid_t ptid) 1814 { 1815 procinfo *pi; 1816 struct inferior *inf; 1817 int fail; 1818 int lwpid; 1819 1820 pi = create_procinfo (ptid.pid (), 0); 1821 if (pi == NULL) 1822 perror (_("procfs: out of memory in 'attach'")); 1823 1824 if (!open_procinfo_files (pi, FD_CTL)) 1825 { 1826 fprintf_filtered (gdb_stderr, "procfs:%d -- ", __LINE__); 1827 xsnprintf (errmsg, sizeof (errmsg), 1828 "do_attach: couldn't open /proc file for process %d", 1829 ptid.pid ()); 1830 dead_procinfo (pi, errmsg, NOKILL); 1831 } 1832 1833 /* Stop the process (if it isn't already stopped). */ 1834 if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) 1835 { 1836 pi->was_stopped = 1; 1837 proc_prettyprint_why (proc_why (pi), proc_what (pi), 1); 1838 } 1839 else 1840 { 1841 pi->was_stopped = 0; 1842 /* Set the process to run again when we close it. */ 1843 if (!proc_set_run_on_last_close (pi)) 1844 dead_procinfo (pi, "do_attach: couldn't set RLC.", NOKILL); 1845 1846 /* Now stop the process. */ 1847 if (!proc_stop_process (pi)) 1848 dead_procinfo (pi, "do_attach: couldn't stop the process.", NOKILL); 1849 pi->ignore_next_sigstop = 1; 1850 } 1851 /* Save some of the /proc state to be restored if we detach. */ 1852 if (!proc_get_traced_faults (pi, &pi->saved_fltset)) 1853 dead_procinfo (pi, "do_attach: couldn't save traced faults.", NOKILL); 1854 if (!proc_get_traced_signals (pi, &pi->saved_sigset)) 1855 dead_procinfo (pi, "do_attach: couldn't save traced signals.", NOKILL); 1856 if (!proc_get_traced_sysentry (pi, pi->saved_entryset)) 1857 dead_procinfo (pi, "do_attach: couldn't save traced syscall entries.", 1858 NOKILL); 1859 if (!proc_get_traced_sysexit (pi, pi->saved_exitset)) 1860 dead_procinfo (pi, "do_attach: couldn't save traced syscall exits.", 1861 NOKILL); 1862 if (!proc_get_held_signals (pi, &pi->saved_sighold)) 1863 dead_procinfo (pi, "do_attach: couldn't save held signals.", NOKILL); 1864 1865 fail = procfs_debug_inferior (pi); 1866 if (fail != 0) 1867 dead_procinfo (pi, "do_attach: failed in procfs_debug_inferior", NOKILL); 1868 1869 inf = current_inferior (); 1870 inferior_appeared (inf, pi->pid); 1871 /* Let GDB know that the inferior was attached. */ 1872 inf->attach_flag = 1; 1873 1874 /* Create a procinfo for the current lwp. */ 1875 lwpid = proc_get_current_thread (pi); 1876 create_procinfo (pi->pid, lwpid); 1877 1878 /* Add it to gdb's thread list. */ 1879 ptid = ptid_t (pi->pid, lwpid, 0); 1880 thread_info *thr = add_thread (&the_procfs_target, ptid); 1881 switch_to_thread (thr); 1882 } 1883 1884 static void 1885 do_detach () 1886 { 1887 procinfo *pi; 1888 1889 /* Find procinfo for the main process. */ 1890 pi = find_procinfo_or_die (inferior_ptid.pid (), 1891 0); /* FIXME: threads */ 1892 1893 if (!proc_set_traced_signals (pi, &pi->saved_sigset)) 1894 proc_warn (pi, "do_detach, set_traced_signal", __LINE__); 1895 1896 if (!proc_set_traced_faults (pi, &pi->saved_fltset)) 1897 proc_warn (pi, "do_detach, set_traced_faults", __LINE__); 1898 1899 if (!proc_set_traced_sysentry (pi, pi->saved_entryset)) 1900 proc_warn (pi, "do_detach, set_traced_sysentry", __LINE__); 1901 1902 if (!proc_set_traced_sysexit (pi, pi->saved_exitset)) 1903 proc_warn (pi, "do_detach, set_traced_sysexit", __LINE__); 1904 1905 if (!proc_set_held_signals (pi, &pi->saved_sighold)) 1906 proc_warn (pi, "do_detach, set_held_signals", __LINE__); 1907 1908 if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) 1909 if (!(pi->was_stopped) 1910 || query (_("Was stopped when attached, make it runnable again? "))) 1911 { 1912 /* Clear any pending signal. */ 1913 if (!proc_clear_current_fault (pi)) 1914 proc_warn (pi, "do_detach, clear_current_fault", __LINE__); 1915 1916 if (!proc_clear_current_signal (pi)) 1917 proc_warn (pi, "do_detach, clear_current_signal", __LINE__); 1918 1919 if (!proc_set_run_on_last_close (pi)) 1920 proc_warn (pi, "do_detach, set_rlc", __LINE__); 1921 } 1922 1923 destroy_procinfo (pi); 1924 } 1925 1926 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this 1927 for all registers. 1928 1929 NOTE: Since the /proc interface cannot give us individual 1930 registers, we pay no attention to REGNUM, and just fetch them all. 1931 This results in the possibility that we will do unnecessarily many 1932 fetches, since we may be called repeatedly for individual 1933 registers. So we cache the results, and mark the cache invalid 1934 when the process is resumed. */ 1935 1936 void 1937 procfs_target::fetch_registers (struct regcache *regcache, int regnum) 1938 { 1939 gdb_gregset_t *gregs; 1940 procinfo *pi; 1941 ptid_t ptid = regcache->ptid (); 1942 int pid = ptid.pid (); 1943 int tid = ptid.lwp (); 1944 struct gdbarch *gdbarch = regcache->arch (); 1945 1946 pi = find_procinfo_or_die (pid, tid); 1947 1948 if (pi == NULL) 1949 error (_("procfs: fetch_registers failed to find procinfo for %s"), 1950 target_pid_to_str (ptid).c_str ()); 1951 1952 gregs = proc_get_gregs (pi); 1953 if (gregs == NULL) 1954 proc_error (pi, "fetch_registers, get_gregs", __LINE__); 1955 1956 supply_gregset (regcache, (const gdb_gregset_t *) gregs); 1957 1958 if (gdbarch_fp0_regnum (gdbarch) >= 0) /* Do we have an FPU? */ 1959 { 1960 gdb_fpregset_t *fpregs; 1961 1962 if ((regnum >= 0 && regnum < gdbarch_fp0_regnum (gdbarch)) 1963 || regnum == gdbarch_pc_regnum (gdbarch) 1964 || regnum == gdbarch_sp_regnum (gdbarch)) 1965 return; /* Not a floating point register. */ 1966 1967 fpregs = proc_get_fpregs (pi); 1968 if (fpregs == NULL) 1969 proc_error (pi, "fetch_registers, get_fpregs", __LINE__); 1970 1971 supply_fpregset (regcache, (const gdb_fpregset_t *) fpregs); 1972 } 1973 } 1974 1975 /* Store register REGNUM back into the inferior. If REGNUM is -1, do 1976 this for all registers. 1977 1978 NOTE: Since the /proc interface will not read individual registers, 1979 we will cache these requests until the process is resumed, and only 1980 then write them back to the inferior process. 1981 1982 FIXME: is that a really bad idea? Have to think about cases where 1983 writing one register might affect the value of others, etc. */ 1984 1985 void 1986 procfs_target::store_registers (struct regcache *regcache, int regnum) 1987 { 1988 gdb_gregset_t *gregs; 1989 procinfo *pi; 1990 ptid_t ptid = regcache->ptid (); 1991 int pid = ptid.pid (); 1992 int tid = ptid.lwp (); 1993 struct gdbarch *gdbarch = regcache->arch (); 1994 1995 pi = find_procinfo_or_die (pid, tid); 1996 1997 if (pi == NULL) 1998 error (_("procfs: store_registers: failed to find procinfo for %s"), 1999 target_pid_to_str (ptid).c_str ()); 2000 2001 gregs = proc_get_gregs (pi); 2002 if (gregs == NULL) 2003 proc_error (pi, "store_registers, get_gregs", __LINE__); 2004 2005 fill_gregset (regcache, gregs, regnum); 2006 if (!proc_set_gregs (pi)) 2007 proc_error (pi, "store_registers, set_gregs", __LINE__); 2008 2009 if (gdbarch_fp0_regnum (gdbarch) >= 0) /* Do we have an FPU? */ 2010 { 2011 gdb_fpregset_t *fpregs; 2012 2013 if ((regnum >= 0 && regnum < gdbarch_fp0_regnum (gdbarch)) 2014 || regnum == gdbarch_pc_regnum (gdbarch) 2015 || regnum == gdbarch_sp_regnum (gdbarch)) 2016 return; /* Not a floating point register. */ 2017 2018 fpregs = proc_get_fpregs (pi); 2019 if (fpregs == NULL) 2020 proc_error (pi, "store_registers, get_fpregs", __LINE__); 2021 2022 fill_fpregset (regcache, fpregs, regnum); 2023 if (!proc_set_fpregs (pi)) 2024 proc_error (pi, "store_registers, set_fpregs", __LINE__); 2025 } 2026 } 2027 2028 /* Retrieve the next stop event from the child process. If child has 2029 not stopped yet, wait for it to stop. Translate /proc eventcodes 2030 (or possibly wait eventcodes) into gdb internal event codes. 2031 Returns the id of process (and possibly thread) that incurred the 2032 event. Event codes are returned through a pointer parameter. */ 2033 2034 ptid_t 2035 procfs_target::wait (ptid_t ptid, struct target_waitstatus *status, 2036 int options) 2037 { 2038 /* First cut: loosely based on original version 2.1. */ 2039 procinfo *pi; 2040 int wstat; 2041 int temp_tid; 2042 ptid_t retval, temp_ptid; 2043 int why, what, flags; 2044 int retry = 0; 2045 2046 wait_again: 2047 2048 retry++; 2049 wstat = 0; 2050 retval = ptid_t (-1); 2051 2052 /* Find procinfo for main process. */ 2053 2054 /* procfs_target currently only supports one inferior. */ 2055 inferior *inf = current_inferior (); 2056 2057 pi = find_procinfo_or_die (inf->pid, 0); 2058 if (pi) 2059 { 2060 /* We must assume that the status is stale now... */ 2061 pi->status_valid = 0; 2062 pi->gregs_valid = 0; 2063 pi->fpregs_valid = 0; 2064 2065 #if 0 /* just try this out... */ 2066 flags = proc_flags (pi); 2067 why = proc_why (pi); 2068 if ((flags & PR_STOPPED) && (why == PR_REQUESTED)) 2069 pi->status_valid = 0; /* re-read again, IMMEDIATELY... */ 2070 #endif 2071 /* If child is not stopped, wait for it to stop. */ 2072 if (!(proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) 2073 && !proc_wait_for_stop (pi)) 2074 { 2075 /* wait_for_stop failed: has the child terminated? */ 2076 if (errno == ENOENT) 2077 { 2078 int wait_retval; 2079 2080 /* /proc file not found; presumably child has terminated. */ 2081 wait_retval = ::wait (&wstat); /* "wait" for the child's exit. */ 2082 2083 /* Wrong child? */ 2084 if (wait_retval != inf->pid) 2085 error (_("procfs: couldn't stop " 2086 "process %d: wait returned %d."), 2087 inf->pid, wait_retval); 2088 /* FIXME: might I not just use waitpid? 2089 Or try find_procinfo to see if I know about this child? */ 2090 retval = ptid_t (wait_retval); 2091 } 2092 else if (errno == EINTR) 2093 goto wait_again; 2094 else 2095 { 2096 /* Unknown error from wait_for_stop. */ 2097 proc_error (pi, "target_wait (wait_for_stop)", __LINE__); 2098 } 2099 } 2100 else 2101 { 2102 /* This long block is reached if either: 2103 a) the child was already stopped, or 2104 b) we successfully waited for the child with wait_for_stop. 2105 This block will analyze the /proc status, and translate it 2106 into a waitstatus for GDB. 2107 2108 If we actually had to call wait because the /proc file 2109 is gone (child terminated), then we skip this block, 2110 because we already have a waitstatus. */ 2111 2112 flags = proc_flags (pi); 2113 why = proc_why (pi); 2114 what = proc_what (pi); 2115 2116 if (flags & (PR_STOPPED | PR_ISTOP)) 2117 { 2118 /* If it's running async (for single_thread control), 2119 set it back to normal again. */ 2120 if (flags & PR_ASYNC) 2121 if (!proc_unset_async (pi)) 2122 proc_error (pi, "target_wait, unset_async", __LINE__); 2123 2124 if (info_verbose) 2125 proc_prettyprint_why (why, what, 1); 2126 2127 /* The 'pid' we will return to GDB is composed of 2128 the process ID plus the lwp ID. */ 2129 retval = ptid_t (pi->pid, proc_get_current_thread (pi), 0); 2130 2131 switch (why) { 2132 case PR_SIGNALLED: 2133 wstat = (what << 8) | 0177; 2134 break; 2135 case PR_SYSENTRY: 2136 if (what == SYS_lwp_exit) 2137 { 2138 if (print_thread_events) 2139 printf_unfiltered (_("[%s exited]\n"), 2140 target_pid_to_str (retval).c_str ()); 2141 delete_thread (find_thread_ptid (this, retval)); 2142 target_continue_no_signal (ptid); 2143 goto wait_again; 2144 } 2145 else if (what == SYS_exit) 2146 { 2147 /* Handle SYS_exit call only. */ 2148 /* Stopped at entry to SYS_exit. 2149 Make it runnable, resume it, then use 2150 the wait system call to get its exit code. 2151 Proc_run_process always clears the current 2152 fault and signal. 2153 Then return its exit status. */ 2154 pi->status_valid = 0; 2155 wstat = 0; 2156 /* FIXME: what we should do is return 2157 TARGET_WAITKIND_SPURIOUS. */ 2158 if (!proc_run_process (pi, 0, 0)) 2159 proc_error (pi, "target_wait, run_process", __LINE__); 2160 2161 if (inf->attach_flag) 2162 { 2163 /* Don't call wait: simulate waiting for exit, 2164 return a "success" exit code. Bogus: what if 2165 it returns something else? */ 2166 wstat = 0; 2167 retval = ptid_t (inf->pid); /* ? ? ? */ 2168 } 2169 else 2170 { 2171 int temp = ::wait (&wstat); 2172 2173 /* FIXME: shouldn't I make sure I get the right 2174 event from the right process? If (for 2175 instance) I have killed an earlier inferior 2176 process but failed to clean up after it 2177 somehow, I could get its termination event 2178 here. */ 2179 2180 /* If wait returns -1, that's what we return 2181 to GDB. */ 2182 if (temp < 0) 2183 retval = ptid_t (temp); 2184 } 2185 } 2186 else 2187 { 2188 printf_filtered (_("procfs: trapped on entry to ")); 2189 proc_prettyprint_syscall (proc_what (pi), 0); 2190 printf_filtered ("\n"); 2191 2192 long i, nsysargs, *sysargs; 2193 2194 nsysargs = proc_nsysarg (pi); 2195 sysargs = proc_sysargs (pi); 2196 2197 if (nsysargs > 0 && sysargs != NULL) 2198 { 2199 printf_filtered (_("%ld syscall arguments:\n"), 2200 nsysargs); 2201 for (i = 0; i < nsysargs; i++) 2202 printf_filtered ("#%ld: 0x%08lx\n", 2203 i, sysargs[i]); 2204 } 2205 2206 /* How to keep going without returning to wfi: */ 2207 target_continue_no_signal (ptid); 2208 goto wait_again; 2209 } 2210 break; 2211 case PR_SYSEXIT: 2212 if (what == SYS_execve) 2213 { 2214 /* Hopefully this is our own "fork-child" execing 2215 the real child. Hoax this event into a trap, and 2216 GDB will see the child about to execute its start 2217 address. */ 2218 wstat = (SIGTRAP << 8) | 0177; 2219 } 2220 else if (what == SYS_lwp_create) 2221 { 2222 /* This syscall is somewhat like fork/exec. We 2223 will get the event twice: once for the parent 2224 LWP, and once for the child. We should already 2225 know about the parent LWP, but the child will 2226 be new to us. So, whenever we get this event, 2227 if it represents a new thread, simply add the 2228 thread to the list. */ 2229 2230 /* If not in procinfo list, add it. */ 2231 temp_tid = proc_get_current_thread (pi); 2232 if (!find_procinfo (pi->pid, temp_tid)) 2233 create_procinfo (pi->pid, temp_tid); 2234 2235 temp_ptid = ptid_t (pi->pid, temp_tid, 0); 2236 /* If not in GDB's thread list, add it. */ 2237 if (!in_thread_list (this, temp_ptid)) 2238 add_thread (this, temp_ptid); 2239 2240 target_continue_no_signal (ptid); 2241 goto wait_again; 2242 } 2243 else if (what == SYS_lwp_exit) 2244 { 2245 if (print_thread_events) 2246 printf_unfiltered (_("[%s exited]\n"), 2247 target_pid_to_str (retval).c_str ()); 2248 delete_thread (find_thread_ptid (this, retval)); 2249 status->kind = TARGET_WAITKIND_SPURIOUS; 2250 return retval; 2251 } 2252 else 2253 { 2254 printf_filtered (_("procfs: trapped on exit from ")); 2255 proc_prettyprint_syscall (proc_what (pi), 0); 2256 printf_filtered ("\n"); 2257 2258 long i, nsysargs, *sysargs; 2259 2260 nsysargs = proc_nsysarg (pi); 2261 sysargs = proc_sysargs (pi); 2262 2263 if (nsysargs > 0 && sysargs != NULL) 2264 { 2265 printf_filtered (_("%ld syscall arguments:\n"), 2266 nsysargs); 2267 for (i = 0; i < nsysargs; i++) 2268 printf_filtered ("#%ld: 0x%08lx\n", 2269 i, sysargs[i]); 2270 } 2271 2272 target_continue_no_signal (ptid); 2273 goto wait_again; 2274 } 2275 break; 2276 case PR_REQUESTED: 2277 #if 0 /* FIXME */ 2278 wstat = (SIGSTOP << 8) | 0177; 2279 break; 2280 #else 2281 if (retry < 5) 2282 { 2283 printf_filtered (_("Retry #%d:\n"), retry); 2284 pi->status_valid = 0; 2285 goto wait_again; 2286 } 2287 else 2288 { 2289 /* If not in procinfo list, add it. */ 2290 temp_tid = proc_get_current_thread (pi); 2291 if (!find_procinfo (pi->pid, temp_tid)) 2292 create_procinfo (pi->pid, temp_tid); 2293 2294 /* If not in GDB's thread list, add it. */ 2295 temp_ptid = ptid_t (pi->pid, temp_tid, 0); 2296 if (!in_thread_list (this, temp_ptid)) 2297 add_thread (this, temp_ptid); 2298 2299 status->kind = TARGET_WAITKIND_STOPPED; 2300 status->value.sig = GDB_SIGNAL_0; 2301 return retval; 2302 } 2303 #endif 2304 case PR_JOBCONTROL: 2305 wstat = (what << 8) | 0177; 2306 break; 2307 case PR_FAULTED: 2308 { 2309 int signo = pi->prstatus.pr_lwp.pr_info.si_signo; 2310 if (signo != 0) 2311 wstat = (signo << 8) | 0177; 2312 } 2313 break; 2314 default: /* switch (why) unmatched */ 2315 printf_filtered ("procfs:%d -- ", __LINE__); 2316 printf_filtered (_("child stopped for unknown reason:\n")); 2317 proc_prettyprint_why (why, what, 1); 2318 error (_("... giving up...")); 2319 break; 2320 } 2321 /* Got this far without error: If retval isn't in the 2322 threads database, add it. */ 2323 if (retval.pid () > 0 2324 && !in_thread_list (this, retval)) 2325 { 2326 /* We have a new thread. We need to add it both to 2327 GDB's list and to our own. If we don't create a 2328 procinfo, resume may be unhappy later. */ 2329 add_thread (this, retval); 2330 if (find_procinfo (retval.pid (), 2331 retval.lwp ()) == NULL) 2332 create_procinfo (retval.pid (), 2333 retval.lwp ()); 2334 } 2335 } 2336 else /* Flags do not indicate STOPPED. */ 2337 { 2338 /* surely this can't happen... */ 2339 printf_filtered ("procfs:%d -- process not stopped.\n", 2340 __LINE__); 2341 proc_prettyprint_flags (flags, 1); 2342 error (_("procfs: ...giving up...")); 2343 } 2344 } 2345 2346 if (status) 2347 store_waitstatus (status, wstat); 2348 } 2349 2350 return retval; 2351 } 2352 2353 /* Perform a partial transfer to/from the specified object. For 2354 memory transfers, fall back to the old memory xfer functions. */ 2355 2356 enum target_xfer_status 2357 procfs_target::xfer_partial (enum target_object object, 2358 const char *annex, gdb_byte *readbuf, 2359 const gdb_byte *writebuf, ULONGEST offset, 2360 ULONGEST len, ULONGEST *xfered_len) 2361 { 2362 switch (object) 2363 { 2364 case TARGET_OBJECT_MEMORY: 2365 return procfs_xfer_memory (readbuf, writebuf, offset, len, xfered_len); 2366 2367 case TARGET_OBJECT_AUXV: 2368 return memory_xfer_auxv (this, object, annex, readbuf, writebuf, 2369 offset, len, xfered_len); 2370 2371 default: 2372 return this->beneath ()->xfer_partial (object, annex, 2373 readbuf, writebuf, offset, len, 2374 xfered_len); 2375 } 2376 } 2377 2378 /* Helper for procfs_xfer_partial that handles memory transfers. 2379 Arguments are like target_xfer_partial. */ 2380 2381 static enum target_xfer_status 2382 procfs_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf, 2383 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len) 2384 { 2385 procinfo *pi; 2386 int nbytes; 2387 2388 /* Find procinfo for main process. */ 2389 pi = find_procinfo_or_die (inferior_ptid.pid (), 0); 2390 if (pi->as_fd == 0 && open_procinfo_files (pi, FD_AS) == 0) 2391 { 2392 proc_warn (pi, "xfer_memory, open_proc_files", __LINE__); 2393 return TARGET_XFER_E_IO; 2394 } 2395 2396 if (lseek (pi->as_fd, (off_t) memaddr, SEEK_SET) != (off_t) memaddr) 2397 return TARGET_XFER_E_IO; 2398 2399 if (writebuf != NULL) 2400 { 2401 PROCFS_NOTE ("write memory:\n"); 2402 nbytes = write (pi->as_fd, writebuf, len); 2403 } 2404 else 2405 { 2406 PROCFS_NOTE ("read memory:\n"); 2407 nbytes = read (pi->as_fd, readbuf, len); 2408 } 2409 if (nbytes <= 0) 2410 return TARGET_XFER_E_IO; 2411 *xfered_len = nbytes; 2412 return TARGET_XFER_OK; 2413 } 2414 2415 /* Called by target_resume before making child runnable. Mark cached 2416 registers and status's invalid. If there are "dirty" caches that 2417 need to be written back to the child process, do that. 2418 2419 File descriptors are also cached. As they are a limited resource, 2420 we cannot hold onto them indefinitely. However, as they are 2421 expensive to open, we don't want to throw them away 2422 indiscriminately either. As a compromise, we will keep the file 2423 descriptors for the parent process, but discard any file 2424 descriptors we may have accumulated for the threads. 2425 2426 As this function is called by iterate_over_threads, it always 2427 returns zero (so that iterate_over_threads will keep 2428 iterating). */ 2429 2430 static int 2431 invalidate_cache (procinfo *parent, procinfo *pi, void *ptr) 2432 { 2433 /* About to run the child; invalidate caches and do any other 2434 cleanup. */ 2435 2436 if (parent != NULL) 2437 { 2438 /* The presence of a parent indicates that this is an LWP. 2439 Close any file descriptors that it might have open. 2440 We don't do this to the master (parent) procinfo. */ 2441 2442 close_procinfo_files (pi); 2443 } 2444 pi->gregs_valid = 0; 2445 pi->fpregs_valid = 0; 2446 pi->status_valid = 0; 2447 pi->threads_valid = 0; 2448 2449 return 0; 2450 } 2451 2452 /* Make the child process runnable. Normally we will then call 2453 procfs_wait and wait for it to stop again (unless gdb is async). 2454 2455 If STEP is true, then arrange for the child to stop again after 2456 executing a single instruction. If SIGNO is zero, then cancel any 2457 pending signal; if non-zero, then arrange for the indicated signal 2458 to be delivered to the child when it runs. If PID is -1, then 2459 allow any child thread to run; if non-zero, then allow only the 2460 indicated thread to run. (not implemented yet). */ 2461 2462 void 2463 procfs_target::resume (ptid_t ptid, int step, enum gdb_signal signo) 2464 { 2465 procinfo *pi, *thread; 2466 int native_signo; 2467 2468 /* FIXME: Check/reword. */ 2469 2470 /* prrun.prflags |= PRCFAULT; clear current fault. 2471 PRCFAULT may be replaced by a PCCFAULT call (proc_clear_current_fault) 2472 This basically leaves PRSTEP and PRCSIG. 2473 PRCSIG is like PCSSIG (proc_clear_current_signal). 2474 So basically PR_STEP is the sole argument that must be passed 2475 to proc_run_process. */ 2476 2477 /* Find procinfo for main process. */ 2478 pi = find_procinfo_or_die (inferior_ptid.pid (), 0); 2479 2480 /* First cut: ignore pid argument. */ 2481 errno = 0; 2482 2483 /* Convert signal to host numbering. */ 2484 if (signo == 0 || (signo == GDB_SIGNAL_STOP && pi->ignore_next_sigstop)) 2485 native_signo = 0; 2486 else 2487 native_signo = gdb_signal_to_host (signo); 2488 2489 pi->ignore_next_sigstop = 0; 2490 2491 /* Running the process voids all cached registers and status. */ 2492 /* Void the threads' caches first. */ 2493 proc_iterate_over_threads (pi, invalidate_cache, NULL); 2494 /* Void the process procinfo's caches. */ 2495 invalidate_cache (NULL, pi, NULL); 2496 2497 if (ptid.pid () != -1) 2498 { 2499 /* Resume a specific thread, presumably suppressing the 2500 others. */ 2501 thread = find_procinfo (ptid.pid (), ptid.lwp ()); 2502 if (thread != NULL) 2503 { 2504 if (thread->tid != 0) 2505 { 2506 /* We're to resume a specific thread, and not the 2507 others. Set the child process's PR_ASYNC flag. */ 2508 if (!proc_set_async (pi)) 2509 proc_error (pi, "target_resume, set_async", __LINE__); 2510 pi = thread; /* Substitute the thread's procinfo 2511 for run. */ 2512 } 2513 } 2514 } 2515 2516 if (!proc_run_process (pi, step, native_signo)) 2517 { 2518 if (errno == EBUSY) 2519 warning (_("resume: target already running. " 2520 "Pretend to resume, and hope for the best!")); 2521 else 2522 proc_error (pi, "target_resume", __LINE__); 2523 } 2524 } 2525 2526 /* Set up to trace signals in the child process. */ 2527 2528 void 2529 procfs_target::pass_signals (gdb::array_view<const unsigned char> pass_signals) 2530 { 2531 sigset_t signals; 2532 procinfo *pi = find_procinfo_or_die (inferior_ptid.pid (), 0); 2533 int signo; 2534 2535 prfillset (&signals); 2536 2537 for (signo = 0; signo < NSIG; signo++) 2538 { 2539 int target_signo = gdb_signal_from_host (signo); 2540 if (target_signo < pass_signals.size () && pass_signals[target_signo]) 2541 prdelset (&signals, signo); 2542 } 2543 2544 if (!proc_set_traced_signals (pi, &signals)) 2545 proc_error (pi, "pass_signals", __LINE__); 2546 } 2547 2548 /* Print status information about the child process. */ 2549 2550 void 2551 procfs_target::files_info () 2552 { 2553 struct inferior *inf = current_inferior (); 2554 2555 printf_filtered (_("\tUsing the running image of %s %s via /proc.\n"), 2556 inf->attach_flag? "attached": "child", 2557 target_pid_to_str (inferior_ptid).c_str ()); 2558 } 2559 2560 /* Make it die. Wait for it to die. Clean up after it. Note: this 2561 should only be applied to the real process, not to an LWP, because 2562 of the check for parent-process. If we need this to work for an 2563 LWP, it needs some more logic. */ 2564 2565 static void 2566 unconditionally_kill_inferior (procinfo *pi) 2567 { 2568 int parent_pid; 2569 2570 parent_pid = proc_parent_pid (pi); 2571 if (!proc_kill (pi, SIGKILL)) 2572 proc_error (pi, "unconditionally_kill, proc_kill", __LINE__); 2573 destroy_procinfo (pi); 2574 2575 /* If pi is GDB's child, wait for it to die. */ 2576 if (parent_pid == getpid ()) 2577 /* FIXME: should we use waitpid to make sure we get the right event? 2578 Should we check the returned event? */ 2579 { 2580 #if 0 2581 int status, ret; 2582 2583 ret = waitpid (pi->pid, &status, 0); 2584 #else 2585 wait (NULL); 2586 #endif 2587 } 2588 } 2589 2590 /* We're done debugging it, and we want it to go away. Then we want 2591 GDB to forget all about it. */ 2592 2593 void 2594 procfs_target::kill () 2595 { 2596 if (inferior_ptid != null_ptid) /* ? */ 2597 { 2598 /* Find procinfo for main process. */ 2599 procinfo *pi = find_procinfo (inferior_ptid.pid (), 0); 2600 2601 if (pi) 2602 unconditionally_kill_inferior (pi); 2603 target_mourn_inferior (inferior_ptid); 2604 } 2605 } 2606 2607 /* Forget we ever debugged this thing! */ 2608 2609 void 2610 procfs_target::mourn_inferior () 2611 { 2612 procinfo *pi; 2613 2614 if (inferior_ptid != null_ptid) 2615 { 2616 /* Find procinfo for main process. */ 2617 pi = find_procinfo (inferior_ptid.pid (), 0); 2618 if (pi) 2619 destroy_procinfo (pi); 2620 } 2621 2622 generic_mourn_inferior (); 2623 2624 maybe_unpush_target (); 2625 } 2626 2627 /* When GDB forks to create a runnable inferior process, this function 2628 is called on the parent side of the fork. It's job is to do 2629 whatever is necessary to make the child ready to be debugged, and 2630 then wait for the child to synchronize. */ 2631 2632 void 2633 procfs_target::procfs_init_inferior (int pid) 2634 { 2635 procinfo *pi; 2636 int fail; 2637 int lwpid; 2638 2639 pi = create_procinfo (pid, 0); 2640 if (pi == NULL) 2641 perror (_("procfs: out of memory in 'init_inferior'")); 2642 2643 if (!open_procinfo_files (pi, FD_CTL)) 2644 proc_error (pi, "init_inferior, open_proc_files", __LINE__); 2645 2646 /* 2647 xmalloc // done 2648 open_procinfo_files // done 2649 link list // done 2650 prfillset (trace) 2651 procfs_notice_signals 2652 prfillset (fault) 2653 prdelset (FLTPAGE) 2654 */ 2655 2656 /* If not stopped yet, wait for it to stop. */ 2657 if (!(proc_flags (pi) & PR_STOPPED) && !(proc_wait_for_stop (pi))) 2658 dead_procinfo (pi, "init_inferior: wait_for_stop failed", KILL); 2659 2660 /* Save some of the /proc state to be restored if we detach. */ 2661 /* FIXME: Why? In case another debugger was debugging it? 2662 We're it's parent, for Ghu's sake! */ 2663 if (!proc_get_traced_signals (pi, &pi->saved_sigset)) 2664 proc_error (pi, "init_inferior, get_traced_signals", __LINE__); 2665 if (!proc_get_held_signals (pi, &pi->saved_sighold)) 2666 proc_error (pi, "init_inferior, get_held_signals", __LINE__); 2667 if (!proc_get_traced_faults (pi, &pi->saved_fltset)) 2668 proc_error (pi, "init_inferior, get_traced_faults", __LINE__); 2669 if (!proc_get_traced_sysentry (pi, pi->saved_entryset)) 2670 proc_error (pi, "init_inferior, get_traced_sysentry", __LINE__); 2671 if (!proc_get_traced_sysexit (pi, pi->saved_exitset)) 2672 proc_error (pi, "init_inferior, get_traced_sysexit", __LINE__); 2673 2674 fail = procfs_debug_inferior (pi); 2675 if (fail != 0) 2676 proc_error (pi, "init_inferior (procfs_debug_inferior)", fail); 2677 2678 /* FIXME: logically, we should really be turning OFF run-on-last-close, 2679 and possibly even turning ON kill-on-last-close at this point. But 2680 I can't make that change without careful testing which I don't have 2681 time to do right now... */ 2682 /* Turn on run-on-last-close flag so that the child 2683 will die if GDB goes away for some reason. */ 2684 if (!proc_set_run_on_last_close (pi)) 2685 proc_error (pi, "init_inferior, set_RLC", __LINE__); 2686 2687 /* We now have have access to the lwpid of the main thread/lwp. */ 2688 lwpid = proc_get_current_thread (pi); 2689 2690 /* Create a procinfo for the main lwp. */ 2691 create_procinfo (pid, lwpid); 2692 2693 /* We already have a main thread registered in the thread table at 2694 this point, but it didn't have any lwp info yet. Notify the core 2695 about it. This changes inferior_ptid as well. */ 2696 thread_change_ptid (this, ptid_t (pid), ptid_t (pid, lwpid, 0)); 2697 2698 gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED); 2699 } 2700 2701 /* When GDB forks to create a new process, this function is called on 2702 the child side of the fork before GDB exec's the user program. Its 2703 job is to make the child minimally debuggable, so that the parent 2704 GDB process can connect to the child and take over. This function 2705 should do only the minimum to make that possible, and to 2706 synchronize with the parent process. The parent process should 2707 take care of the details. */ 2708 2709 static void 2710 procfs_set_exec_trap (void) 2711 { 2712 /* This routine called on the child side (inferior side) 2713 after GDB forks the inferior. It must use only local variables, 2714 because it may be sharing data space with its parent. */ 2715 2716 procinfo *pi; 2717 sysset_t *exitset; 2718 2719 pi = create_procinfo (getpid (), 0); 2720 if (pi == NULL) 2721 perror_with_name (_("procfs: create_procinfo failed in child.")); 2722 2723 if (open_procinfo_files (pi, FD_CTL) == 0) 2724 { 2725 proc_warn (pi, "set_exec_trap, open_proc_files", __LINE__); 2726 gdb_flush (gdb_stderr); 2727 /* No need to call "dead_procinfo", because we're going to 2728 exit. */ 2729 _exit (127); 2730 } 2731 2732 exitset = XNEW (sysset_t); 2733 premptyset (exitset); 2734 praddset (exitset, SYS_execve); 2735 2736 if (!proc_set_traced_sysexit (pi, exitset)) 2737 { 2738 proc_warn (pi, "set_exec_trap, set_traced_sysexit", __LINE__); 2739 gdb_flush (gdb_stderr); 2740 _exit (127); 2741 } 2742 2743 /* FIXME: should this be done in the parent instead? */ 2744 /* Turn off inherit on fork flag so that all grand-children 2745 of gdb start with tracing flags cleared. */ 2746 if (!proc_unset_inherit_on_fork (pi)) 2747 proc_warn (pi, "set_exec_trap, unset_inherit", __LINE__); 2748 2749 /* Turn off run on last close flag, so that the child process 2750 cannot run away just because we close our handle on it. 2751 We want it to wait for the parent to attach. */ 2752 if (!proc_unset_run_on_last_close (pi)) 2753 proc_warn (pi, "set_exec_trap, unset_RLC", __LINE__); 2754 2755 /* FIXME: No need to destroy the procinfo -- 2756 we have our own address space, and we're about to do an exec! */ 2757 /*destroy_procinfo (pi);*/ 2758 } 2759 2760 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). 2761 This avoids a possible deadlock gdb and its vfork'ed child. */ 2762 static void 2763 procfs_pre_trace (void) 2764 { 2765 } 2766 2767 /* This function is called BEFORE gdb forks the inferior process. Its 2768 only real responsibility is to set things up for the fork, and tell 2769 GDB which two functions to call after the fork (one for the parent, 2770 and one for the child). 2771 2772 This function does a complicated search for a unix shell program, 2773 which it then uses to parse arguments and environment variables to 2774 be sent to the child. I wonder whether this code could not be 2775 abstracted out and shared with other unix targets such as 2776 inf-ptrace? */ 2777 2778 void 2779 procfs_target::create_inferior (const char *exec_file, 2780 const std::string &allargs, 2781 char **env, int from_tty) 2782 { 2783 const char *shell_file = get_shell (); 2784 char *tryname; 2785 int pid; 2786 2787 if (strchr (shell_file, '/') == NULL) 2788 { 2789 2790 /* We will be looking down the PATH to find shell_file. If we 2791 just do this the normal way (via execlp, which operates by 2792 attempting an exec for each element of the PATH until it 2793 finds one which succeeds), then there will be an exec for 2794 each failed attempt, each of which will cause a PR_SYSEXIT 2795 stop, and we won't know how to distinguish the PR_SYSEXIT's 2796 for these failed execs with the ones for successful execs 2797 (whether the exec has succeeded is stored at that time in the 2798 carry bit or some such architecture-specific and 2799 non-ABI-specified place). 2800 2801 So I can't think of anything better than to search the PATH 2802 now. This has several disadvantages: (1) There is a race 2803 condition; if we find a file now and it is deleted before we 2804 exec it, we lose, even if the deletion leaves a valid file 2805 further down in the PATH, (2) there is no way to know exactly 2806 what an executable (in the sense of "capable of being 2807 exec'd") file is. Using access() loses because it may lose 2808 if the caller is the superuser; failing to use it loses if 2809 there are ACLs or some such. */ 2810 2811 const char *p; 2812 const char *p1; 2813 /* FIXME-maybe: might want "set path" command so user can change what 2814 path is used from within GDB. */ 2815 const char *path = getenv ("PATH"); 2816 int len; 2817 struct stat statbuf; 2818 2819 if (path == NULL) 2820 path = "/bin:/usr/bin"; 2821 2822 tryname = (char *) alloca (strlen (path) + strlen (shell_file) + 2); 2823 for (p = path; p != NULL; p = p1 ? p1 + 1: NULL) 2824 { 2825 p1 = strchr (p, ':'); 2826 if (p1 != NULL) 2827 len = p1 - p; 2828 else 2829 len = strlen (p); 2830 strncpy (tryname, p, len); 2831 tryname[len] = '\0'; 2832 strcat (tryname, "/"); 2833 strcat (tryname, shell_file); 2834 if (access (tryname, X_OK) < 0) 2835 continue; 2836 if (stat (tryname, &statbuf) < 0) 2837 continue; 2838 if (!S_ISREG (statbuf.st_mode)) 2839 /* We certainly need to reject directories. I'm not quite 2840 as sure about FIFOs, sockets, etc., but I kind of doubt 2841 that people want to exec() these things. */ 2842 continue; 2843 break; 2844 } 2845 if (p == NULL) 2846 /* Not found. This must be an error rather than merely passing 2847 the file to execlp(), because execlp() would try all the 2848 exec()s, causing GDB to get confused. */ 2849 error (_("procfs:%d -- Can't find shell %s in PATH"), 2850 __LINE__, shell_file); 2851 2852 shell_file = tryname; 2853 } 2854 2855 if (!target_is_pushed (this)) 2856 push_target (this); 2857 2858 pid = fork_inferior (exec_file, allargs, env, procfs_set_exec_trap, 2859 NULL, procfs_pre_trace, shell_file, NULL); 2860 2861 /* We have something that executes now. We'll be running through 2862 the shell at this point (if startup-with-shell is true), but the 2863 pid shouldn't change. */ 2864 thread_info *thr = add_thread_silent (this, ptid_t (pid)); 2865 switch_to_thread (thr); 2866 2867 procfs_init_inferior (pid); 2868 } 2869 2870 /* An observer for the "inferior_created" event. */ 2871 2872 static void 2873 procfs_inferior_created (struct target_ops *ops, int from_tty) 2874 { 2875 } 2876 2877 /* Callback for update_thread_list. Calls "add_thread". */ 2878 2879 static int 2880 procfs_notice_thread (procinfo *pi, procinfo *thread, void *ptr) 2881 { 2882 ptid_t gdb_threadid = ptid_t (pi->pid, thread->tid, 0); 2883 2884 thread_info *thr = find_thread_ptid (&the_procfs_target, gdb_threadid); 2885 if (thr == NULL || thr->state == THREAD_EXITED) 2886 add_thread (&the_procfs_target, gdb_threadid); 2887 2888 return 0; 2889 } 2890 2891 /* Query all the threads that the target knows about, and give them 2892 back to GDB to add to its list. */ 2893 2894 void 2895 procfs_target::update_thread_list () 2896 { 2897 procinfo *pi; 2898 2899 prune_threads (); 2900 2901 /* Find procinfo for main process. */ 2902 pi = find_procinfo_or_die (inferior_ptid.pid (), 0); 2903 proc_update_threads (pi); 2904 proc_iterate_over_threads (pi, procfs_notice_thread, NULL); 2905 } 2906 2907 /* Return true if the thread is still 'alive'. This guy doesn't 2908 really seem to be doing his job. Got to investigate how to tell 2909 when a thread is really gone. */ 2910 2911 bool 2912 procfs_target::thread_alive (ptid_t ptid) 2913 { 2914 int proc, thread; 2915 procinfo *pi; 2916 2917 proc = ptid.pid (); 2918 thread = ptid.lwp (); 2919 /* If I don't know it, it ain't alive! */ 2920 pi = find_procinfo (proc, thread); 2921 if (pi == NULL) 2922 return false; 2923 2924 /* If I can't get its status, it ain't alive! 2925 What's more, I need to forget about it! */ 2926 if (!proc_get_status (pi)) 2927 { 2928 destroy_procinfo (pi); 2929 return false; 2930 } 2931 /* I couldn't have got its status if it weren't alive, so it's 2932 alive. */ 2933 return true; 2934 } 2935 2936 /* Convert PTID to a string. */ 2937 2938 std::string 2939 procfs_target::pid_to_str (ptid_t ptid) 2940 { 2941 if (ptid.lwp () == 0) 2942 return string_printf ("process %d", ptid.pid ()); 2943 else 2944 return string_printf ("LWP %ld", ptid.lwp ()); 2945 } 2946 2947 /* Accepts an integer PID; Returns a string representing a file that 2948 can be opened to get the symbols for the child process. */ 2949 2950 char * 2951 procfs_target::pid_to_exec_file (int pid) 2952 { 2953 static char buf[PATH_MAX]; 2954 char name[PATH_MAX]; 2955 2956 /* Solaris 11 introduced /proc/<proc-id>/execname. */ 2957 xsnprintf (name, sizeof (name), "/proc/%d/execname", pid); 2958 scoped_fd fd (gdb_open_cloexec (name, O_RDONLY, 0)); 2959 if (fd.get () < 0 || read (fd.get (), buf, PATH_MAX - 1) < 0) 2960 { 2961 /* If that fails, fall back to /proc/<proc-id>/path/a.out introduced in 2962 Solaris 10. */ 2963 ssize_t len; 2964 2965 xsnprintf (name, sizeof (name), "/proc/%d/path/a.out", pid); 2966 len = readlink (name, buf, PATH_MAX - 1); 2967 if (len <= 0) 2968 strcpy (buf, name); 2969 else 2970 buf[len] = '\0'; 2971 } 2972 2973 return buf; 2974 } 2975 2976 /* Insert a watchpoint. */ 2977 2978 static int 2979 procfs_set_watchpoint (ptid_t ptid, CORE_ADDR addr, int len, int rwflag, 2980 int after) 2981 { 2982 int pflags = 0; 2983 procinfo *pi; 2984 2985 pi = find_procinfo_or_die (ptid.pid () == -1 ? 2986 inferior_ptid.pid () : ptid.pid (), 2987 0); 2988 2989 /* Translate from GDB's flags to /proc's. */ 2990 if (len > 0) /* len == 0 means delete watchpoint. */ 2991 { 2992 switch (rwflag) { /* FIXME: need an enum! */ 2993 case hw_write: /* default watchpoint (write) */ 2994 pflags = WA_WRITE; 2995 break; 2996 case hw_read: /* read watchpoint */ 2997 pflags = WA_READ; 2998 break; 2999 case hw_access: /* access watchpoint */ 3000 pflags = WA_READ | WA_WRITE; 3001 break; 3002 case hw_execute: /* execution HW breakpoint */ 3003 pflags = WA_EXEC; 3004 break; 3005 default: /* Something weird. Return error. */ 3006 return -1; 3007 } 3008 if (after) /* Stop after r/w access is completed. */ 3009 pflags |= WA_TRAPAFTER; 3010 } 3011 3012 if (!proc_set_watchpoint (pi, addr, len, pflags)) 3013 { 3014 if (errno == E2BIG) /* Typical error for no resources. */ 3015 return -1; /* fail */ 3016 /* GDB may try to remove the same watchpoint twice. 3017 If a remove request returns no match, don't error. */ 3018 if (errno == ESRCH && len == 0) 3019 return 0; /* ignore */ 3020 proc_error (pi, "set_watchpoint", __LINE__); 3021 } 3022 return 0; 3023 } 3024 3025 /* Return non-zero if we can set a hardware watchpoint of type TYPE. TYPE 3026 is one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint, 3027 or bp_hardware_watchpoint. CNT is the number of watchpoints used so 3028 far. */ 3029 3030 int 3031 procfs_target::can_use_hw_breakpoint (enum bptype type, int cnt, int othertype) 3032 { 3033 /* Due to the way that proc_set_watchpoint() is implemented, host 3034 and target pointers must be of the same size. If they are not, 3035 we can't use hardware watchpoints. This limitation is due to the 3036 fact that proc_set_watchpoint() calls 3037 procfs_address_to_host_pointer(); a close inspection of 3038 procfs_address_to_host_pointer will reveal that an internal error 3039 will be generated when the host and target pointer sizes are 3040 different. */ 3041 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; 3042 3043 if (sizeof (void *) != TYPE_LENGTH (ptr_type)) 3044 return 0; 3045 3046 /* Other tests here??? */ 3047 3048 return 1; 3049 } 3050 3051 /* Returns non-zero if process is stopped on a hardware watchpoint 3052 fault, else returns zero. */ 3053 3054 bool 3055 procfs_target::stopped_by_watchpoint () 3056 { 3057 procinfo *pi; 3058 3059 pi = find_procinfo_or_die (inferior_ptid.pid (), 0); 3060 3061 if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) 3062 if (proc_why (pi) == PR_FAULTED) 3063 if (proc_what (pi) == FLTWATCH) 3064 return true; 3065 return false; 3066 } 3067 3068 /* Returns 1 if the OS knows the position of the triggered watchpoint, 3069 and sets *ADDR to that address. Returns 0 if OS cannot report that 3070 address. This function is only called if 3071 procfs_stopped_by_watchpoint returned 1, thus no further checks are 3072 done. The function also assumes that ADDR is not NULL. */ 3073 3074 bool 3075 procfs_target::stopped_data_address (CORE_ADDR *addr) 3076 { 3077 procinfo *pi; 3078 3079 pi = find_procinfo_or_die (inferior_ptid.pid (), 0); 3080 return proc_watchpoint_address (pi, addr); 3081 } 3082 3083 int 3084 procfs_target::insert_watchpoint (CORE_ADDR addr, int len, 3085 enum target_hw_bp_type type, 3086 struct expression *cond) 3087 { 3088 if (!target_have_steppable_watchpoint 3089 && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch ())) 3090 /* When a hardware watchpoint fires off the PC will be left at 3091 the instruction following the one which caused the 3092 watchpoint. It will *NOT* be necessary for GDB to step over 3093 the watchpoint. */ 3094 return procfs_set_watchpoint (inferior_ptid, addr, len, type, 1); 3095 else 3096 /* When a hardware watchpoint fires off the PC will be left at 3097 the instruction which caused the watchpoint. It will be 3098 necessary for GDB to step over the watchpoint. */ 3099 return procfs_set_watchpoint (inferior_ptid, addr, len, type, 0); 3100 } 3101 3102 int 3103 procfs_target::remove_watchpoint (CORE_ADDR addr, int len, 3104 enum target_hw_bp_type type, 3105 struct expression *cond) 3106 { 3107 return procfs_set_watchpoint (inferior_ptid, addr, 0, 0, 0); 3108 } 3109 3110 int 3111 procfs_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len) 3112 { 3113 /* The man page for proc(4) on Solaris 2.6 and up says that the 3114 system can support "thousands" of hardware watchpoints, but gives 3115 no method for finding out how many; It doesn't say anything about 3116 the allowed size for the watched area either. So we just tell 3117 GDB 'yes'. */ 3118 return 1; 3119 } 3120 3121 /* Memory Mappings Functions: */ 3122 3123 /* Call a callback function once for each mapping, passing it the 3124 mapping, an optional secondary callback function, and some optional 3125 opaque data. Quit and return the first non-zero value returned 3126 from the callback. 3127 3128 PI is the procinfo struct for the process to be mapped. FUNC is 3129 the callback function to be called by this iterator. DATA is the 3130 optional opaque data to be passed to the callback function. 3131 CHILD_FUNC is the optional secondary function pointer to be passed 3132 to the child function. Returns the first non-zero return value 3133 from the callback function, or zero. */ 3134 3135 static int 3136 iterate_over_mappings (procinfo *pi, find_memory_region_ftype child_func, 3137 void *data, 3138 int (*func) (struct prmap *map, 3139 find_memory_region_ftype child_func, 3140 void *data)) 3141 { 3142 char pathname[MAX_PROC_NAME_SIZE]; 3143 struct prmap *prmaps; 3144 struct prmap *prmap; 3145 int funcstat; 3146 int nmap; 3147 struct stat sbuf; 3148 3149 /* Get the number of mappings, allocate space, 3150 and read the mappings into prmaps. */ 3151 /* Open map fd. */ 3152 xsnprintf (pathname, sizeof (pathname), "/proc/%d/map", pi->pid); 3153 3154 scoped_fd map_fd (open (pathname, O_RDONLY)); 3155 if (map_fd.get () < 0) 3156 proc_error (pi, "iterate_over_mappings (open)", __LINE__); 3157 3158 /* Use stat to determine the file size, and compute 3159 the number of prmap_t objects it contains. */ 3160 if (fstat (map_fd.get (), &sbuf) != 0) 3161 proc_error (pi, "iterate_over_mappings (fstat)", __LINE__); 3162 3163 nmap = sbuf.st_size / sizeof (prmap_t); 3164 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps)); 3165 if (read (map_fd.get (), (char *) prmaps, nmap * sizeof (*prmaps)) 3166 != (nmap * sizeof (*prmaps))) 3167 proc_error (pi, "iterate_over_mappings (read)", __LINE__); 3168 3169 for (prmap = prmaps; nmap > 0; prmap++, nmap--) 3170 { 3171 funcstat = (*func) (prmap, child_func, data); 3172 if (funcstat != 0) 3173 return funcstat; 3174 } 3175 3176 return 0; 3177 } 3178 3179 /* Implements the to_find_memory_regions method. Calls an external 3180 function for each memory region. 3181 Returns the integer value returned by the callback. */ 3182 3183 static int 3184 find_memory_regions_callback (struct prmap *map, 3185 find_memory_region_ftype func, void *data) 3186 { 3187 return (*func) ((CORE_ADDR) map->pr_vaddr, 3188 map->pr_size, 3189 (map->pr_mflags & MA_READ) != 0, 3190 (map->pr_mflags & MA_WRITE) != 0, 3191 (map->pr_mflags & MA_EXEC) != 0, 3192 1, /* MODIFIED is unknown, pass it as true. */ 3193 data); 3194 } 3195 3196 /* External interface. Calls a callback function once for each 3197 mapped memory region in the child process, passing as arguments: 3198 3199 CORE_ADDR virtual_address, 3200 unsigned long size, 3201 int read, TRUE if region is readable by the child 3202 int write, TRUE if region is writable by the child 3203 int execute TRUE if region is executable by the child. 3204 3205 Stops iterating and returns the first non-zero value returned by 3206 the callback. */ 3207 3208 int 3209 procfs_target::find_memory_regions (find_memory_region_ftype func, void *data) 3210 { 3211 procinfo *pi = find_procinfo_or_die (inferior_ptid.pid (), 0); 3212 3213 return iterate_over_mappings (pi, func, data, 3214 find_memory_regions_callback); 3215 } 3216 3217 /* Returns an ascii representation of a memory mapping's flags. */ 3218 3219 static char * 3220 mappingflags (long flags) 3221 { 3222 static char asciiflags[8]; 3223 3224 strcpy (asciiflags, "-------"); 3225 if (flags & MA_STACK) 3226 asciiflags[1] = 's'; 3227 if (flags & MA_BREAK) 3228 asciiflags[2] = 'b'; 3229 if (flags & MA_SHARED) 3230 asciiflags[3] = 's'; 3231 if (flags & MA_READ) 3232 asciiflags[4] = 'r'; 3233 if (flags & MA_WRITE) 3234 asciiflags[5] = 'w'; 3235 if (flags & MA_EXEC) 3236 asciiflags[6] = 'x'; 3237 return (asciiflags); 3238 } 3239 3240 /* Callback function, does the actual work for 'info proc 3241 mappings'. */ 3242 3243 static int 3244 info_mappings_callback (struct prmap *map, find_memory_region_ftype ignore, 3245 void *unused) 3246 { 3247 unsigned int pr_off; 3248 3249 pr_off = (unsigned int) map->pr_offset; 3250 3251 if (gdbarch_addr_bit (target_gdbarch ()) == 32) 3252 printf_filtered ("\t%#10lx %#10lx %#10lx %#10x %7s\n", 3253 (unsigned long) map->pr_vaddr, 3254 (unsigned long) map->pr_vaddr + map->pr_size - 1, 3255 (unsigned long) map->pr_size, 3256 pr_off, 3257 mappingflags (map->pr_mflags)); 3258 else 3259 printf_filtered (" %#18lx %#18lx %#10lx %#10x %7s\n", 3260 (unsigned long) map->pr_vaddr, 3261 (unsigned long) map->pr_vaddr + map->pr_size - 1, 3262 (unsigned long) map->pr_size, 3263 pr_off, 3264 mappingflags (map->pr_mflags)); 3265 3266 return 0; 3267 } 3268 3269 /* Implement the "info proc mappings" subcommand. */ 3270 3271 static void 3272 info_proc_mappings (procinfo *pi, int summary) 3273 { 3274 if (summary) 3275 return; /* No output for summary mode. */ 3276 3277 printf_filtered (_("Mapped address spaces:\n\n")); 3278 if (gdbarch_ptr_bit (target_gdbarch ()) == 32) 3279 printf_filtered ("\t%10s %10s %10s %10s %7s\n", 3280 "Start Addr", 3281 " End Addr", 3282 " Size", 3283 " Offset", 3284 "Flags"); 3285 else 3286 printf_filtered (" %18s %18s %10s %10s %7s\n", 3287 "Start Addr", 3288 " End Addr", 3289 " Size", 3290 " Offset", 3291 "Flags"); 3292 3293 iterate_over_mappings (pi, NULL, NULL, info_mappings_callback); 3294 printf_filtered ("\n"); 3295 } 3296 3297 /* Implement the "info proc" command. */ 3298 3299 bool 3300 procfs_target::info_proc (const char *args, enum info_proc_what what) 3301 { 3302 procinfo *process = NULL; 3303 procinfo *thread = NULL; 3304 char *tmp = NULL; 3305 int pid = 0; 3306 int tid = 0; 3307 int mappings = 0; 3308 3309 switch (what) 3310 { 3311 case IP_MINIMAL: 3312 break; 3313 3314 case IP_MAPPINGS: 3315 case IP_ALL: 3316 mappings = 1; 3317 break; 3318 3319 default: 3320 error (_("Not supported on this target.")); 3321 } 3322 3323 gdb_argv built_argv (args); 3324 for (char *arg : built_argv) 3325 { 3326 if (isdigit (arg[0])) 3327 { 3328 pid = strtoul (arg, &tmp, 10); 3329 if (*tmp == '/') 3330 tid = strtoul (++tmp, NULL, 10); 3331 } 3332 else if (arg[0] == '/') 3333 { 3334 tid = strtoul (arg + 1, NULL, 10); 3335 } 3336 } 3337 3338 procinfo_up temporary_procinfo; 3339 if (pid == 0) 3340 pid = inferior_ptid.pid (); 3341 if (pid == 0) 3342 error (_("No current process: you must name one.")); 3343 else 3344 { 3345 /* Have pid, will travel. 3346 First see if it's a process we're already debugging. */ 3347 process = find_procinfo (pid, 0); 3348 if (process == NULL) 3349 { 3350 /* No. So open a procinfo for it, but 3351 remember to close it again when finished. */ 3352 process = create_procinfo (pid, 0); 3353 temporary_procinfo.reset (process); 3354 if (!open_procinfo_files (process, FD_CTL)) 3355 proc_error (process, "info proc, open_procinfo_files", __LINE__); 3356 } 3357 } 3358 if (tid != 0) 3359 thread = create_procinfo (pid, tid); 3360 3361 if (process) 3362 { 3363 printf_filtered (_("process %d flags:\n"), process->pid); 3364 proc_prettyprint_flags (proc_flags (process), 1); 3365 if (proc_flags (process) & (PR_STOPPED | PR_ISTOP)) 3366 proc_prettyprint_why (proc_why (process), proc_what (process), 1); 3367 if (proc_get_nthreads (process) > 1) 3368 printf_filtered ("Process has %d threads.\n", 3369 proc_get_nthreads (process)); 3370 } 3371 if (thread) 3372 { 3373 printf_filtered (_("thread %d flags:\n"), thread->tid); 3374 proc_prettyprint_flags (proc_flags (thread), 1); 3375 if (proc_flags (thread) & (PR_STOPPED | PR_ISTOP)) 3376 proc_prettyprint_why (proc_why (thread), proc_what (thread), 1); 3377 } 3378 3379 if (mappings) 3380 info_proc_mappings (process, 0); 3381 3382 return true; 3383 } 3384 3385 /* Modify the status of the system call identified by SYSCALLNUM in 3386 the set of syscalls that are currently traced/debugged. 3387 3388 If ENTRY_OR_EXIT is set to PR_SYSENTRY, then the entry syscalls set 3389 will be updated. Otherwise, the exit syscalls set will be updated. 3390 3391 If MODE is FLAG_SET, then traces will be enabled. Otherwise, they 3392 will be disabled. */ 3393 3394 static void 3395 proc_trace_syscalls_1 (procinfo *pi, int syscallnum, int entry_or_exit, 3396 int mode, int from_tty) 3397 { 3398 sysset_t *sysset; 3399 3400 if (entry_or_exit == PR_SYSENTRY) 3401 sysset = proc_get_traced_sysentry (pi, NULL); 3402 else 3403 sysset = proc_get_traced_sysexit (pi, NULL); 3404 3405 if (sysset == NULL) 3406 proc_error (pi, "proc-trace, get_traced_sysset", __LINE__); 3407 3408 if (mode == FLAG_SET) 3409 praddset (sysset, syscallnum); 3410 else 3411 prdelset (sysset, syscallnum); 3412 3413 if (entry_or_exit == PR_SYSENTRY) 3414 { 3415 if (!proc_set_traced_sysentry (pi, sysset)) 3416 proc_error (pi, "proc-trace, set_traced_sysentry", __LINE__); 3417 } 3418 else 3419 { 3420 if (!proc_set_traced_sysexit (pi, sysset)) 3421 proc_error (pi, "proc-trace, set_traced_sysexit", __LINE__); 3422 } 3423 } 3424 3425 static void 3426 proc_trace_syscalls (const char *args, int from_tty, int entry_or_exit, int mode) 3427 { 3428 procinfo *pi; 3429 3430 if (inferior_ptid.pid () <= 0) 3431 error (_("you must be debugging a process to use this command.")); 3432 3433 if (args == NULL || args[0] == 0) 3434 error_no_arg (_("system call to trace")); 3435 3436 pi = find_procinfo_or_die (inferior_ptid.pid (), 0); 3437 if (isdigit (args[0])) 3438 { 3439 const int syscallnum = atoi (args); 3440 3441 proc_trace_syscalls_1 (pi, syscallnum, entry_or_exit, mode, from_tty); 3442 } 3443 } 3444 3445 static void 3446 proc_trace_sysentry_cmd (const char *args, int from_tty) 3447 { 3448 proc_trace_syscalls (args, from_tty, PR_SYSENTRY, FLAG_SET); 3449 } 3450 3451 static void 3452 proc_trace_sysexit_cmd (const char *args, int from_tty) 3453 { 3454 proc_trace_syscalls (args, from_tty, PR_SYSEXIT, FLAG_SET); 3455 } 3456 3457 static void 3458 proc_untrace_sysentry_cmd (const char *args, int from_tty) 3459 { 3460 proc_trace_syscalls (args, from_tty, PR_SYSENTRY, FLAG_RESET); 3461 } 3462 3463 static void 3464 proc_untrace_sysexit_cmd (const char *args, int from_tty) 3465 { 3466 proc_trace_syscalls (args, from_tty, PR_SYSEXIT, FLAG_RESET); 3467 } 3468 3469 void _initialize_procfs (); 3470 void 3471 _initialize_procfs () 3472 { 3473 gdb::observers::inferior_created.attach (procfs_inferior_created); 3474 3475 add_com ("proc-trace-entry", no_class, proc_trace_sysentry_cmd, 3476 _("Give a trace of entries into the syscall.")); 3477 add_com ("proc-trace-exit", no_class, proc_trace_sysexit_cmd, 3478 _("Give a trace of exits from the syscall.")); 3479 add_com ("proc-untrace-entry", no_class, proc_untrace_sysentry_cmd, 3480 _("Cancel a trace of entries into the syscall.")); 3481 add_com ("proc-untrace-exit", no_class, proc_untrace_sysexit_cmd, 3482 _("Cancel a trace of exits from the syscall.")); 3483 3484 add_inf_child_target (&the_procfs_target); 3485 } 3486 3487 /* =================== END, GDB "MODULE" =================== */ 3488 3489 3490 3491 /* miscellaneous stubs: */ 3492 3493 /* The following satisfy a few random symbols mostly created by the 3494 solaris threads implementation, which I will chase down later. */ 3495 3496 /* Return a pid for which we guarantee we will be able to find a 3497 'live' procinfo. */ 3498 3499 ptid_t 3500 procfs_first_available (void) 3501 { 3502 return ptid_t (procinfo_list ? procinfo_list->pid : -1); 3503 } 3504 3505 /* =================== GCORE .NOTE "MODULE" =================== */ 3506 3507 static char * 3508 procfs_do_thread_registers (bfd *obfd, ptid_t ptid, 3509 char *note_data, int *note_size, 3510 enum gdb_signal stop_signal) 3511 { 3512 struct regcache *regcache = get_thread_regcache (&the_procfs_target, ptid); 3513 gdb_gregset_t gregs; 3514 gdb_fpregset_t fpregs; 3515 unsigned long merged_pid; 3516 3517 merged_pid = ptid.lwp () << 16 | ptid.pid (); 3518 3519 /* This part is the old method for fetching registers. 3520 It should be replaced by the newer one using regsets 3521 once it is implemented in this platform: 3522 gdbarch_iterate_over_regset_sections(). */ 3523 3524 target_fetch_registers (regcache, -1); 3525 3526 fill_gregset (regcache, &gregs, -1); 3527 note_data = (char *) elfcore_write_lwpstatus (obfd, 3528 note_data, 3529 note_size, 3530 merged_pid, 3531 stop_signal, 3532 &gregs); 3533 fill_fpregset (regcache, &fpregs, -1); 3534 note_data = (char *) elfcore_write_prfpreg (obfd, 3535 note_data, 3536 note_size, 3537 &fpregs, 3538 sizeof (fpregs)); 3539 3540 return note_data; 3541 } 3542 3543 struct procfs_corefile_thread_data { 3544 bfd *obfd; 3545 char *note_data; 3546 int *note_size; 3547 enum gdb_signal stop_signal; 3548 }; 3549 3550 static int 3551 procfs_corefile_thread_callback (procinfo *pi, procinfo *thread, void *data) 3552 { 3553 struct procfs_corefile_thread_data *args 3554 = (struct procfs_corefile_thread_data *) data; 3555 3556 if (pi != NULL) 3557 { 3558 ptid_t ptid = ptid_t (pi->pid, thread->tid, 0); 3559 3560 args->note_data = procfs_do_thread_registers (args->obfd, ptid, 3561 args->note_data, 3562 args->note_size, 3563 args->stop_signal); 3564 } 3565 return 0; 3566 } 3567 3568 static int 3569 find_signalled_thread (struct thread_info *info, void *data) 3570 { 3571 if (info->suspend.stop_signal != GDB_SIGNAL_0 3572 && info->ptid.pid () == inferior_ptid.pid ()) 3573 return 1; 3574 3575 return 0; 3576 } 3577 3578 static enum gdb_signal 3579 find_stop_signal (void) 3580 { 3581 struct thread_info *info = 3582 iterate_over_threads (find_signalled_thread, NULL); 3583 3584 if (info) 3585 return info->suspend.stop_signal; 3586 else 3587 return GDB_SIGNAL_0; 3588 } 3589 3590 char * 3591 procfs_target::make_corefile_notes (bfd *obfd, int *note_size) 3592 { 3593 gdb_gregset_t gregs; 3594 char fname[16] = {'\0'}; 3595 char psargs[80] = {'\0'}; 3596 procinfo *pi = find_procinfo_or_die (inferior_ptid.pid (), 0); 3597 char *note_data = NULL; 3598 const char *inf_args; 3599 struct procfs_corefile_thread_data thread_args; 3600 enum gdb_signal stop_signal; 3601 3602 if (get_exec_file (0)) 3603 { 3604 strncpy (fname, lbasename (get_exec_file (0)), sizeof (fname)); 3605 fname[sizeof (fname) - 1] = 0; 3606 strncpy (psargs, get_exec_file (0), sizeof (psargs)); 3607 psargs[sizeof (psargs) - 1] = 0; 3608 3609 inf_args = get_inferior_args (); 3610 if (inf_args && *inf_args 3611 && (strlen (inf_args) 3612 < ((int) sizeof (psargs) - (int) strlen (psargs)))) 3613 { 3614 strncat (psargs, " ", 3615 sizeof (psargs) - strlen (psargs)); 3616 strncat (psargs, inf_args, 3617 sizeof (psargs) - strlen (psargs)); 3618 } 3619 } 3620 3621 note_data = (char *) elfcore_write_prpsinfo (obfd, 3622 note_data, 3623 note_size, 3624 fname, 3625 psargs); 3626 3627 stop_signal = find_stop_signal (); 3628 3629 fill_gregset (get_current_regcache (), &gregs, -1); 3630 note_data = elfcore_write_pstatus (obfd, note_data, note_size, 3631 inferior_ptid.pid (), 3632 stop_signal, &gregs); 3633 3634 thread_args.obfd = obfd; 3635 thread_args.note_data = note_data; 3636 thread_args.note_size = note_size; 3637 thread_args.stop_signal = stop_signal; 3638 proc_iterate_over_threads (pi, procfs_corefile_thread_callback, 3639 &thread_args); 3640 note_data = thread_args.note_data; 3641 3642 gdb::optional<gdb::byte_vector> auxv = 3643 target_read_alloc (current_top_target (), TARGET_OBJECT_AUXV, NULL); 3644 if (auxv && !auxv->empty ()) 3645 note_data = elfcore_write_note (obfd, note_data, note_size, 3646 "CORE", NT_AUXV, auxv->data (), 3647 auxv->size ()); 3648 3649 return note_data; 3650 } 3651 /* =================== END GCORE .NOTE "MODULE" =================== */ 3652