1/* Machine independent support for SVR4 /proc (process file system) for GDB. 2 3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2006, 2007 4 Free Software Foundation, Inc. 5 6 Written by Michael Snyder at Cygnus Solutions. 7 Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others. 8 9 This file is part of GDB. 10 11 This program is free software; you can redistribute it and/or modify 12 it under the terms of the GNU General Public License as published by 13 the Free Software Foundation; either version 3 of the License, or 14 (at your option) any later version. 15 16 This program is distributed in the hope that it will be useful, 17 but WITHOUT ANY WARRANTY; without even the implied warranty of 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 GNU General Public License for more details. 20 21 You should have received a copy of the GNU General Public License 22 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 23 24#include "defs.h" 25#include "inferior.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 33#if defined (NEW_PROC_API) 34#define _STRUCTURED_PROC 1 /* Should be done by configure script. */ 35#endif 36 37#include <sys/procfs.h> 38#ifdef HAVE_SYS_FAULT_H 39#include <sys/fault.h> 40#endif 41#ifdef HAVE_SYS_SYSCALL_H 42#include <sys/syscall.h> 43#endif 44#include <sys/errno.h> 45#include "gdb_wait.h" 46#include <signal.h> 47#include <ctype.h> 48#include "gdb_string.h" 49#include "gdb_assert.h" 50#include "inflow.h" 51#include "auxv.h" 52 53/* 54 * PROCFS.C 55 * 56 * This module provides the interface between GDB and the 57 * /proc file system, which is used on many versions of Unix 58 * as a means for debuggers to control other processes. 59 * Examples of the systems that use this interface are: 60 * Irix 61 * Solaris 62 * OSF 63 * Unixware 64 * AIX5 65 * 66 * /proc works by imitating a file system: you open a simulated file 67 * that represents the process you wish to interact with, and 68 * perform operations on that "file" in order to examine or change 69 * the state of the other process. 70 * 71 * The most important thing to know about /proc and this module 72 * is that there are two very different interfaces to /proc: 73 * One that uses the ioctl system call, and 74 * another that uses read and write system calls. 75 * This module has to support both /proc interfaces. This means 76 * that there are two different ways of doing every basic operation. 77 * 78 * In order to keep most of the code simple and clean, I have 79 * defined an interface "layer" which hides all these system calls. 80 * An ifdef (NEW_PROC_API) determines which interface we are using, 81 * and most or all occurrances of this ifdef should be confined to 82 * this interface layer. 83 */ 84 85 86/* Determine which /proc API we are using: 87 The ioctl API defines PIOCSTATUS, while 88 the read/write (multiple fd) API never does. */ 89 90#ifdef NEW_PROC_API 91#include <sys/types.h> 92#include "gdb_dirent.h" /* opendir/readdir, for listing the LWP's */ 93#endif 94 95#include <fcntl.h> /* for O_RDONLY */ 96#include <unistd.h> /* for "X_OK" */ 97#include "gdb_stat.h" /* for struct stat */ 98 99/* Note: procfs-utils.h must be included after the above system header 100 files, because it redefines various system calls using macros. 101 This may be incompatible with the prototype declarations. */ 102 103#include "proc-utils.h" 104 105/* Prototypes for supply_gregset etc. */ 106#include "gregset.h" 107 108/* =================== TARGET_OPS "MODULE" =================== */ 109 110/* 111 * This module defines the GDB target vector and its methods. 112 */ 113 114static void procfs_open (char *, int); 115static void procfs_attach (char *, int); 116static void procfs_detach (char *, int); 117static void procfs_resume (ptid_t, int, enum target_signal); 118static int procfs_can_run (void); 119static void procfs_stop (void); 120static void procfs_files_info (struct target_ops *); 121static void procfs_fetch_registers (struct regcache *, int); 122static void procfs_store_registers (struct regcache *, int); 123static void procfs_notice_signals (ptid_t); 124static void procfs_prepare_to_store (struct regcache *); 125static void procfs_kill_inferior (void); 126static void procfs_mourn_inferior (void); 127static void procfs_create_inferior (char *, char *, char **, int); 128static ptid_t procfs_wait (ptid_t, struct target_waitstatus *); 129static int procfs_xfer_memory (CORE_ADDR, char *, int, int, 130 struct mem_attrib *attrib, 131 struct target_ops *); 132static LONGEST procfs_xfer_partial (struct target_ops *ops, 133 enum target_object object, 134 const char *annex, 135 void *readbuf, const void *writebuf, 136 ULONGEST offset, LONGEST len); 137 138static int procfs_thread_alive (ptid_t); 139 140void procfs_find_new_threads (void); 141char *procfs_pid_to_str (ptid_t); 142 143static int proc_find_memory_regions (int (*) (CORE_ADDR, 144 unsigned long, 145 int, int, int, 146 void *), 147 void *); 148 149static char * procfs_make_note_section (bfd *, int *); 150 151static int procfs_can_use_hw_breakpoint (int, int, int); 152 153struct target_ops procfs_ops; /* the target vector */ 154 155static void 156init_procfs_ops (void) 157{ 158 procfs_ops.to_shortname = "procfs"; 159 procfs_ops.to_longname = "Unix /proc child process"; 160 procfs_ops.to_doc = 161 "Unix /proc child process (started by the \"run\" command)."; 162 procfs_ops.to_open = procfs_open; 163 procfs_ops.to_can_run = procfs_can_run; 164 procfs_ops.to_create_inferior = procfs_create_inferior; 165 procfs_ops.to_kill = procfs_kill_inferior; 166 procfs_ops.to_mourn_inferior = procfs_mourn_inferior; 167 procfs_ops.to_attach = procfs_attach; 168 procfs_ops.to_detach = procfs_detach; 169 procfs_ops.to_wait = procfs_wait; 170 procfs_ops.to_resume = procfs_resume; 171 procfs_ops.to_prepare_to_store = procfs_prepare_to_store; 172 procfs_ops.to_fetch_registers = procfs_fetch_registers; 173 procfs_ops.to_store_registers = procfs_store_registers; 174 procfs_ops.to_xfer_partial = procfs_xfer_partial; 175 procfs_ops.deprecated_xfer_memory = procfs_xfer_memory; 176 procfs_ops.to_insert_breakpoint = memory_insert_breakpoint; 177 procfs_ops.to_remove_breakpoint = memory_remove_breakpoint; 178 procfs_ops.to_notice_signals = procfs_notice_signals; 179 procfs_ops.to_files_info = procfs_files_info; 180 procfs_ops.to_stop = procfs_stop; 181 182 procfs_ops.to_terminal_init = terminal_init_inferior; 183 procfs_ops.to_terminal_inferior = terminal_inferior; 184 procfs_ops.to_terminal_ours_for_output = terminal_ours_for_output; 185 procfs_ops.to_terminal_ours = terminal_ours; 186 procfs_ops.to_terminal_save_ours = terminal_save_ours; 187 procfs_ops.to_terminal_info = child_terminal_info; 188 189 procfs_ops.to_find_new_threads = procfs_find_new_threads; 190 procfs_ops.to_thread_alive = procfs_thread_alive; 191 procfs_ops.to_pid_to_str = procfs_pid_to_str; 192 193 procfs_ops.to_has_all_memory = 1; 194 procfs_ops.to_has_memory = 1; 195 procfs_ops.to_has_execution = 1; 196 procfs_ops.to_has_stack = 1; 197 procfs_ops.to_has_registers = 1; 198 procfs_ops.to_stratum = process_stratum; 199 procfs_ops.to_has_thread_control = tc_schedlock; 200 procfs_ops.to_find_memory_regions = proc_find_memory_regions; 201 procfs_ops.to_make_corefile_notes = procfs_make_note_section; 202 procfs_ops.to_can_use_hw_breakpoint = procfs_can_use_hw_breakpoint; 203 procfs_ops.to_magic = OPS_MAGIC; 204} 205 206/* =================== END, TARGET_OPS "MODULE" =================== */ 207 208/* 209 * World Unification: 210 * 211 * Put any typedefs, defines etc. here that are required for 212 * the unification of code that handles different versions of /proc. 213 */ 214 215#ifdef NEW_PROC_API /* Solaris 7 && 8 method for watchpoints */ 216#ifdef WA_READ 217 enum { READ_WATCHFLAG = WA_READ, 218 WRITE_WATCHFLAG = WA_WRITE, 219 EXEC_WATCHFLAG = WA_EXEC, 220 AFTER_WATCHFLAG = WA_TRAPAFTER 221 }; 222#endif 223#else /* Irix method for watchpoints */ 224 enum { READ_WATCHFLAG = MA_READ, 225 WRITE_WATCHFLAG = MA_WRITE, 226 EXEC_WATCHFLAG = MA_EXEC, 227 AFTER_WATCHFLAG = 0 /* trapafter not implemented */ 228 }; 229#endif 230 231/* gdb_sigset_t */ 232#ifdef HAVE_PR_SIGSET_T 233typedef pr_sigset_t gdb_sigset_t; 234#else 235typedef sigset_t gdb_sigset_t; 236#endif 237 238/* sigaction */ 239#ifdef HAVE_PR_SIGACTION64_T 240typedef pr_sigaction64_t gdb_sigaction_t; 241#else 242typedef struct sigaction gdb_sigaction_t; 243#endif 244 245/* siginfo */ 246#ifdef HAVE_PR_SIGINFO64_T 247typedef pr_siginfo64_t gdb_siginfo_t; 248#else 249typedef struct siginfo gdb_siginfo_t; 250#endif 251 252/* gdb_premptysysset */ 253#ifdef premptysysset 254#define gdb_premptysysset premptysysset 255#else 256#define gdb_premptysysset premptyset 257#endif 258 259/* praddsysset */ 260#ifdef praddsysset 261#define gdb_praddsysset praddsysset 262#else 263#define gdb_praddsysset praddset 264#endif 265 266/* prdelsysset */ 267#ifdef prdelsysset 268#define gdb_prdelsysset prdelsysset 269#else 270#define gdb_prdelsysset prdelset 271#endif 272 273/* prissyssetmember */ 274#ifdef prissyssetmember 275#define gdb_pr_issyssetmember prissyssetmember 276#else 277#define gdb_pr_issyssetmember prismember 278#endif 279 280/* As a feature test, saying ``#if HAVE_PRSYSENT_T'' everywhere isn't 281 as intuitively descriptive as it could be, so we'll define 282 DYNAMIC_SYSCALLS to mean the same thing. Anyway, at the time of 283 this writing, this feature is only found on AIX5 systems and 284 basically means that the set of syscalls is not fixed. I.e, 285 there's no nice table that one can #include to get all of the 286 syscall numbers. Instead, they're stored in /proc/PID/sysent 287 for each process. We are at least guaranteed that they won't 288 change over the lifetime of the process. But each process could 289 (in theory) have different syscall numbers. 290*/ 291#ifdef HAVE_PRSYSENT_T 292#define DYNAMIC_SYSCALLS 293#endif 294 295 296 297/* =================== STRUCT PROCINFO "MODULE" =================== */ 298 299 /* FIXME: this comment will soon be out of date W.R.T. threads. */ 300 301/* The procinfo struct is a wrapper to hold all the state information 302 concerning a /proc process. There should be exactly one procinfo 303 for each process, and since GDB currently can debug only one 304 process at a time, that means there should be only one procinfo. 305 All of the LWP's of a process can be accessed indirectly thru the 306 single process procinfo. 307 308 However, against the day when GDB may debug more than one process, 309 this data structure is kept in a list (which for now will hold no 310 more than one member), and many functions will have a pointer to a 311 procinfo as an argument. 312 313 There will be a separate procinfo structure for use by the (not yet 314 implemented) "info proc" command, so that we can print useful 315 information about any random process without interfering with the 316 inferior's procinfo information. */ 317 318#ifdef NEW_PROC_API 319/* format strings for /proc paths */ 320# ifndef CTL_PROC_NAME_FMT 321# define MAIN_PROC_NAME_FMT "/proc/%d" 322# define CTL_PROC_NAME_FMT "/proc/%d/ctl" 323# define AS_PROC_NAME_FMT "/proc/%d/as" 324# define MAP_PROC_NAME_FMT "/proc/%d/map" 325# define STATUS_PROC_NAME_FMT "/proc/%d/status" 326# define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus") 327# endif 328/* the name of the proc status struct depends on the implementation */ 329typedef pstatus_t gdb_prstatus_t; 330typedef lwpstatus_t gdb_lwpstatus_t; 331#else /* ! NEW_PROC_API */ 332/* format strings for /proc paths */ 333# ifndef CTL_PROC_NAME_FMT 334# define MAIN_PROC_NAME_FMT "/proc/%05d" 335# define CTL_PROC_NAME_FMT "/proc/%05d" 336# define AS_PROC_NAME_FMT "/proc/%05d" 337# define MAP_PROC_NAME_FMT "/proc/%05d" 338# define STATUS_PROC_NAME_FMT "/proc/%05d" 339# define MAX_PROC_NAME_SIZE sizeof("/proc/ttttppppp") 340# endif 341/* the name of the proc status struct depends on the implementation */ 342typedef prstatus_t gdb_prstatus_t; 343typedef prstatus_t gdb_lwpstatus_t; 344#endif /* NEW_PROC_API */ 345 346typedef struct procinfo { 347 struct procinfo *next; 348 int pid; /* Process ID */ 349 int tid; /* Thread/LWP id */ 350 351 /* process state */ 352 int was_stopped; 353 int ignore_next_sigstop; 354 355 /* The following four fd fields may be identical, or may contain 356 several different fd's, depending on the version of /proc 357 (old ioctl or new read/write). */ 358 359 int ctl_fd; /* File descriptor for /proc control file */ 360 /* 361 * The next three file descriptors are actually only needed in the 362 * read/write, multiple-file-descriptor implemenation (NEW_PROC_API). 363 * However, to avoid a bunch of #ifdefs in the code, we will use 364 * them uniformly by (in the case of the ioctl single-file-descriptor 365 * implementation) filling them with copies of the control fd. 366 */ 367 int status_fd; /* File descriptor for /proc status file */ 368 int as_fd; /* File descriptor for /proc as file */ 369 370 char pathname[MAX_PROC_NAME_SIZE]; /* Pathname to /proc entry */ 371 372 fltset_t saved_fltset; /* Saved traced hardware fault set */ 373 gdb_sigset_t saved_sigset; /* Saved traced signal set */ 374 gdb_sigset_t saved_sighold; /* Saved held signal set */ 375 sysset_t *saved_exitset; /* Saved traced system call exit set */ 376 sysset_t *saved_entryset; /* Saved traced system call entry set */ 377 378 gdb_prstatus_t prstatus; /* Current process status info */ 379 380#ifndef NEW_PROC_API 381 gdb_fpregset_t fpregset; /* Current floating point registers */ 382#endif 383 384#ifdef DYNAMIC_SYSCALLS 385 int num_syscalls; /* Total number of syscalls */ 386 char **syscall_names; /* Syscall number to name map */ 387#endif 388 389 struct procinfo *thread_list; 390 391 int status_valid : 1; 392 int gregs_valid : 1; 393 int fpregs_valid : 1; 394 int threads_valid: 1; 395} procinfo; 396 397static char errmsg[128]; /* shared error msg buffer */ 398 399/* Function prototypes for procinfo module: */ 400 401static procinfo *find_procinfo_or_die (int pid, int tid); 402static procinfo *find_procinfo (int pid, int tid); 403static procinfo *create_procinfo (int pid, int tid); 404static void destroy_procinfo (procinfo * p); 405static void do_destroy_procinfo_cleanup (void *); 406static void dead_procinfo (procinfo * p, char *msg, int killp); 407static int open_procinfo_files (procinfo * p, int which); 408static void close_procinfo_files (procinfo * p); 409static int sysset_t_size (procinfo *p); 410static sysset_t *sysset_t_alloc (procinfo * pi); 411#ifdef DYNAMIC_SYSCALLS 412static void load_syscalls (procinfo *pi); 413static void free_syscalls (procinfo *pi); 414static int find_syscall (procinfo *pi, char *name); 415#endif /* DYNAMIC_SYSCALLS */ 416 417/* The head of the procinfo list: */ 418static procinfo * procinfo_list; 419 420/* 421 * Function: find_procinfo 422 * 423 * Search the procinfo list. 424 * 425 * Returns: pointer to procinfo, or NULL if not found. 426 */ 427 428static procinfo * 429find_procinfo (int pid, int tid) 430{ 431 procinfo *pi; 432 433 for (pi = procinfo_list; pi; pi = pi->next) 434 if (pi->pid == pid) 435 break; 436 437 if (pi) 438 if (tid) 439 { 440 /* Don't check threads_valid. If we're updating the 441 thread_list, we want to find whatever threads are already 442 here. This means that in general it is the caller's 443 responsibility to check threads_valid and update before 444 calling find_procinfo, if the caller wants to find a new 445 thread. */ 446 447 for (pi = pi->thread_list; pi; pi = pi->next) 448 if (pi->tid == tid) 449 break; 450 } 451 452 return pi; 453} 454 455/* 456 * Function: find_procinfo_or_die 457 * 458 * Calls find_procinfo, but errors on failure. 459 */ 460 461static procinfo * 462find_procinfo_or_die (int pid, int tid) 463{ 464 procinfo *pi = find_procinfo (pid, tid); 465 466 if (pi == NULL) 467 { 468 if (tid) 469 error (_("procfs: couldn't find pid %d (kernel thread %d) in procinfo list."), 470 pid, tid); 471 else 472 error (_("procfs: couldn't find pid %d in procinfo list."), pid); 473 } 474 return pi; 475} 476 477/* open_with_retry() is a wrapper for open(). The appropriate 478 open() call is attempted; if unsuccessful, it will be retried as 479 many times as needed for the EAGAIN and EINTR conditions. 480 481 For other conditions, open_with_retry() will retry the open() a 482 limited number of times. In addition, a short sleep is imposed 483 prior to retrying the open(). The reason for this sleep is to give 484 the kernel a chance to catch up and create the file in question in 485 the event that GDB "wins" the race to open a file before the kernel 486 has created it. */ 487 488static int 489open_with_retry (const char *pathname, int flags) 490{ 491 int retries_remaining, status; 492 493 retries_remaining = 2; 494 495 while (1) 496 { 497 status = open (pathname, flags); 498 499 if (status >= 0 || retries_remaining == 0) 500 break; 501 else if (errno != EINTR && errno != EAGAIN) 502 { 503 retries_remaining--; 504 sleep (1); 505 } 506 } 507 508 return status; 509} 510 511/* 512 * Function: open_procinfo_files 513 * 514 * Open the file descriptor for the process or LWP. 515 * ifdef NEW_PROC_API, we only open the control file descriptor; 516 * the others are opened lazily as needed. 517 * else (if not NEW_PROC_API), there is only one real 518 * file descriptor, but we keep multiple copies of it so that 519 * the code that uses them does not have to be #ifdef'd. 520 * 521 * Return: file descriptor, or zero for failure. 522 */ 523 524enum { FD_CTL, FD_STATUS, FD_AS }; 525 526static int 527open_procinfo_files (procinfo *pi, int which) 528{ 529#ifdef NEW_PROC_API 530 char tmp[MAX_PROC_NAME_SIZE]; 531#endif 532 int fd; 533 534 /* 535 * This function is getting ALMOST long enough to break up into several. 536 * Here is some rationale: 537 * 538 * NEW_PROC_API (Solaris 2.6, Solaris 2.7, Unixware): 539 * There are several file descriptors that may need to be open 540 * for any given process or LWP. The ones we're intereted in are: 541 * - control (ctl) write-only change the state 542 * - status (status) read-only query the state 543 * - address space (as) read/write access memory 544 * - map (map) read-only virtual addr map 545 * Most of these are opened lazily as they are needed. 546 * The pathnames for the 'files' for an LWP look slightly 547 * different from those of a first-class process: 548 * Pathnames for a process (<proc-id>): 549 * /proc/<proc-id>/ctl 550 * /proc/<proc-id>/status 551 * /proc/<proc-id>/as 552 * /proc/<proc-id>/map 553 * Pathnames for an LWP (lwp-id): 554 * /proc/<proc-id>/lwp/<lwp-id>/lwpctl 555 * /proc/<proc-id>/lwp/<lwp-id>/lwpstatus 556 * An LWP has no map or address space file descriptor, since 557 * the memory map and address space are shared by all LWPs. 558 * 559 * Everyone else (Solaris 2.5, Irix, OSF) 560 * There is only one file descriptor for each process or LWP. 561 * For convenience, we copy the same file descriptor into all 562 * three fields of the procinfo struct (ctl_fd, status_fd, and 563 * as_fd, see NEW_PROC_API above) so that code that uses them 564 * doesn't need any #ifdef's. 565 * Pathname for all: 566 * /proc/<proc-id> 567 * 568 * Solaris 2.5 LWP's: 569 * Each LWP has an independent file descriptor, but these 570 * are not obtained via the 'open' system call like the rest: 571 * instead, they're obtained thru an ioctl call (PIOCOPENLWP) 572 * to the file descriptor of the parent process. 573 * 574 * OSF threads: 575 * These do not even have their own independent file descriptor. 576 * All operations are carried out on the file descriptor of the 577 * parent process. Therefore we just call open again for each 578 * thread, getting a new handle for the same 'file'. 579 */ 580 581#ifdef NEW_PROC_API 582 /* 583 * In this case, there are several different file descriptors that 584 * we might be asked to open. The control file descriptor will be 585 * opened early, but the others will be opened lazily as they are 586 * needed. 587 */ 588 589 strcpy (tmp, pi->pathname); 590 switch (which) { /* which file descriptor to open? */ 591 case FD_CTL: 592 if (pi->tid) 593 strcat (tmp, "/lwpctl"); 594 else 595 strcat (tmp, "/ctl"); 596 fd = open_with_retry (tmp, O_WRONLY); 597 if (fd <= 0) 598 return 0; /* fail */ 599 pi->ctl_fd = fd; 600 break; 601 case FD_AS: 602 if (pi->tid) 603 return 0; /* there is no 'as' file descriptor for an lwp */ 604 strcat (tmp, "/as"); 605 fd = open_with_retry (tmp, O_RDWR); 606 if (fd <= 0) 607 return 0; /* fail */ 608 pi->as_fd = fd; 609 break; 610 case FD_STATUS: 611 if (pi->tid) 612 strcat (tmp, "/lwpstatus"); 613 else 614 strcat (tmp, "/status"); 615 fd = open_with_retry (tmp, O_RDONLY); 616 if (fd <= 0) 617 return 0; /* fail */ 618 pi->status_fd = fd; 619 break; 620 default: 621 return 0; /* unknown file descriptor */ 622 } 623#else /* not NEW_PROC_API */ 624 /* 625 * In this case, there is only one file descriptor for each procinfo 626 * (ie. each process or LWP). In fact, only the file descriptor for 627 * the process can actually be opened by an 'open' system call. 628 * The ones for the LWPs have to be obtained thru an IOCTL call 629 * on the process's file descriptor. 630 * 631 * For convenience, we copy each procinfo's single file descriptor 632 * into all of the fields occupied by the several file descriptors 633 * of the NEW_PROC_API implementation. That way, the code that uses 634 * them can be written without ifdefs. 635 */ 636 637 638#ifdef PIOCTSTATUS /* OSF */ 639 /* Only one FD; just open it. */ 640 if ((fd = open_with_retry (pi->pathname, O_RDWR)) == 0) 641 return 0; 642#else /* Sol 2.5, Irix, other? */ 643 if (pi->tid == 0) /* Master procinfo for the process */ 644 { 645 fd = open_with_retry (pi->pathname, O_RDWR); 646 if (fd <= 0) 647 return 0; /* fail */ 648 } 649 else /* LWP thread procinfo */ 650 { 651#ifdef PIOCOPENLWP /* Sol 2.5, thread/LWP */ 652 procinfo *process; 653 int lwpid = pi->tid; 654 655 /* Find the procinfo for the entire process. */ 656 if ((process = find_procinfo (pi->pid, 0)) == NULL) 657 return 0; /* fail */ 658 659 /* Now obtain the file descriptor for the LWP. */ 660 if ((fd = ioctl (process->ctl_fd, PIOCOPENLWP, &lwpid)) <= 0) 661 return 0; /* fail */ 662#else /* Irix, other? */ 663 return 0; /* Don't know how to open threads */ 664#endif /* Sol 2.5 PIOCOPENLWP */ 665 } 666#endif /* OSF PIOCTSTATUS */ 667 pi->ctl_fd = pi->as_fd = pi->status_fd = fd; 668#endif /* NEW_PROC_API */ 669 670 return 1; /* success */ 671} 672 673/* 674 * Function: create_procinfo 675 * 676 * Allocate a data structure and link it into the procinfo list. 677 * (First tries to find a pre-existing one (FIXME: why?) 678 * 679 * Return: pointer to new procinfo struct. 680 */ 681 682static procinfo * 683create_procinfo (int pid, int tid) 684{ 685 procinfo *pi, *parent; 686 687 if ((pi = find_procinfo (pid, tid))) 688 return pi; /* Already exists, nothing to do. */ 689 690 /* find parent before doing malloc, to save having to cleanup */ 691 if (tid != 0) 692 parent = find_procinfo_or_die (pid, 0); /* FIXME: should I 693 create it if it 694 doesn't exist yet? */ 695 696 pi = (procinfo *) xmalloc (sizeof (procinfo)); 697 memset (pi, 0, sizeof (procinfo)); 698 pi->pid = pid; 699 pi->tid = tid; 700 701#ifdef DYNAMIC_SYSCALLS 702 load_syscalls (pi); 703#endif 704 705 pi->saved_entryset = sysset_t_alloc (pi); 706 pi->saved_exitset = sysset_t_alloc (pi); 707 708 /* Chain into list. */ 709 if (tid == 0) 710 { 711 sprintf (pi->pathname, MAIN_PROC_NAME_FMT, pid); 712 pi->next = procinfo_list; 713 procinfo_list = pi; 714 } 715 else 716 { 717#ifdef NEW_PROC_API 718 sprintf (pi->pathname, "/proc/%05d/lwp/%d", pid, tid); 719#else 720 sprintf (pi->pathname, MAIN_PROC_NAME_FMT, pid); 721#endif 722 pi->next = parent->thread_list; 723 parent->thread_list = pi; 724 } 725 return pi; 726} 727 728/* 729 * Function: close_procinfo_files 730 * 731 * Close all file descriptors associated with the procinfo 732 */ 733 734static void 735close_procinfo_files (procinfo *pi) 736{ 737 if (pi->ctl_fd > 0) 738 close (pi->ctl_fd); 739#ifdef NEW_PROC_API 740 if (pi->as_fd > 0) 741 close (pi->as_fd); 742 if (pi->status_fd > 0) 743 close (pi->status_fd); 744#endif 745 pi->ctl_fd = pi->as_fd = pi->status_fd = 0; 746} 747 748/* 749 * Function: destroy_procinfo 750 * 751 * Destructor function. Close, unlink and deallocate the object. 752 */ 753 754static void 755destroy_one_procinfo (procinfo **list, procinfo *pi) 756{ 757 procinfo *ptr; 758 759 /* Step one: unlink the procinfo from its list */ 760 if (pi == *list) 761 *list = pi->next; 762 else 763 for (ptr = *list; ptr; ptr = ptr->next) 764 if (ptr->next == pi) 765 { 766 ptr->next = pi->next; 767 break; 768 } 769 770 /* Step two: close any open file descriptors */ 771 close_procinfo_files (pi); 772 773 /* Step three: free the memory. */ 774#ifdef DYNAMIC_SYSCALLS 775 free_syscalls (pi); 776#endif 777 xfree (pi->saved_entryset); 778 xfree (pi->saved_exitset); 779 xfree (pi); 780} 781 782static void 783destroy_procinfo (procinfo *pi) 784{ 785 procinfo *tmp; 786 787 if (pi->tid != 0) /* destroy a thread procinfo */ 788 { 789 tmp = find_procinfo (pi->pid, 0); /* find the parent process */ 790 destroy_one_procinfo (&tmp->thread_list, pi); 791 } 792 else /* destroy a process procinfo and all its threads */ 793 { 794 /* First destroy the children, if any; */ 795 while (pi->thread_list != NULL) 796 destroy_one_procinfo (&pi->thread_list, pi->thread_list); 797 /* Then destroy the parent. Genocide!!! */ 798 destroy_one_procinfo (&procinfo_list, pi); 799 } 800} 801 802static void 803do_destroy_procinfo_cleanup (void *pi) 804{ 805 destroy_procinfo (pi); 806} 807 808enum { NOKILL, KILL }; 809 810/* 811 * Function: dead_procinfo 812 * 813 * To be called on a non_recoverable error for a procinfo. 814 * Prints error messages, optionally sends a SIGKILL to the process, 815 * then destroys the data structure. 816 */ 817 818static void 819dead_procinfo (procinfo *pi, char *msg, int kill_p) 820{ 821 char procfile[80]; 822 823 if (pi->pathname) 824 { 825 print_sys_errmsg (pi->pathname, errno); 826 } 827 else 828 { 829 sprintf (procfile, "process %d", pi->pid); 830 print_sys_errmsg (procfile, errno); 831 } 832 if (kill_p == KILL) 833 kill (pi->pid, SIGKILL); 834 835 destroy_procinfo (pi); 836 error ((msg)); 837} 838 839/* 840 * Function: sysset_t_size 841 * 842 * Returns the (complete) size of a sysset_t struct. Normally, this 843 * is just sizeof (syset_t), but in the case of Monterey/64, the actual 844 * size of sysset_t isn't known until runtime. 845 */ 846 847static int 848sysset_t_size (procinfo * pi) 849{ 850#ifndef DYNAMIC_SYSCALLS 851 return sizeof (sysset_t); 852#else 853 return sizeof (sysset_t) - sizeof (uint64_t) 854 + sizeof (uint64_t) * ((pi->num_syscalls + (8 * sizeof (uint64_t) - 1)) 855 / (8 * sizeof (uint64_t))); 856#endif 857} 858 859/* Function: sysset_t_alloc 860 861 Allocate and (partially) initialize a sysset_t struct. */ 862 863static sysset_t * 864sysset_t_alloc (procinfo * pi) 865{ 866 sysset_t *ret; 867 int size = sysset_t_size (pi); 868 ret = xmalloc (size); 869#ifdef DYNAMIC_SYSCALLS 870 ret->pr_size = (pi->num_syscalls + (8 * sizeof (uint64_t) - 1)) 871 / (8 * sizeof (uint64_t)); 872#endif 873 return ret; 874} 875 876#ifdef DYNAMIC_SYSCALLS 877 878/* Function: load_syscalls 879 880 Extract syscall numbers and names from /proc/<pid>/sysent. Initialize 881 pi->num_syscalls with the number of syscalls and pi->syscall_names 882 with the names. (Certain numbers may be skipped in which case the 883 names for these numbers will be left as NULL.) */ 884 885#define MAX_SYSCALL_NAME_LENGTH 256 886#define MAX_SYSCALLS 65536 887 888static void 889load_syscalls (procinfo *pi) 890{ 891 char pathname[MAX_PROC_NAME_SIZE]; 892 int sysent_fd; 893 prsysent_t header; 894 prsyscall_t *syscalls; 895 int i, size, maxcall; 896 897 pi->num_syscalls = 0; 898 pi->syscall_names = 0; 899 900 /* Open the file descriptor for the sysent file */ 901 sprintf (pathname, "/proc/%d/sysent", pi->pid); 902 sysent_fd = open_with_retry (pathname, O_RDONLY); 903 if (sysent_fd < 0) 904 { 905 error (_("load_syscalls: Can't open /proc/%d/sysent"), pi->pid); 906 } 907 908 size = sizeof header - sizeof (prsyscall_t); 909 if (read (sysent_fd, &header, size) != size) 910 { 911 error (_("load_syscalls: Error reading /proc/%d/sysent"), pi->pid); 912 } 913 914 if (header.pr_nsyscalls == 0) 915 { 916 error (_("load_syscalls: /proc/%d/sysent contains no syscalls!"), pi->pid); 917 } 918 919 size = header.pr_nsyscalls * sizeof (prsyscall_t); 920 syscalls = xmalloc (size); 921 922 if (read (sysent_fd, syscalls, size) != size) 923 { 924 xfree (syscalls); 925 error (_("load_syscalls: Error reading /proc/%d/sysent"), pi->pid); 926 } 927 928 /* Find maximum syscall number. This may not be the same as 929 pr_nsyscalls since that value refers to the number of entries 930 in the table. (Also, the docs indicate that some system 931 call numbers may be skipped.) */ 932 933 maxcall = syscalls[0].pr_number; 934 935 for (i = 1; i < header.pr_nsyscalls; i++) 936 if (syscalls[i].pr_number > maxcall 937 && syscalls[i].pr_nameoff > 0 938 && syscalls[i].pr_number < MAX_SYSCALLS) 939 maxcall = syscalls[i].pr_number; 940 941 pi->num_syscalls = maxcall+1; 942 pi->syscall_names = xmalloc (pi->num_syscalls * sizeof (char *)); 943 944 for (i = 0; i < pi->num_syscalls; i++) 945 pi->syscall_names[i] = NULL; 946 947 /* Read the syscall names in */ 948 for (i = 0; i < header.pr_nsyscalls; i++) 949 { 950 char namebuf[MAX_SYSCALL_NAME_LENGTH]; 951 int nread; 952 int callnum; 953 954 if (syscalls[i].pr_number >= MAX_SYSCALLS 955 || syscalls[i].pr_number < 0 956 || syscalls[i].pr_nameoff <= 0 957 || (lseek (sysent_fd, (off_t) syscalls[i].pr_nameoff, SEEK_SET) 958 != (off_t) syscalls[i].pr_nameoff)) 959 continue; 960 961 nread = read (sysent_fd, namebuf, sizeof namebuf); 962 if (nread <= 0) 963 continue; 964 965 callnum = syscalls[i].pr_number; 966 967 if (pi->syscall_names[callnum] != NULL) 968 { 969 /* FIXME: Generate warning */ 970 continue; 971 } 972 973 namebuf[nread-1] = '\0'; 974 size = strlen (namebuf) + 1; 975 pi->syscall_names[callnum] = xmalloc (size); 976 strncpy (pi->syscall_names[callnum], namebuf, size-1); 977 pi->syscall_names[callnum][size-1] = '\0'; 978 } 979 980 close (sysent_fd); 981 xfree (syscalls); 982} 983 984/* Function: free_syscalls 985 986 Free the space allocated for the syscall names from the procinfo 987 structure. */ 988 989static void 990free_syscalls (procinfo *pi) 991{ 992 if (pi->syscall_names) 993 { 994 int i; 995 996 for (i = 0; i < pi->num_syscalls; i++) 997 if (pi->syscall_names[i] != NULL) 998 xfree (pi->syscall_names[i]); 999 1000 xfree (pi->syscall_names); 1001 pi->syscall_names = 0; 1002 } 1003} 1004 1005/* Function: find_syscall 1006 1007 Given a name, look up (and return) the corresponding syscall number. 1008 If no match is found, return -1. */ 1009 1010static int 1011find_syscall (procinfo *pi, char *name) 1012{ 1013 int i; 1014 for (i = 0; i < pi->num_syscalls; i++) 1015 { 1016 if (pi->syscall_names[i] && strcmp (name, pi->syscall_names[i]) == 0) 1017 return i; 1018 } 1019 return -1; 1020} 1021#endif 1022 1023/* =================== END, STRUCT PROCINFO "MODULE" =================== */ 1024 1025/* =================== /proc "MODULE" =================== */ 1026 1027/* 1028 * This "module" is the interface layer between the /proc system API 1029 * and the gdb target vector functions. This layer consists of 1030 * access functions that encapsulate each of the basic operations 1031 * that we need to use from the /proc API. 1032 * 1033 * The main motivation for this layer is to hide the fact that 1034 * there are two very different implementations of the /proc API. 1035 * Rather than have a bunch of #ifdefs all thru the gdb target vector 1036 * functions, we do our best to hide them all in here. 1037 */ 1038 1039int proc_get_status (procinfo * pi); 1040long proc_flags (procinfo * pi); 1041int proc_why (procinfo * pi); 1042int proc_what (procinfo * pi); 1043int proc_set_run_on_last_close (procinfo * pi); 1044int proc_unset_run_on_last_close (procinfo * pi); 1045int proc_set_inherit_on_fork (procinfo * pi); 1046int proc_unset_inherit_on_fork (procinfo * pi); 1047int proc_set_async (procinfo * pi); 1048int proc_unset_async (procinfo * pi); 1049int proc_stop_process (procinfo * pi); 1050int proc_trace_signal (procinfo * pi, int signo); 1051int proc_ignore_signal (procinfo * pi, int signo); 1052int proc_clear_current_fault (procinfo * pi); 1053int proc_set_current_signal (procinfo * pi, int signo); 1054int proc_clear_current_signal (procinfo * pi); 1055int proc_set_gregs (procinfo * pi); 1056int proc_set_fpregs (procinfo * pi); 1057int proc_wait_for_stop (procinfo * pi); 1058int proc_run_process (procinfo * pi, int step, int signo); 1059int proc_kill (procinfo * pi, int signo); 1060int proc_parent_pid (procinfo * pi); 1061int proc_get_nthreads (procinfo * pi); 1062int proc_get_current_thread (procinfo * pi); 1063int proc_set_held_signals (procinfo * pi, gdb_sigset_t * sighold); 1064int proc_set_traced_sysexit (procinfo * pi, sysset_t * sysset); 1065int proc_set_traced_sysentry (procinfo * pi, sysset_t * sysset); 1066int proc_set_traced_faults (procinfo * pi, fltset_t * fltset); 1067int proc_set_traced_signals (procinfo * pi, gdb_sigset_t * sigset); 1068 1069int proc_update_threads (procinfo * pi); 1070int proc_iterate_over_threads (procinfo * pi, 1071 int (*func) (procinfo *, procinfo *, void *), 1072 void *ptr); 1073 1074gdb_gregset_t *proc_get_gregs (procinfo * pi); 1075gdb_fpregset_t *proc_get_fpregs (procinfo * pi); 1076sysset_t *proc_get_traced_sysexit (procinfo * pi, sysset_t * save); 1077sysset_t *proc_get_traced_sysentry (procinfo * pi, sysset_t * save); 1078fltset_t *proc_get_traced_faults (procinfo * pi, fltset_t * save); 1079gdb_sigset_t *proc_get_traced_signals (procinfo * pi, gdb_sigset_t * save); 1080gdb_sigset_t *proc_get_held_signals (procinfo * pi, gdb_sigset_t * save); 1081gdb_sigset_t *proc_get_pending_signals (procinfo * pi, gdb_sigset_t * save); 1082gdb_sigaction_t *proc_get_signal_actions (procinfo * pi, gdb_sigaction_t *save); 1083 1084void proc_warn (procinfo * pi, char *func, int line); 1085void proc_error (procinfo * pi, char *func, int line); 1086 1087void 1088proc_warn (procinfo *pi, char *func, int line) 1089{ 1090 sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname); 1091 print_sys_errmsg (errmsg, errno); 1092} 1093 1094void 1095proc_error (procinfo *pi, char *func, int line) 1096{ 1097 sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname); 1098 perror_with_name (errmsg); 1099} 1100 1101/* 1102 * Function: proc_get_status 1103 * 1104 * Updates the status struct in the procinfo. 1105 * There is a 'valid' flag, to let other functions know when 1106 * this function needs to be called (so the status is only 1107 * read when it is needed). The status file descriptor is 1108 * also only opened when it is needed. 1109 * 1110 * Return: non-zero for success, zero for failure. 1111 */ 1112 1113int 1114proc_get_status (procinfo *pi) 1115{ 1116 /* Status file descriptor is opened "lazily" */ 1117 if (pi->status_fd == 0 && 1118 open_procinfo_files (pi, FD_STATUS) == 0) 1119 { 1120 pi->status_valid = 0; 1121 return 0; 1122 } 1123 1124#ifdef NEW_PROC_API 1125 if (lseek (pi->status_fd, 0, SEEK_SET) < 0) 1126 pi->status_valid = 0; /* fail */ 1127 else 1128 { 1129 /* Sigh... I have to read a different data structure, 1130 depending on whether this is a main process or an LWP. */ 1131 if (pi->tid) 1132 pi->status_valid = (read (pi->status_fd, 1133 (char *) &pi->prstatus.pr_lwp, 1134 sizeof (lwpstatus_t)) 1135 == sizeof (lwpstatus_t)); 1136 else 1137 { 1138 pi->status_valid = (read (pi->status_fd, 1139 (char *) &pi->prstatus, 1140 sizeof (gdb_prstatus_t)) 1141 == sizeof (gdb_prstatus_t)); 1142#if 0 /*def UNIXWARE*/ 1143 if (pi->status_valid && 1144 (pi->prstatus.pr_lwp.pr_flags & PR_ISTOP) && 1145 pi->prstatus.pr_lwp.pr_why == PR_REQUESTED) 1146 /* Unixware peculiarity -- read the damn thing again! */ 1147 pi->status_valid = (read (pi->status_fd, 1148 (char *) &pi->prstatus, 1149 sizeof (gdb_prstatus_t)) 1150 == sizeof (gdb_prstatus_t)); 1151#endif /* UNIXWARE */ 1152 } 1153 } 1154#else /* ioctl method */ 1155#ifdef PIOCTSTATUS /* osf */ 1156 if (pi->tid == 0) /* main process */ 1157 { 1158 /* Just read the danged status. Now isn't that simple? */ 1159 pi->status_valid = 1160 (ioctl (pi->status_fd, PIOCSTATUS, &pi->prstatus) >= 0); 1161 } 1162 else 1163 { 1164 int win; 1165 struct { 1166 long pr_count; 1167 tid_t pr_error_thread; 1168 struct prstatus status; 1169 } thread_status; 1170 1171 thread_status.pr_count = 1; 1172 thread_status.status.pr_tid = pi->tid; 1173 win = (ioctl (pi->status_fd, PIOCTSTATUS, &thread_status) >= 0); 1174 if (win) 1175 { 1176 memcpy (&pi->prstatus, &thread_status.status, 1177 sizeof (pi->prstatus)); 1178 pi->status_valid = 1; 1179 } 1180 } 1181#else 1182 /* Just read the danged status. Now isn't that simple? */ 1183 pi->status_valid = (ioctl (pi->status_fd, PIOCSTATUS, &pi->prstatus) >= 0); 1184#endif 1185#endif 1186 1187 if (pi->status_valid) 1188 { 1189 PROC_PRETTYFPRINT_STATUS (proc_flags (pi), 1190 proc_why (pi), 1191 proc_what (pi), 1192 proc_get_current_thread (pi)); 1193 } 1194 1195 /* The status struct includes general regs, so mark them valid too */ 1196 pi->gregs_valid = pi->status_valid; 1197#ifdef NEW_PROC_API 1198 /* In the read/write multiple-fd model, 1199 the status struct includes the fp regs too, so mark them valid too */ 1200 pi->fpregs_valid = pi->status_valid; 1201#endif 1202 return pi->status_valid; /* True if success, false if failure. */ 1203} 1204 1205/* 1206 * Function: proc_flags 1207 * 1208 * returns the process flags (pr_flags field). 1209 */ 1210 1211long 1212proc_flags (procinfo *pi) 1213{ 1214 if (!pi->status_valid) 1215 if (!proc_get_status (pi)) 1216 return 0; /* FIXME: not a good failure value (but what is?) */ 1217 1218#ifdef NEW_PROC_API 1219# ifdef UNIXWARE 1220 /* UnixWare 7.1 puts process status flags, e.g. PR_ASYNC, in 1221 pstatus_t and LWP status flags, e.g. PR_STOPPED, in lwpstatus_t. 1222 The two sets of flags don't overlap. */ 1223 return pi->prstatus.pr_flags | pi->prstatus.pr_lwp.pr_flags; 1224# else 1225 return pi->prstatus.pr_lwp.pr_flags; 1226# endif 1227#else 1228 return pi->prstatus.pr_flags; 1229#endif 1230} 1231 1232/* 1233 * Function: proc_why 1234 * 1235 * returns the pr_why field (why the process stopped). 1236 */ 1237 1238int 1239proc_why (procinfo *pi) 1240{ 1241 if (!pi->status_valid) 1242 if (!proc_get_status (pi)) 1243 return 0; /* FIXME: not a good failure value (but what is?) */ 1244 1245#ifdef NEW_PROC_API 1246 return pi->prstatus.pr_lwp.pr_why; 1247#else 1248 return pi->prstatus.pr_why; 1249#endif 1250} 1251 1252/* 1253 * Function: proc_what 1254 * 1255 * returns the pr_what field (details of why the process stopped). 1256 */ 1257 1258int 1259proc_what (procinfo *pi) 1260{ 1261 if (!pi->status_valid) 1262 if (!proc_get_status (pi)) 1263 return 0; /* FIXME: not a good failure value (but what is?) */ 1264 1265#ifdef NEW_PROC_API 1266 return pi->prstatus.pr_lwp.pr_what; 1267#else 1268 return pi->prstatus.pr_what; 1269#endif 1270} 1271 1272#ifndef PIOCSSPCACT /* The following is not supported on OSF. */ 1273/* 1274 * Function: proc_nsysarg 1275 * 1276 * returns the pr_nsysarg field (number of args to the current syscall). 1277 */ 1278 1279int 1280proc_nsysarg (procinfo *pi) 1281{ 1282 if (!pi->status_valid) 1283 if (!proc_get_status (pi)) 1284 return 0; 1285 1286#ifdef NEW_PROC_API 1287 return pi->prstatus.pr_lwp.pr_nsysarg; 1288#else 1289 return pi->prstatus.pr_nsysarg; 1290#endif 1291} 1292 1293/* 1294 * Function: proc_sysargs 1295 * 1296 * returns the pr_sysarg field (pointer to the arguments of current syscall). 1297 */ 1298 1299long * 1300proc_sysargs (procinfo *pi) 1301{ 1302 if (!pi->status_valid) 1303 if (!proc_get_status (pi)) 1304 return NULL; 1305 1306#ifdef NEW_PROC_API 1307 return (long *) &pi->prstatus.pr_lwp.pr_sysarg; 1308#else 1309 return (long *) &pi->prstatus.pr_sysarg; 1310#endif 1311} 1312 1313/* 1314 * Function: proc_syscall 1315 * 1316 * returns the pr_syscall field (id of current syscall if we are in one). 1317 */ 1318 1319int 1320proc_syscall (procinfo *pi) 1321{ 1322 if (!pi->status_valid) 1323 if (!proc_get_status (pi)) 1324 return 0; 1325 1326#ifdef NEW_PROC_API 1327 return pi->prstatus.pr_lwp.pr_syscall; 1328#else 1329 return pi->prstatus.pr_syscall; 1330#endif 1331} 1332#endif /* PIOCSSPCACT */ 1333 1334/* 1335 * Function: proc_cursig: 1336 * 1337 * returns the pr_cursig field (current signal). 1338 */ 1339 1340long 1341proc_cursig (struct procinfo *pi) 1342{ 1343 if (!pi->status_valid) 1344 if (!proc_get_status (pi)) 1345 return 0; /* FIXME: not a good failure value (but what is?) */ 1346 1347#ifdef NEW_PROC_API 1348 return pi->prstatus.pr_lwp.pr_cursig; 1349#else 1350 return pi->prstatus.pr_cursig; 1351#endif 1352} 1353 1354/* 1355 * Function: proc_modify_flag 1356 * 1357 * === I appologize for the messiness of this function. 1358 * === This is an area where the different versions of 1359 * === /proc are more inconsistent than usual. MVS 1360 * 1361 * Set or reset any of the following process flags: 1362 * PR_FORK -- forked child will inherit trace flags 1363 * PR_RLC -- traced process runs when last /proc file closed. 1364 * PR_KLC -- traced process is killed when last /proc file closed. 1365 * PR_ASYNC -- LWP's get to run/stop independently. 1366 * 1367 * There are three methods for doing this function: 1368 * 1) Newest: read/write [PCSET/PCRESET/PCUNSET] 1369 * [Sol6, Sol7, UW] 1370 * 2) Middle: PIOCSET/PIOCRESET 1371 * [Irix, Sol5] 1372 * 3) Oldest: PIOCSFORK/PIOCRFORK/PIOCSRLC/PIOCRRLC 1373 * [OSF, Sol5] 1374 * 1375 * Note: Irix does not define PR_ASYNC. 1376 * Note: OSF does not define PR_KLC. 1377 * Note: OSF is the only one that can ONLY use the oldest method. 1378 * 1379 * Arguments: 1380 * pi -- the procinfo 1381 * flag -- one of PR_FORK, PR_RLC, or PR_ASYNC 1382 * mode -- 1 for set, 0 for reset. 1383 * 1384 * Returns non-zero for success, zero for failure. 1385 */ 1386 1387enum { FLAG_RESET, FLAG_SET }; 1388 1389static int 1390proc_modify_flag (procinfo *pi, long flag, long mode) 1391{ 1392 long win = 0; /* default to fail */ 1393 1394 /* 1395 * These operations affect the process as a whole, and applying 1396 * them to an individual LWP has the same meaning as applying them 1397 * to the main process. Therefore, if we're ever called with a 1398 * pointer to an LWP's procinfo, let's substitute the process's 1399 * procinfo and avoid opening the LWP's file descriptor 1400 * unnecessarily. 1401 */ 1402 1403 if (pi->pid != 0) 1404 pi = find_procinfo_or_die (pi->pid, 0); 1405 1406#ifdef NEW_PROC_API /* Newest method: UnixWare and newer Solarii */ 1407 /* First normalize the PCUNSET/PCRESET command opcode 1408 (which for no obvious reason has a different definition 1409 from one operating system to the next...) */ 1410#ifdef PCUNSET 1411#define GDBRESET PCUNSET 1412#else 1413#ifdef PCRESET 1414#define GDBRESET PCRESET 1415#endif 1416#endif 1417 { 1418 procfs_ctl_t arg[2]; 1419 1420 if (mode == FLAG_SET) /* Set the flag (RLC, FORK, or ASYNC) */ 1421 arg[0] = PCSET; 1422 else /* Reset the flag */ 1423 arg[0] = GDBRESET; 1424 1425 arg[1] = flag; 1426 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg)); 1427 } 1428#else 1429#ifdef PIOCSET /* Irix/Sol5 method */ 1430 if (mode == FLAG_SET) /* Set the flag (hopefully RLC, FORK, or ASYNC) */ 1431 { 1432 win = (ioctl (pi->ctl_fd, PIOCSET, &flag) >= 0); 1433 } 1434 else /* Reset the flag */ 1435 { 1436 win = (ioctl (pi->ctl_fd, PIOCRESET, &flag) >= 0); 1437 } 1438 1439#else 1440#ifdef PIOCSRLC /* Oldest method: OSF */ 1441 switch (flag) { 1442 case PR_RLC: 1443 if (mode == FLAG_SET) /* Set run-on-last-close */ 1444 { 1445 win = (ioctl (pi->ctl_fd, PIOCSRLC, NULL) >= 0); 1446 } 1447 else /* Clear run-on-last-close */ 1448 { 1449 win = (ioctl (pi->ctl_fd, PIOCRRLC, NULL) >= 0); 1450 } 1451 break; 1452 case PR_FORK: 1453 if (mode == FLAG_SET) /* Set inherit-on-fork */ 1454 { 1455 win = (ioctl (pi->ctl_fd, PIOCSFORK, NULL) >= 0); 1456 } 1457 else /* Clear inherit-on-fork */ 1458 { 1459 win = (ioctl (pi->ctl_fd, PIOCRFORK, NULL) >= 0); 1460 } 1461 break; 1462 default: 1463 win = 0; /* fail -- unknown flag (can't do PR_ASYNC) */ 1464 break; 1465 } 1466#endif 1467#endif 1468#endif 1469#undef GDBRESET 1470 /* The above operation renders the procinfo's cached pstatus obsolete. */ 1471 pi->status_valid = 0; 1472 1473 if (!win) 1474 warning (_("procfs: modify_flag failed to turn %s %s"), 1475 flag == PR_FORK ? "PR_FORK" : 1476 flag == PR_RLC ? "PR_RLC" : 1477#ifdef PR_ASYNC 1478 flag == PR_ASYNC ? "PR_ASYNC" : 1479#endif 1480#ifdef PR_KLC 1481 flag == PR_KLC ? "PR_KLC" : 1482#endif 1483 "<unknown flag>", 1484 mode == FLAG_RESET ? "off" : "on"); 1485 1486 return win; 1487} 1488 1489/* 1490 * Function: proc_set_run_on_last_close 1491 * 1492 * Set the run_on_last_close flag. 1493 * Process with all threads will become runnable 1494 * when debugger closes all /proc fds. 1495 * 1496 * Returns non-zero for success, zero for failure. 1497 */ 1498 1499int 1500proc_set_run_on_last_close (procinfo *pi) 1501{ 1502 return proc_modify_flag (pi, PR_RLC, FLAG_SET); 1503} 1504 1505/* 1506 * Function: proc_unset_run_on_last_close 1507 * 1508 * Reset the run_on_last_close flag. 1509 * Process will NOT become runnable 1510 * when debugger closes its file handles. 1511 * 1512 * Returns non-zero for success, zero for failure. 1513 */ 1514 1515int 1516proc_unset_run_on_last_close (procinfo *pi) 1517{ 1518 return proc_modify_flag (pi, PR_RLC, FLAG_RESET); 1519} 1520 1521#ifdef PR_KLC 1522/* 1523 * Function: proc_set_kill_on_last_close 1524 * 1525 * Set the kill_on_last_close flag. 1526 * Process with all threads will be killed when debugger 1527 * closes all /proc fds (or debugger exits or dies). 1528 * 1529 * Returns non-zero for success, zero for failure. 1530 */ 1531 1532int 1533proc_set_kill_on_last_close (procinfo *pi) 1534{ 1535 return proc_modify_flag (pi, PR_KLC, FLAG_SET); 1536} 1537 1538/* 1539 * Function: proc_unset_kill_on_last_close 1540 * 1541 * Reset the kill_on_last_close flag. 1542 * Process will NOT be killed when debugger 1543 * closes its file handles (or exits or dies). 1544 * 1545 * Returns non-zero for success, zero for failure. 1546 */ 1547 1548int 1549proc_unset_kill_on_last_close (procinfo *pi) 1550{ 1551 return proc_modify_flag (pi, PR_KLC, FLAG_RESET); 1552} 1553#endif /* PR_KLC */ 1554 1555/* 1556 * Function: proc_set_inherit_on_fork 1557 * 1558 * Set inherit_on_fork flag. 1559 * If the process forks a child while we are registered for events 1560 * in the parent, then we will also recieve events from the child. 1561 * 1562 * Returns non-zero for success, zero for failure. 1563 */ 1564 1565int 1566proc_set_inherit_on_fork (procinfo *pi) 1567{ 1568 return proc_modify_flag (pi, PR_FORK, FLAG_SET); 1569} 1570 1571/* 1572 * Function: proc_unset_inherit_on_fork 1573 * 1574 * Reset inherit_on_fork flag. 1575 * If the process forks a child while we are registered for events 1576 * in the parent, then we will NOT recieve events from the child. 1577 * 1578 * Returns non-zero for success, zero for failure. 1579 */ 1580 1581int 1582proc_unset_inherit_on_fork (procinfo *pi) 1583{ 1584 return proc_modify_flag (pi, PR_FORK, FLAG_RESET); 1585} 1586 1587#ifdef PR_ASYNC 1588/* 1589 * Function: proc_set_async 1590 * 1591 * Set PR_ASYNC flag. 1592 * If one LWP stops because of a debug event (signal etc.), 1593 * the remaining LWPs will continue to run. 1594 * 1595 * Returns non-zero for success, zero for failure. 1596 */ 1597 1598int 1599proc_set_async (procinfo *pi) 1600{ 1601 return proc_modify_flag (pi, PR_ASYNC, FLAG_SET); 1602} 1603 1604/* 1605 * Function: proc_unset_async 1606 * 1607 * Reset PR_ASYNC flag. 1608 * If one LWP stops because of a debug event (signal etc.), 1609 * then all other LWPs will stop as well. 1610 * 1611 * Returns non-zero for success, zero for failure. 1612 */ 1613 1614int 1615proc_unset_async (procinfo *pi) 1616{ 1617 return proc_modify_flag (pi, PR_ASYNC, FLAG_RESET); 1618} 1619#endif /* PR_ASYNC */ 1620 1621/* 1622 * Function: proc_stop_process 1623 * 1624 * Request the process/LWP to stop. Does not wait. 1625 * Returns non-zero for success, zero for failure. 1626 */ 1627 1628int 1629proc_stop_process (procinfo *pi) 1630{ 1631 int win; 1632 1633 /* 1634 * We might conceivably apply this operation to an LWP, and 1635 * the LWP's ctl file descriptor might not be open. 1636 */ 1637 1638 if (pi->ctl_fd == 0 && 1639 open_procinfo_files (pi, FD_CTL) == 0) 1640 return 0; 1641 else 1642 { 1643#ifdef NEW_PROC_API 1644 procfs_ctl_t cmd = PCSTOP; 1645 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd)); 1646#else /* ioctl method */ 1647 win = (ioctl (pi->ctl_fd, PIOCSTOP, &pi->prstatus) >= 0); 1648 /* Note: the call also reads the prstatus. */ 1649 if (win) 1650 { 1651 pi->status_valid = 1; 1652 PROC_PRETTYFPRINT_STATUS (proc_flags (pi), 1653 proc_why (pi), 1654 proc_what (pi), 1655 proc_get_current_thread (pi)); 1656 } 1657#endif 1658 } 1659 1660 return win; 1661} 1662 1663/* 1664 * Function: proc_wait_for_stop 1665 * 1666 * Wait for the process or LWP to stop (block until it does). 1667 * Returns non-zero for success, zero for failure. 1668 */ 1669 1670int 1671proc_wait_for_stop (procinfo *pi) 1672{ 1673 int win; 1674 1675 /* 1676 * We should never have to apply this operation to any procinfo 1677 * except the one for the main process. If that ever changes 1678 * for any reason, then take out the following clause and 1679 * replace it with one that makes sure the ctl_fd is open. 1680 */ 1681 1682 if (pi->tid != 0) 1683 pi = find_procinfo_or_die (pi->pid, 0); 1684 1685#ifdef NEW_PROC_API 1686 { 1687 procfs_ctl_t cmd = PCWSTOP; 1688 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd)); 1689 /* We been runnin' and we stopped -- need to update status. */ 1690 pi->status_valid = 0; 1691 } 1692#else /* ioctl method */ 1693 win = (ioctl (pi->ctl_fd, PIOCWSTOP, &pi->prstatus) >= 0); 1694 /* Above call also refreshes the prstatus. */ 1695 if (win) 1696 { 1697 pi->status_valid = 1; 1698 PROC_PRETTYFPRINT_STATUS (proc_flags (pi), 1699 proc_why (pi), 1700 proc_what (pi), 1701 proc_get_current_thread (pi)); 1702 } 1703#endif 1704 1705 return win; 1706} 1707 1708/* 1709 * Function: proc_run_process 1710 * 1711 * Make the process or LWP runnable. 1712 * Options (not all are implemented): 1713 * - single-step 1714 * - clear current fault 1715 * - clear current signal 1716 * - abort the current system call 1717 * - stop as soon as finished with system call 1718 * - (ioctl): set traced signal set 1719 * - (ioctl): set held signal set 1720 * - (ioctl): set traced fault set 1721 * - (ioctl): set start pc (vaddr) 1722 * Always clear the current fault. 1723 * Clear the current signal if 'signo' is zero. 1724 * 1725 * Arguments: 1726 * pi the process or LWP to operate on. 1727 * step if true, set the process or LWP to trap after one instr. 1728 * signo if zero, clear the current signal if any. 1729 * if non-zero, set the current signal to this one. 1730 * 1731 * Returns non-zero for success, zero for failure. 1732 */ 1733 1734int 1735proc_run_process (procinfo *pi, int step, int signo) 1736{ 1737 int win; 1738 int runflags; 1739 1740 /* 1741 * We will probably have to apply this operation to individual threads, 1742 * so make sure the control file descriptor is open. 1743 */ 1744 1745 if (pi->ctl_fd == 0 && 1746 open_procinfo_files (pi, FD_CTL) == 0) 1747 { 1748 return 0; 1749 } 1750 1751 runflags = PRCFAULT; /* always clear current fault */ 1752 if (step) 1753 runflags |= PRSTEP; 1754 if (signo == 0) 1755 runflags |= PRCSIG; 1756 else if (signo != -1) /* -1 means do nothing W.R.T. signals */ 1757 proc_set_current_signal (pi, signo); 1758 1759#ifdef NEW_PROC_API 1760 { 1761 procfs_ctl_t cmd[2]; 1762 1763 cmd[0] = PCRUN; 1764 cmd[1] = runflags; 1765 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd)); 1766 } 1767#else /* ioctl method */ 1768 { 1769 prrun_t prrun; 1770 1771 memset (&prrun, 0, sizeof (prrun)); 1772 prrun.pr_flags = runflags; 1773 win = (ioctl (pi->ctl_fd, PIOCRUN, &prrun) >= 0); 1774 } 1775#endif 1776 1777 return win; 1778} 1779 1780/* 1781 * Function: proc_set_traced_signals 1782 * 1783 * Register to trace signals in the process or LWP. 1784 * Returns non-zero for success, zero for failure. 1785 */ 1786 1787int 1788proc_set_traced_signals (procinfo *pi, gdb_sigset_t *sigset) 1789{ 1790 int win; 1791 1792 /* 1793 * We should never have to apply this operation to any procinfo 1794 * except the one for the main process. If that ever changes 1795 * for any reason, then take out the following clause and 1796 * replace it with one that makes sure the ctl_fd is open. 1797 */ 1798 1799 if (pi->tid != 0) 1800 pi = find_procinfo_or_die (pi->pid, 0); 1801 1802#ifdef NEW_PROC_API 1803 { 1804 struct { 1805 procfs_ctl_t cmd; 1806 /* Use char array to avoid alignment issues. */ 1807 char sigset[sizeof (gdb_sigset_t)]; 1808 } arg; 1809 1810 arg.cmd = PCSTRACE; 1811 memcpy (&arg.sigset, sigset, sizeof (gdb_sigset_t)); 1812 1813 win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg)); 1814 } 1815#else /* ioctl method */ 1816 win = (ioctl (pi->ctl_fd, PIOCSTRACE, sigset) >= 0); 1817#endif 1818 /* The above operation renders the procinfo's cached pstatus obsolete. */ 1819 pi->status_valid = 0; 1820 1821 if (!win) 1822 warning (_("procfs: set_traced_signals failed")); 1823 return win; 1824} 1825 1826/* 1827 * Function: proc_set_traced_faults 1828 * 1829 * Register to trace hardware faults in the process or LWP. 1830 * Returns non-zero for success, zero for failure. 1831 */ 1832 1833int 1834proc_set_traced_faults (procinfo *pi, fltset_t *fltset) 1835{ 1836 int win; 1837 1838 /* 1839 * We should never have to apply this operation to any procinfo 1840 * except the one for the main process. If that ever changes 1841 * for any reason, then take out the following clause and 1842 * replace it with one that makes sure the ctl_fd is open. 1843 */ 1844 1845 if (pi->tid != 0) 1846 pi = find_procinfo_or_die (pi->pid, 0); 1847 1848#ifdef NEW_PROC_API 1849 { 1850 struct { 1851 procfs_ctl_t cmd; 1852 /* Use char array to avoid alignment issues. */ 1853 char fltset[sizeof (fltset_t)]; 1854 } arg; 1855 1856 arg.cmd = PCSFAULT; 1857 memcpy (&arg.fltset, fltset, sizeof (fltset_t)); 1858 1859 win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg)); 1860 } 1861#else /* ioctl method */ 1862 win = (ioctl (pi->ctl_fd, PIOCSFAULT, fltset) >= 0); 1863#endif 1864 /* The above operation renders the procinfo's cached pstatus obsolete. */ 1865 pi->status_valid = 0; 1866 1867 return win; 1868} 1869 1870/* 1871 * Function: proc_set_traced_sysentry 1872 * 1873 * Register to trace entry to system calls in the process or LWP. 1874 * Returns non-zero for success, zero for failure. 1875 */ 1876 1877int 1878proc_set_traced_sysentry (procinfo *pi, sysset_t *sysset) 1879{ 1880 int win; 1881 1882 /* 1883 * We should never have to apply this operation to any procinfo 1884 * except the one for the main process. If that ever changes 1885 * for any reason, then take out the following clause and 1886 * replace it with one that makes sure the ctl_fd is open. 1887 */ 1888 1889 if (pi->tid != 0) 1890 pi = find_procinfo_or_die (pi->pid, 0); 1891 1892#ifdef NEW_PROC_API 1893 { 1894 struct gdb_proc_ctl_pcsentry { 1895 procfs_ctl_t cmd; 1896 /* Use char array to avoid alignment issues. */ 1897 char sysset[sizeof (sysset_t)]; 1898 } *argp; 1899 int argp_size = sizeof (struct gdb_proc_ctl_pcsentry) 1900 - sizeof (sysset_t) 1901 + sysset_t_size (pi); 1902 1903 argp = xmalloc (argp_size); 1904 1905 argp->cmd = PCSENTRY; 1906 memcpy (&argp->sysset, sysset, sysset_t_size (pi)); 1907 1908 win = (write (pi->ctl_fd, (char *) argp, argp_size) == argp_size); 1909 xfree (argp); 1910 } 1911#else /* ioctl method */ 1912 win = (ioctl (pi->ctl_fd, PIOCSENTRY, sysset) >= 0); 1913#endif 1914 /* The above operation renders the procinfo's cached pstatus obsolete. */ 1915 pi->status_valid = 0; 1916 1917 return win; 1918} 1919 1920/* 1921 * Function: proc_set_traced_sysexit 1922 * 1923 * Register to trace exit from system calls in the process or LWP. 1924 * Returns non-zero for success, zero for failure. 1925 */ 1926 1927int 1928proc_set_traced_sysexit (procinfo *pi, sysset_t *sysset) 1929{ 1930 int win; 1931 1932 /* 1933 * We should never have to apply this operation to any procinfo 1934 * except the one for the main process. If that ever changes 1935 * for any reason, then take out the following clause and 1936 * replace it with one that makes sure the ctl_fd is open. 1937 */ 1938 1939 if (pi->tid != 0) 1940 pi = find_procinfo_or_die (pi->pid, 0); 1941 1942#ifdef NEW_PROC_API 1943 { 1944 struct gdb_proc_ctl_pcsexit { 1945 procfs_ctl_t cmd; 1946 /* Use char array to avoid alignment issues. */ 1947 char sysset[sizeof (sysset_t)]; 1948 } *argp; 1949 int argp_size = sizeof (struct gdb_proc_ctl_pcsexit) 1950 - sizeof (sysset_t) 1951 + sysset_t_size (pi); 1952 1953 argp = xmalloc (argp_size); 1954 1955 argp->cmd = PCSEXIT; 1956 memcpy (&argp->sysset, sysset, sysset_t_size (pi)); 1957 1958 win = (write (pi->ctl_fd, (char *) argp, argp_size) == argp_size); 1959 xfree (argp); 1960 } 1961#else /* ioctl method */ 1962 win = (ioctl (pi->ctl_fd, PIOCSEXIT, sysset) >= 0); 1963#endif 1964 /* The above operation renders the procinfo's cached pstatus obsolete. */ 1965 pi->status_valid = 0; 1966 1967 return win; 1968} 1969 1970/* 1971 * Function: proc_set_held_signals 1972 * 1973 * Specify the set of blocked / held signals in the process or LWP. 1974 * Returns non-zero for success, zero for failure. 1975 */ 1976 1977int 1978proc_set_held_signals (procinfo *pi, gdb_sigset_t *sighold) 1979{ 1980 int win; 1981 1982 /* 1983 * We should never have to apply this operation to any procinfo 1984 * except the one for the main process. If that ever changes 1985 * for any reason, then take out the following clause and 1986 * replace it with one that makes sure the ctl_fd is open. 1987 */ 1988 1989 if (pi->tid != 0) 1990 pi = find_procinfo_or_die (pi->pid, 0); 1991 1992#ifdef NEW_PROC_API 1993 { 1994 struct { 1995 procfs_ctl_t cmd; 1996 /* Use char array to avoid alignment issues. */ 1997 char hold[sizeof (gdb_sigset_t)]; 1998 } arg; 1999 2000 arg.cmd = PCSHOLD; 2001 memcpy (&arg.hold, sighold, sizeof (gdb_sigset_t)); 2002 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg)); 2003 } 2004#else 2005 win = (ioctl (pi->ctl_fd, PIOCSHOLD, sighold) >= 0); 2006#endif 2007 /* The above operation renders the procinfo's cached pstatus obsolete. */ 2008 pi->status_valid = 0; 2009 2010 return win; 2011} 2012 2013/* 2014 * Function: proc_get_pending_signals 2015 * 2016 * returns the set of signals that are pending in the process or LWP. 2017 * Will also copy the sigset if 'save' is non-zero. 2018 */ 2019 2020gdb_sigset_t * 2021proc_get_pending_signals (procinfo *pi, gdb_sigset_t *save) 2022{ 2023 gdb_sigset_t *ret = NULL; 2024 2025 /* 2026 * We should never have to apply this operation to any procinfo 2027 * except the one for the main process. If that ever changes 2028 * for any reason, then take out the following clause and 2029 * replace it with one that makes sure the ctl_fd is open. 2030 */ 2031 2032 if (pi->tid != 0) 2033 pi = find_procinfo_or_die (pi->pid, 0); 2034 2035 if (!pi->status_valid) 2036 if (!proc_get_status (pi)) 2037 return NULL; 2038 2039#ifdef NEW_PROC_API 2040 ret = &pi->prstatus.pr_lwp.pr_lwppend; 2041#else 2042 ret = &pi->prstatus.pr_sigpend; 2043#endif 2044 if (save && ret) 2045 memcpy (save, ret, sizeof (gdb_sigset_t)); 2046 2047 return ret; 2048} 2049 2050/* 2051 * Function: proc_get_signal_actions 2052 * 2053 * returns the set of signal actions. 2054 * Will also copy the sigactionset if 'save' is non-zero. 2055 */ 2056 2057gdb_sigaction_t * 2058proc_get_signal_actions (procinfo *pi, gdb_sigaction_t *save) 2059{ 2060 gdb_sigaction_t *ret = NULL; 2061 2062 /* 2063 * We should never have to apply this operation to any procinfo 2064 * except the one for the main process. If that ever changes 2065 * for any reason, then take out the following clause and 2066 * replace it with one that makes sure the ctl_fd is open. 2067 */ 2068 2069 if (pi->tid != 0) 2070 pi = find_procinfo_or_die (pi->pid, 0); 2071 2072 if (!pi->status_valid) 2073 if (!proc_get_status (pi)) 2074 return NULL; 2075 2076#ifdef NEW_PROC_API 2077 ret = &pi->prstatus.pr_lwp.pr_action; 2078#else 2079 ret = &pi->prstatus.pr_action; 2080#endif 2081 if (save && ret) 2082 memcpy (save, ret, sizeof (gdb_sigaction_t)); 2083 2084 return ret; 2085} 2086 2087/* 2088 * Function: proc_get_held_signals 2089 * 2090 * returns the set of signals that are held / blocked. 2091 * Will also copy the sigset if 'save' is non-zero. 2092 */ 2093 2094gdb_sigset_t * 2095proc_get_held_signals (procinfo *pi, gdb_sigset_t *save) 2096{ 2097 gdb_sigset_t *ret = NULL; 2098 2099 /* 2100 * We should never have to apply this operation to any procinfo 2101 * except the one for the main process. If that ever changes 2102 * for any reason, then take out the following clause and 2103 * replace it with one that makes sure the ctl_fd is open. 2104 */ 2105 2106 if (pi->tid != 0) 2107 pi = find_procinfo_or_die (pi->pid, 0); 2108 2109#ifdef NEW_PROC_API 2110 if (!pi->status_valid) 2111 if (!proc_get_status (pi)) 2112 return NULL; 2113 2114#ifdef UNIXWARE 2115 ret = &pi->prstatus.pr_lwp.pr_context.uc_sigmask; 2116#else 2117 ret = &pi->prstatus.pr_lwp.pr_lwphold; 2118#endif /* UNIXWARE */ 2119#else /* not NEW_PROC_API */ 2120 { 2121 static gdb_sigset_t sigheld; 2122 2123 if (ioctl (pi->ctl_fd, PIOCGHOLD, &sigheld) >= 0) 2124 ret = &sigheld; 2125 } 2126#endif /* NEW_PROC_API */ 2127 if (save && ret) 2128 memcpy (save, ret, sizeof (gdb_sigset_t)); 2129 2130 return ret; 2131} 2132 2133/* 2134 * Function: proc_get_traced_signals 2135 * 2136 * returns the set of signals that are traced / debugged. 2137 * Will also copy the sigset if 'save' is non-zero. 2138 */ 2139 2140gdb_sigset_t * 2141proc_get_traced_signals (procinfo *pi, gdb_sigset_t *save) 2142{ 2143 gdb_sigset_t *ret = NULL; 2144 2145 /* 2146 * We should never have to apply this operation to any procinfo 2147 * except the one for the main process. If that ever changes 2148 * for any reason, then take out the following clause and 2149 * replace it with one that makes sure the ctl_fd is open. 2150 */ 2151 2152 if (pi->tid != 0) 2153 pi = find_procinfo_or_die (pi->pid, 0); 2154 2155#ifdef NEW_PROC_API 2156 if (!pi->status_valid) 2157 if (!proc_get_status (pi)) 2158 return NULL; 2159 2160 ret = &pi->prstatus.pr_sigtrace; 2161#else 2162 { 2163 static gdb_sigset_t sigtrace; 2164 2165 if (ioctl (pi->ctl_fd, PIOCGTRACE, &sigtrace) >= 0) 2166 ret = &sigtrace; 2167 } 2168#endif 2169 if (save && ret) 2170 memcpy (save, ret, sizeof (gdb_sigset_t)); 2171 2172 return ret; 2173} 2174 2175/* 2176 * Function: proc_trace_signal 2177 * 2178 * Add 'signo' to the set of signals that are traced. 2179 * Returns non-zero for success, zero for failure. 2180 */ 2181 2182int 2183proc_trace_signal (procinfo *pi, int signo) 2184{ 2185 gdb_sigset_t temp; 2186 2187 /* 2188 * We should never have to apply this operation to any procinfo 2189 * except the one for the main process. If that ever changes 2190 * for any reason, then take out the following clause and 2191 * replace it with one that makes sure the ctl_fd is open. 2192 */ 2193 2194 if (pi->tid != 0) 2195 pi = find_procinfo_or_die (pi->pid, 0); 2196 2197 if (pi) 2198 { 2199 if (proc_get_traced_signals (pi, &temp)) 2200 { 2201 praddset (&temp, signo); 2202 return proc_set_traced_signals (pi, &temp); 2203 } 2204 } 2205 2206 return 0; /* failure */ 2207} 2208 2209/* 2210 * Function: proc_ignore_signal 2211 * 2212 * Remove 'signo' from the set of signals that are traced. 2213 * Returns non-zero for success, zero for failure. 2214 */ 2215 2216int 2217proc_ignore_signal (procinfo *pi, int signo) 2218{ 2219 gdb_sigset_t temp; 2220 2221 /* 2222 * We should never have to apply this operation to any procinfo 2223 * except the one for the main process. If that ever changes 2224 * for any reason, then take out the following clause and 2225 * replace it with one that makes sure the ctl_fd is open. 2226 */ 2227 2228 if (pi->tid != 0) 2229 pi = find_procinfo_or_die (pi->pid, 0); 2230 2231 if (pi) 2232 { 2233 if (proc_get_traced_signals (pi, &temp)) 2234 { 2235 prdelset (&temp, signo); 2236 return proc_set_traced_signals (pi, &temp); 2237 } 2238 } 2239 2240 return 0; /* failure */ 2241} 2242 2243/* 2244 * Function: proc_get_traced_faults 2245 * 2246 * returns the set of hardware faults that are traced /debugged. 2247 * Will also copy the faultset if 'save' is non-zero. 2248 */ 2249 2250fltset_t * 2251proc_get_traced_faults (procinfo *pi, fltset_t *save) 2252{ 2253 fltset_t *ret = NULL; 2254 2255 /* 2256 * We should never have to apply this operation to any procinfo 2257 * except the one for the main process. If that ever changes 2258 * for any reason, then take out the following clause and 2259 * replace it with one that makes sure the ctl_fd is open. 2260 */ 2261 2262 if (pi->tid != 0) 2263 pi = find_procinfo_or_die (pi->pid, 0); 2264 2265#ifdef NEW_PROC_API 2266 if (!pi->status_valid) 2267 if (!proc_get_status (pi)) 2268 return NULL; 2269 2270 ret = &pi->prstatus.pr_flttrace; 2271#else 2272 { 2273 static fltset_t flttrace; 2274 2275 if (ioctl (pi->ctl_fd, PIOCGFAULT, &flttrace) >= 0) 2276 ret = &flttrace; 2277 } 2278#endif 2279 if (save && ret) 2280 memcpy (save, ret, sizeof (fltset_t)); 2281 2282 return ret; 2283} 2284 2285/* 2286 * Function: proc_get_traced_sysentry 2287 * 2288 * returns the set of syscalls that are traced /debugged on entry. 2289 * Will also copy the syscall set if 'save' is non-zero. 2290 */ 2291 2292sysset_t * 2293proc_get_traced_sysentry (procinfo *pi, sysset_t *save) 2294{ 2295 sysset_t *ret = NULL; 2296 2297 /* 2298 * We should never have to apply this operation to any procinfo 2299 * except the one for the main process. If that ever changes 2300 * for any reason, then take out the following clause and 2301 * replace it with one that makes sure the ctl_fd is open. 2302 */ 2303 2304 if (pi->tid != 0) 2305 pi = find_procinfo_or_die (pi->pid, 0); 2306 2307#ifdef NEW_PROC_API 2308 if (!pi->status_valid) 2309 if (!proc_get_status (pi)) 2310 return NULL; 2311 2312#ifndef DYNAMIC_SYSCALLS 2313 ret = &pi->prstatus.pr_sysentry; 2314#else /* DYNAMIC_SYSCALLS */ 2315 { 2316 static sysset_t *sysentry; 2317 size_t size; 2318 2319 if (!sysentry) 2320 sysentry = sysset_t_alloc (pi); 2321 ret = sysentry; 2322 if (pi->status_fd == 0 && open_procinfo_files (pi, FD_STATUS) == 0) 2323 return NULL; 2324 if (pi->prstatus.pr_sysentry_offset == 0) 2325 { 2326 gdb_premptysysset (sysentry); 2327 } 2328 else 2329 { 2330 int rsize; 2331 2332 if (lseek (pi->status_fd, (off_t) pi->prstatus.pr_sysentry_offset, 2333 SEEK_SET) 2334 != (off_t) pi->prstatus.pr_sysentry_offset) 2335 return NULL; 2336 size = sysset_t_size (pi); 2337 gdb_premptysysset (sysentry); 2338 rsize = read (pi->status_fd, sysentry, size); 2339 if (rsize < 0) 2340 return NULL; 2341 } 2342 } 2343#endif /* DYNAMIC_SYSCALLS */ 2344#else /* !NEW_PROC_API */ 2345 { 2346 static sysset_t sysentry; 2347 2348 if (ioctl (pi->ctl_fd, PIOCGENTRY, &sysentry) >= 0) 2349 ret = &sysentry; 2350 } 2351#endif /* NEW_PROC_API */ 2352 if (save && ret) 2353 memcpy (save, ret, sysset_t_size (pi)); 2354 2355 return ret; 2356} 2357 2358/* 2359 * Function: proc_get_traced_sysexit 2360 * 2361 * returns the set of syscalls that are traced /debugged on exit. 2362 * Will also copy the syscall set if 'save' is non-zero. 2363 */ 2364 2365sysset_t * 2366proc_get_traced_sysexit (procinfo *pi, sysset_t *save) 2367{ 2368 sysset_t * ret = NULL; 2369 2370 /* 2371 * We should never have to apply this operation to any procinfo 2372 * except the one for the main process. If that ever changes 2373 * for any reason, then take out the following clause and 2374 * replace it with one that makes sure the ctl_fd is open. 2375 */ 2376 2377 if (pi->tid != 0) 2378 pi = find_procinfo_or_die (pi->pid, 0); 2379 2380#ifdef NEW_PROC_API 2381 if (!pi->status_valid) 2382 if (!proc_get_status (pi)) 2383 return NULL; 2384 2385#ifndef DYNAMIC_SYSCALLS 2386 ret = &pi->prstatus.pr_sysexit; 2387#else /* DYNAMIC_SYSCALLS */ 2388 { 2389 static sysset_t *sysexit; 2390 size_t size; 2391 2392 if (!sysexit) 2393 sysexit = sysset_t_alloc (pi); 2394 ret = sysexit; 2395 if (pi->status_fd == 0 && open_procinfo_files (pi, FD_STATUS) == 0) 2396 return NULL; 2397 if (pi->prstatus.pr_sysexit_offset == 0) 2398 { 2399 gdb_premptysysset (sysexit); 2400 } 2401 else 2402 { 2403 int rsize; 2404 2405 if (lseek (pi->status_fd, (off_t) pi->prstatus.pr_sysexit_offset, SEEK_SET) 2406 != (off_t) pi->prstatus.pr_sysexit_offset) 2407 return NULL; 2408 size = sysset_t_size (pi); 2409 gdb_premptysysset (sysexit); 2410 rsize = read (pi->status_fd, sysexit, size); 2411 if (rsize < 0) 2412 return NULL; 2413 } 2414 } 2415#endif /* DYNAMIC_SYSCALLS */ 2416#else 2417 { 2418 static sysset_t sysexit; 2419 2420 if (ioctl (pi->ctl_fd, PIOCGEXIT, &sysexit) >= 0) 2421 ret = &sysexit; 2422 } 2423#endif 2424 if (save && ret) 2425 memcpy (save, ret, sysset_t_size (pi)); 2426 2427 return ret; 2428} 2429 2430/* 2431 * Function: proc_clear_current_fault 2432 * 2433 * The current fault (if any) is cleared; the associated signal 2434 * will not be sent to the process or LWP when it resumes. 2435 * Returns non-zero for success, zero for failure. 2436 */ 2437 2438int 2439proc_clear_current_fault (procinfo *pi) 2440{ 2441 int win; 2442 2443 /* 2444 * We should never have to apply this operation to any procinfo 2445 * except the one for the main process. If that ever changes 2446 * for any reason, then take out the following clause and 2447 * replace it with one that makes sure the ctl_fd is open. 2448 */ 2449 2450 if (pi->tid != 0) 2451 pi = find_procinfo_or_die (pi->pid, 0); 2452 2453#ifdef NEW_PROC_API 2454 { 2455 procfs_ctl_t cmd = PCCFAULT; 2456 win = (write (pi->ctl_fd, (void *) &cmd, sizeof (cmd)) == sizeof (cmd)); 2457 } 2458#else 2459 win = (ioctl (pi->ctl_fd, PIOCCFAULT, 0) >= 0); 2460#endif 2461 2462 return win; 2463} 2464 2465/* 2466 * Function: proc_set_current_signal 2467 * 2468 * Set the "current signal" that will be delivered next to the process. 2469 * NOTE: semantics are different from those of KILL. 2470 * This signal will be delivered to the process or LWP 2471 * immediately when it is resumed (even if the signal is held/blocked); 2472 * it will NOT immediately cause another event of interest, and will NOT 2473 * first trap back to the debugger. 2474 * 2475 * Returns non-zero for success, zero for failure. 2476 */ 2477 2478int 2479proc_set_current_signal (procinfo *pi, int signo) 2480{ 2481 int win; 2482 struct { 2483 procfs_ctl_t cmd; 2484 /* Use char array to avoid alignment issues. */ 2485 char sinfo[sizeof (gdb_siginfo_t)]; 2486 } arg; 2487 gdb_siginfo_t *mysinfo; 2488 2489 /* 2490 * We should never have to apply this operation to any procinfo 2491 * except the one for the main process. If that ever changes 2492 * for any reason, then take out the following clause and 2493 * replace it with one that makes sure the ctl_fd is open. 2494 */ 2495 2496 if (pi->tid != 0) 2497 pi = find_procinfo_or_die (pi->pid, 0); 2498 2499#ifdef PROCFS_DONT_PIOCSSIG_CURSIG 2500 /* With Alpha OSF/1 procfs, the kernel gets really confused if it 2501 * receives a PIOCSSIG with a signal identical to the current signal, 2502 * it messes up the current signal. Work around the kernel bug. 2503 */ 2504 if (signo > 0 && 2505 signo == proc_cursig (pi)) 2506 return 1; /* I assume this is a success? */ 2507#endif 2508 2509 /* The pointer is just a type alias. */ 2510 mysinfo = (gdb_siginfo_t *) &arg.sinfo; 2511 mysinfo->si_signo = signo; 2512 mysinfo->si_code = 0; 2513 mysinfo->si_pid = getpid (); /* ?why? */ 2514 mysinfo->si_uid = getuid (); /* ?why? */ 2515 2516#ifdef NEW_PROC_API 2517 arg.cmd = PCSSIG; 2518 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg)); 2519#else 2520 win = (ioctl (pi->ctl_fd, PIOCSSIG, (void *) &arg.sinfo) >= 0); 2521#endif 2522 2523 return win; 2524} 2525 2526/* 2527 * Function: proc_clear_current_signal 2528 * 2529 * The current signal (if any) is cleared, and 2530 * is not sent to the process or LWP when it resumes. 2531 * Returns non-zero for success, zero for failure. 2532 */ 2533 2534int 2535proc_clear_current_signal (procinfo *pi) 2536{ 2537 int win; 2538 2539 /* 2540 * We should never have to apply this operation to any procinfo 2541 * except the one for the main process. If that ever changes 2542 * for any reason, then take out the following clause and 2543 * replace it with one that makes sure the ctl_fd is open. 2544 */ 2545 2546 if (pi->tid != 0) 2547 pi = find_procinfo_or_die (pi->pid, 0); 2548 2549#ifdef NEW_PROC_API 2550 { 2551 struct { 2552 procfs_ctl_t cmd; 2553 /* Use char array to avoid alignment issues. */ 2554 char sinfo[sizeof (gdb_siginfo_t)]; 2555 } arg; 2556 gdb_siginfo_t *mysinfo; 2557 2558 arg.cmd = PCSSIG; 2559 /* The pointer is just a type alias. */ 2560 mysinfo = (gdb_siginfo_t *) &arg.sinfo; 2561 mysinfo->si_signo = 0; 2562 mysinfo->si_code = 0; 2563 mysinfo->si_errno = 0; 2564 mysinfo->si_pid = getpid (); /* ?why? */ 2565 mysinfo->si_uid = getuid (); /* ?why? */ 2566 2567 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg)); 2568 } 2569#else 2570 win = (ioctl (pi->ctl_fd, PIOCSSIG, 0) >= 0); 2571#endif 2572 2573 return win; 2574} 2575 2576/* Return the general-purpose registers for the process or LWP 2577 corresponding to PI. Upon failure, return NULL. */ 2578 2579gdb_gregset_t * 2580proc_get_gregs (procinfo *pi) 2581{ 2582 if (!pi->status_valid || !pi->gregs_valid) 2583 if (!proc_get_status (pi)) 2584 return NULL; 2585 2586 /* OK, sorry about the ifdef's. There's three cases instead of two, 2587 because in this case Unixware and Solaris/RW differ. */ 2588 2589#ifdef NEW_PROC_API 2590# ifdef UNIXWARE /* FIXME: Should be autoconfigured. */ 2591 return &pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs; 2592# else 2593 return &pi->prstatus.pr_lwp.pr_reg; 2594# endif 2595#else 2596 return &pi->prstatus.pr_reg; 2597#endif 2598} 2599 2600/* Return the general-purpose registers for the process or LWP 2601 corresponding to PI. Upon failure, return NULL. */ 2602 2603gdb_fpregset_t * 2604proc_get_fpregs (procinfo *pi) 2605{ 2606#ifdef NEW_PROC_API 2607 if (!pi->status_valid || !pi->fpregs_valid) 2608 if (!proc_get_status (pi)) 2609 return NULL; 2610 2611# ifdef UNIXWARE /* FIXME: Should be autoconfigured. */ 2612 return &pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs; 2613# else 2614 return &pi->prstatus.pr_lwp.pr_fpreg; 2615# endif 2616 2617#else /* not NEW_PROC_API */ 2618 if (pi->fpregs_valid) 2619 return &pi->fpregset; /* Already got 'em. */ 2620 else 2621 { 2622 if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0) 2623 { 2624 return NULL; 2625 } 2626 else 2627 { 2628# ifdef PIOCTGFPREG 2629 struct { 2630 long pr_count; 2631 tid_t pr_error_thread; 2632 tfpregset_t thread_1; 2633 } thread_fpregs; 2634 2635 thread_fpregs.pr_count = 1; 2636 thread_fpregs.thread_1.tid = pi->tid; 2637 2638 if (pi->tid == 0 2639 && ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset) >= 0) 2640 { 2641 pi->fpregs_valid = 1; 2642 return &pi->fpregset; /* Got 'em now! */ 2643 } 2644 else if (pi->tid != 0 2645 && ioctl (pi->ctl_fd, PIOCTGFPREG, &thread_fpregs) >= 0) 2646 { 2647 memcpy (&pi->fpregset, &thread_fpregs.thread_1.pr_fpregs, 2648 sizeof (pi->fpregset)); 2649 pi->fpregs_valid = 1; 2650 return &pi->fpregset; /* Got 'em now! */ 2651 } 2652 else 2653 { 2654 return NULL; 2655 } 2656# else 2657 if (ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset) >= 0) 2658 { 2659 pi->fpregs_valid = 1; 2660 return &pi->fpregset; /* Got 'em now! */ 2661 } 2662 else 2663 { 2664 return NULL; 2665 } 2666# endif 2667 } 2668 } 2669#endif /* NEW_PROC_API */ 2670} 2671 2672/* Write the general-purpose registers back to the process or LWP 2673 corresponding to PI. Return non-zero for success, zero for 2674 failure. */ 2675 2676int 2677proc_set_gregs (procinfo *pi) 2678{ 2679 gdb_gregset_t *gregs; 2680 int win; 2681 2682 gregs = proc_get_gregs (pi); 2683 if (gregs == NULL) 2684 return 0; /* proc_get_regs has already warned. */ 2685 2686 if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0) 2687 { 2688 return 0; 2689 } 2690 else 2691 { 2692#ifdef NEW_PROC_API 2693 struct { 2694 procfs_ctl_t cmd; 2695 /* Use char array to avoid alignment issues. */ 2696 char gregs[sizeof (gdb_gregset_t)]; 2697 } arg; 2698 2699 arg.cmd = PCSREG; 2700 memcpy (&arg.gregs, gregs, sizeof (arg.gregs)); 2701 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg)); 2702#else 2703 win = (ioctl (pi->ctl_fd, PIOCSREG, gregs) >= 0); 2704#endif 2705 } 2706 2707 /* Policy: writing the registers invalidates our cache. */ 2708 pi->gregs_valid = 0; 2709 return win; 2710} 2711 2712/* Write the floating-pointer registers back to the process or LWP 2713 corresponding to PI. Return non-zero for success, zero for 2714 failure. */ 2715 2716int 2717proc_set_fpregs (procinfo *pi) 2718{ 2719 gdb_fpregset_t *fpregs; 2720 int win; 2721 2722 fpregs = proc_get_fpregs (pi); 2723 if (fpregs == NULL) 2724 return 0; /* proc_get_fpregs has already warned. */ 2725 2726 if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0) 2727 { 2728 return 0; 2729 } 2730 else 2731 { 2732#ifdef NEW_PROC_API 2733 struct { 2734 procfs_ctl_t cmd; 2735 /* Use char array to avoid alignment issues. */ 2736 char fpregs[sizeof (gdb_fpregset_t)]; 2737 } arg; 2738 2739 arg.cmd = PCSFPREG; 2740 memcpy (&arg.fpregs, fpregs, sizeof (arg.fpregs)); 2741 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg)); 2742#else 2743# ifdef PIOCTSFPREG 2744 if (pi->tid == 0) 2745 win = (ioctl (pi->ctl_fd, PIOCSFPREG, fpregs) >= 0); 2746 else 2747 { 2748 struct { 2749 long pr_count; 2750 tid_t pr_error_thread; 2751 tfpregset_t thread_1; 2752 } thread_fpregs; 2753 2754 thread_fpregs.pr_count = 1; 2755 thread_fpregs.thread_1.tid = pi->tid; 2756 memcpy (&thread_fpregs.thread_1.pr_fpregs, fpregs, 2757 sizeof (*fpregs)); 2758 win = (ioctl (pi->ctl_fd, PIOCTSFPREG, &thread_fpregs) >= 0); 2759 } 2760# else 2761 win = (ioctl (pi->ctl_fd, PIOCSFPREG, fpregs) >= 0); 2762# endif 2763#endif /* NEW_PROC_API */ 2764 } 2765 2766 /* Policy: writing the registers invalidates our cache. */ 2767 pi->fpregs_valid = 0; 2768 return win; 2769} 2770 2771/* 2772 * Function: proc_kill 2773 * 2774 * Send a signal to the proc or lwp with the semantics of "kill()". 2775 * Returns non-zero for success, zero for failure. 2776 */ 2777 2778int 2779proc_kill (procinfo *pi, int signo) 2780{ 2781 int win; 2782 2783 /* 2784 * We might conceivably apply this operation to an LWP, and 2785 * the LWP's ctl file descriptor might not be open. 2786 */ 2787 2788 if (pi->ctl_fd == 0 && 2789 open_procinfo_files (pi, FD_CTL) == 0) 2790 { 2791 return 0; 2792 } 2793 else 2794 { 2795#ifdef NEW_PROC_API 2796 procfs_ctl_t cmd[2]; 2797 2798 cmd[0] = PCKILL; 2799 cmd[1] = signo; 2800 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd)); 2801#else /* ioctl method */ 2802 /* FIXME: do I need the Alpha OSF fixups present in 2803 procfs.c/unconditionally_kill_inferior? Perhaps only for SIGKILL? */ 2804 win = (ioctl (pi->ctl_fd, PIOCKILL, &signo) >= 0); 2805#endif 2806 } 2807 2808 return win; 2809} 2810 2811/* 2812 * Function: proc_parent_pid 2813 * 2814 * Find the pid of the process that started this one. 2815 * Returns the parent process pid, or zero. 2816 */ 2817 2818int 2819proc_parent_pid (procinfo *pi) 2820{ 2821 /* 2822 * We should never have to apply this operation to any procinfo 2823 * except the one for the main process. If that ever changes 2824 * for any reason, then take out the following clause and 2825 * replace it with one that makes sure the ctl_fd is open. 2826 */ 2827 2828 if (pi->tid != 0) 2829 pi = find_procinfo_or_die (pi->pid, 0); 2830 2831 if (!pi->status_valid) 2832 if (!proc_get_status (pi)) 2833 return 0; 2834 2835 return pi->prstatus.pr_ppid; 2836} 2837 2838 2839/* Convert a target address (a.k.a. CORE_ADDR) into a host address 2840 (a.k.a void pointer)! */ 2841 2842static void * 2843procfs_address_to_host_pointer (CORE_ADDR addr) 2844{ 2845 void *ptr; 2846 2847 gdb_assert (sizeof (ptr) == TYPE_LENGTH (builtin_type_void_data_ptr)); 2848 gdbarch_address_to_pointer (current_gdbarch, builtin_type_void_data_ptr, 2849 &ptr, addr); 2850 return ptr; 2851} 2852 2853/* 2854 * Function: proc_set_watchpoint 2855 * 2856 */ 2857 2858int 2859proc_set_watchpoint (procinfo *pi, CORE_ADDR addr, int len, int wflags) 2860{ 2861#if !defined (TARGET_HAS_HARDWARE_WATCHPOINTS) 2862 return 0; 2863#else 2864/* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5 */ 2865#if defined (PIOCOPENLWP) || defined (UNIXWARE) /* Solaris 2.5: bail out */ 2866 return 0; 2867#else 2868 struct { 2869 procfs_ctl_t cmd; 2870 char watch[sizeof (prwatch_t)]; 2871 } arg; 2872 prwatch_t *pwatch; 2873 2874 pwatch = (prwatch_t *) &arg.watch; 2875 /* NOTE: cagney/2003-02-01: Even more horrible hack. Need to 2876 convert a target address into something that can be stored in a 2877 native data structure. */ 2878#ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */ 2879 pwatch->pr_vaddr = (uintptr_t) procfs_address_to_host_pointer (addr); 2880#else 2881 pwatch->pr_vaddr = (caddr_t) procfs_address_to_host_pointer (addr); 2882#endif 2883 pwatch->pr_size = len; 2884 pwatch->pr_wflags = wflags; 2885#if defined(NEW_PROC_API) && defined (PCWATCH) 2886 arg.cmd = PCWATCH; 2887 return (write (pi->ctl_fd, &arg, sizeof (arg)) == sizeof (arg)); 2888#else 2889#if defined (PIOCSWATCH) 2890 return (ioctl (pi->ctl_fd, PIOCSWATCH, pwatch) >= 0); 2891#else 2892 return 0; /* Fail */ 2893#endif 2894#endif 2895#endif 2896#endif 2897} 2898 2899#ifdef TM_I386SOL2_H /* Is it hokey to use this? */ 2900 2901#include <sys/sysi86.h> 2902 2903/* 2904 * Function: proc_get_LDT_entry 2905 * 2906 * Inputs: 2907 * procinfo *pi; 2908 * int key; 2909 * 2910 * The 'key' is actually the value of the lower 16 bits of 2911 * the GS register for the LWP that we're interested in. 2912 * 2913 * Return: matching ssh struct (LDT entry). 2914 */ 2915 2916struct ssd * 2917proc_get_LDT_entry (procinfo *pi, int key) 2918{ 2919 static struct ssd *ldt_entry = NULL; 2920#ifdef NEW_PROC_API 2921 char pathname[MAX_PROC_NAME_SIZE]; 2922 struct cleanup *old_chain = NULL; 2923 int fd; 2924 2925 /* Allocate space for one LDT entry. 2926 This alloc must persist, because we return a pointer to it. */ 2927 if (ldt_entry == NULL) 2928 ldt_entry = (struct ssd *) xmalloc (sizeof (struct ssd)); 2929 2930 /* Open the file descriptor for the LDT table. */ 2931 sprintf (pathname, "/proc/%d/ldt", pi->pid); 2932 if ((fd = open_with_retry (pathname, O_RDONLY)) < 0) 2933 { 2934 proc_warn (pi, "proc_get_LDT_entry (open)", __LINE__); 2935 return NULL; 2936 } 2937 /* Make sure it gets closed again! */ 2938 old_chain = make_cleanup_close (fd); 2939 2940 /* Now 'read' thru the table, find a match and return it. */ 2941 while (read (fd, ldt_entry, sizeof (struct ssd)) == sizeof (struct ssd)) 2942 { 2943 if (ldt_entry->sel == 0 && 2944 ldt_entry->bo == 0 && 2945 ldt_entry->acc1 == 0 && 2946 ldt_entry->acc2 == 0) 2947 break; /* end of table */ 2948 /* If key matches, return this entry. */ 2949 if (ldt_entry->sel == key) 2950 return ldt_entry; 2951 } 2952 /* Loop ended, match not found. */ 2953 return NULL; 2954#else 2955 int nldt, i; 2956 static int nalloc = 0; 2957 2958 /* Get the number of LDT entries. */ 2959 if (ioctl (pi->ctl_fd, PIOCNLDT, &nldt) < 0) 2960 { 2961 proc_warn (pi, "proc_get_LDT_entry (PIOCNLDT)", __LINE__); 2962 return NULL; 2963 } 2964 2965 /* Allocate space for the number of LDT entries. */ 2966 /* This alloc has to persist, 'cause we return a pointer to it. */ 2967 if (nldt > nalloc) 2968 { 2969 ldt_entry = (struct ssd *) 2970 xrealloc (ldt_entry, (nldt + 1) * sizeof (struct ssd)); 2971 nalloc = nldt; 2972 } 2973 2974 /* Read the whole table in one gulp. */ 2975 if (ioctl (pi->ctl_fd, PIOCLDT, ldt_entry) < 0) 2976 { 2977 proc_warn (pi, "proc_get_LDT_entry (PIOCLDT)", __LINE__); 2978 return NULL; 2979 } 2980 2981 /* Search the table and return the (first) entry matching 'key'. */ 2982 for (i = 0; i < nldt; i++) 2983 if (ldt_entry[i].sel == key) 2984 return &ldt_entry[i]; 2985 2986 /* Loop ended, match not found. */ 2987 return NULL; 2988#endif 2989} 2990 2991#endif /* TM_I386SOL2_H */ 2992 2993/* =============== END, non-thread part of /proc "MODULE" =============== */ 2994 2995/* =================== Thread "MODULE" =================== */ 2996 2997/* NOTE: you'll see more ifdefs and duplication of functions here, 2998 since there is a different way to do threads on every OS. */ 2999 3000/* 3001 * Function: proc_get_nthreads 3002 * 3003 * Return the number of threads for the process 3004 */ 3005 3006#if defined (PIOCNTHR) && defined (PIOCTLIST) 3007/* 3008 * OSF version 3009 */ 3010int 3011proc_get_nthreads (procinfo *pi) 3012{ 3013 int nthreads = 0; 3014 3015 if (ioctl (pi->ctl_fd, PIOCNTHR, &nthreads) < 0) 3016 proc_warn (pi, "procfs: PIOCNTHR failed", __LINE__); 3017 3018 return nthreads; 3019} 3020 3021#else 3022#if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */ 3023/* 3024 * Solaris and Unixware version 3025 */ 3026int 3027proc_get_nthreads (procinfo *pi) 3028{ 3029 if (!pi->status_valid) 3030 if (!proc_get_status (pi)) 3031 return 0; 3032 3033 /* 3034 * NEW_PROC_API: only works for the process procinfo, 3035 * because the LWP procinfos do not get prstatus filled in. 3036 */ 3037#ifdef NEW_PROC_API 3038 if (pi->tid != 0) /* find the parent process procinfo */ 3039 pi = find_procinfo_or_die (pi->pid, 0); 3040#endif 3041 return pi->prstatus.pr_nlwp; 3042} 3043 3044#else 3045/* 3046 * Default version 3047 */ 3048int 3049proc_get_nthreads (procinfo *pi) 3050{ 3051 return 0; 3052} 3053#endif 3054#endif 3055 3056/* 3057 * Function: proc_get_current_thread (LWP version) 3058 * 3059 * Return the ID of the thread that had an event of interest. 3060 * (ie. the one that hit a breakpoint or other traced event). 3061 * All other things being equal, this should be the ID of a 3062 * thread that is currently executing. 3063 */ 3064 3065#if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */ 3066/* 3067 * Solaris and Unixware version 3068 */ 3069int 3070proc_get_current_thread (procinfo *pi) 3071{ 3072 /* 3073 * Note: this should be applied to the root procinfo for the process, 3074 * not to the procinfo for an LWP. If applied to the procinfo for 3075 * an LWP, it will simply return that LWP's ID. In that case, 3076 * find the parent process procinfo. 3077 */ 3078 3079 if (pi->tid != 0) 3080 pi = find_procinfo_or_die (pi->pid, 0); 3081 3082 if (!pi->status_valid) 3083 if (!proc_get_status (pi)) 3084 return 0; 3085 3086#ifdef NEW_PROC_API 3087 return pi->prstatus.pr_lwp.pr_lwpid; 3088#else 3089 return pi->prstatus.pr_who; 3090#endif 3091} 3092 3093#else 3094#if defined (PIOCNTHR) && defined (PIOCTLIST) 3095/* 3096 * OSF version 3097 */ 3098int 3099proc_get_current_thread (procinfo *pi) 3100{ 3101#if 0 /* FIXME: not ready for prime time? */ 3102 return pi->prstatus.pr_tid; 3103#else 3104 return 0; 3105#endif 3106} 3107 3108#else 3109/* 3110 * Default version 3111 */ 3112int 3113proc_get_current_thread (procinfo *pi) 3114{ 3115 return 0; 3116} 3117 3118#endif 3119#endif 3120 3121/* 3122 * Function: proc_update_threads 3123 * 3124 * Discover the IDs of all the threads within the process, and 3125 * create a procinfo for each of them (chained to the parent). 3126 * 3127 * This unfortunately requires a different method on every OS. 3128 * 3129 * Return: non-zero for success, zero for failure. 3130 */ 3131 3132int 3133proc_delete_dead_threads (procinfo *parent, procinfo *thread, void *ignore) 3134{ 3135 if (thread && parent) /* sanity */ 3136 { 3137 thread->status_valid = 0; 3138 if (!proc_get_status (thread)) 3139 destroy_one_procinfo (&parent->thread_list, thread); 3140 } 3141 return 0; /* keep iterating */ 3142} 3143 3144#if defined (PIOCLSTATUS) 3145/* 3146 * Solaris 2.5 (ioctl) version 3147 */ 3148int 3149proc_update_threads (procinfo *pi) 3150{ 3151 gdb_prstatus_t *prstatus; 3152 struct cleanup *old_chain = NULL; 3153 procinfo *thread; 3154 int nlwp, i; 3155 3156 /* 3157 * We should never have to apply this operation to any procinfo 3158 * except the one for the main process. If that ever changes 3159 * for any reason, then take out the following clause and 3160 * replace it with one that makes sure the ctl_fd is open. 3161 */ 3162 3163 if (pi->tid != 0) 3164 pi = find_procinfo_or_die (pi->pid, 0); 3165 3166 proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL); 3167 3168 if ((nlwp = proc_get_nthreads (pi)) <= 1) 3169 return 1; /* Process is not multi-threaded; nothing to do. */ 3170 3171 prstatus = xmalloc (sizeof (gdb_prstatus_t) * (nlwp + 1)); 3172 3173 old_chain = make_cleanup (xfree, prstatus); 3174 if (ioctl (pi->ctl_fd, PIOCLSTATUS, prstatus) < 0) 3175 proc_error (pi, "update_threads (PIOCLSTATUS)", __LINE__); 3176 3177 /* Skip element zero, which represents the process as a whole. */ 3178 for (i = 1; i < nlwp + 1; i++) 3179 { 3180 if ((thread = create_procinfo (pi->pid, prstatus[i].pr_who)) == NULL) 3181 proc_error (pi, "update_threads, create_procinfo", __LINE__); 3182 3183 memcpy (&thread->prstatus, &prstatus[i], sizeof (*prstatus)); 3184 thread->status_valid = 1; 3185 } 3186 pi->threads_valid = 1; 3187 do_cleanups (old_chain); 3188 return 1; 3189} 3190#else 3191#ifdef NEW_PROC_API 3192/* 3193 * Unixware and Solaris 6 (and later) version 3194 */ 3195static void 3196do_closedir_cleanup (void *dir) 3197{ 3198 closedir (dir); 3199} 3200 3201int 3202proc_update_threads (procinfo *pi) 3203{ 3204 char pathname[MAX_PROC_NAME_SIZE + 16]; 3205 struct dirent *direntry; 3206 struct cleanup *old_chain = NULL; 3207 procinfo *thread; 3208 DIR *dirp; 3209 int lwpid; 3210 3211 /* 3212 * We should never have to apply this operation to any procinfo 3213 * except the one for the main process. If that ever changes 3214 * for any reason, then take out the following clause and 3215 * replace it with one that makes sure the ctl_fd is open. 3216 */ 3217 3218 if (pi->tid != 0) 3219 pi = find_procinfo_or_die (pi->pid, 0); 3220 3221 proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL); 3222 3223 /* 3224 * Unixware 3225 * 3226 * Note: this brute-force method is the only way I know of 3227 * to accomplish this task on Unixware. This method will 3228 * also work on Solaris 2.6 and 2.7. There is a much simpler 3229 * and more elegant way to do this on Solaris, but the margins 3230 * of this manuscript are too small to write it here... ;-) 3231 */ 3232 3233 strcpy (pathname, pi->pathname); 3234 strcat (pathname, "/lwp"); 3235 if ((dirp = opendir (pathname)) == NULL) 3236 proc_error (pi, "update_threads, opendir", __LINE__); 3237 3238 old_chain = make_cleanup (do_closedir_cleanup, dirp); 3239 while ((direntry = readdir (dirp)) != NULL) 3240 if (direntry->d_name[0] != '.') /* skip '.' and '..' */ 3241 { 3242 lwpid = atoi (&direntry->d_name[0]); 3243 if ((thread = create_procinfo (pi->pid, lwpid)) == NULL) 3244 proc_error (pi, "update_threads, create_procinfo", __LINE__); 3245 } 3246 pi->threads_valid = 1; 3247 do_cleanups (old_chain); 3248 return 1; 3249} 3250#else 3251#ifdef PIOCTLIST 3252/* 3253 * OSF version 3254 */ 3255int 3256proc_update_threads (procinfo *pi) 3257{ 3258 int nthreads, i; 3259 tid_t *threads; 3260 3261 /* 3262 * We should never have to apply this operation to any procinfo 3263 * except the one for the main process. If that ever changes 3264 * for any reason, then take out the following clause and 3265 * replace it with one that makes sure the ctl_fd is open. 3266 */ 3267 3268 if (pi->tid != 0) 3269 pi = find_procinfo_or_die (pi->pid, 0); 3270 3271 proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL); 3272 3273 nthreads = proc_get_nthreads (pi); 3274 if (nthreads < 2) 3275 return 0; /* nothing to do for 1 or fewer threads */ 3276 3277 threads = xmalloc (nthreads * sizeof (tid_t)); 3278 3279 if (ioctl (pi->ctl_fd, PIOCTLIST, threads) < 0) 3280 proc_error (pi, "procfs: update_threads (PIOCTLIST)", __LINE__); 3281 3282 for (i = 0; i < nthreads; i++) 3283 { 3284 if (!find_procinfo (pi->pid, threads[i])) 3285 if (!create_procinfo (pi->pid, threads[i])) 3286 proc_error (pi, "update_threads, create_procinfo", __LINE__); 3287 } 3288 pi->threads_valid = 1; 3289 return 1; 3290} 3291#else 3292/* 3293 * Default version 3294 */ 3295int 3296proc_update_threads (procinfo *pi) 3297{ 3298 return 0; 3299} 3300#endif /* OSF PIOCTLIST */ 3301#endif /* NEW_PROC_API */ 3302#endif /* SOL 2.5 PIOCLSTATUS */ 3303 3304/* 3305 * Function: proc_iterate_over_threads 3306 * 3307 * Description: 3308 * Given a pointer to a function, call that function once 3309 * for each lwp in the procinfo list, until the function 3310 * returns non-zero, in which event return the value 3311 * returned by the function. 3312 * 3313 * Note: this function does NOT call update_threads. 3314 * If you want to discover new threads first, you must 3315 * call that function explicitly. This function just makes 3316 * a quick pass over the currently-known procinfos. 3317 * 3318 * Arguments: 3319 * pi - parent process procinfo 3320 * func - per-thread function 3321 * ptr - opaque parameter for function. 3322 * 3323 * Return: 3324 * First non-zero return value from the callee, or zero. 3325 */ 3326 3327int 3328proc_iterate_over_threads (procinfo *pi, 3329 int (*func) (procinfo *, procinfo *, void *), 3330 void *ptr) 3331{ 3332 procinfo *thread, *next; 3333 int retval = 0; 3334 3335 /* 3336 * We should never have to apply this operation to any procinfo 3337 * except the one for the main process. If that ever changes 3338 * for any reason, then take out the following clause and 3339 * replace it with one that makes sure the ctl_fd is open. 3340 */ 3341 3342 if (pi->tid != 0) 3343 pi = find_procinfo_or_die (pi->pid, 0); 3344 3345 for (thread = pi->thread_list; thread != NULL; thread = next) 3346 { 3347 next = thread->next; /* in case thread is destroyed */ 3348 if ((retval = (*func) (pi, thread, ptr)) != 0) 3349 break; 3350 } 3351 3352 return retval; 3353} 3354 3355/* =================== END, Thread "MODULE" =================== */ 3356 3357/* =================== END, /proc "MODULE" =================== */ 3358 3359/* =================== GDB "MODULE" =================== */ 3360 3361/* 3362 * Here are all of the gdb target vector functions and their friends. 3363 */ 3364 3365static ptid_t do_attach (ptid_t ptid); 3366static void do_detach (int signo); 3367static int register_gdb_signals (procinfo *, gdb_sigset_t *); 3368static void proc_trace_syscalls_1 (procinfo *pi, int syscallnum, 3369 int entry_or_exit, int mode, int from_tty); 3370static int insert_dbx_link_breakpoint (procinfo *pi); 3371static void remove_dbx_link_breakpoint (void); 3372 3373/* On mips-irix, we need to insert a breakpoint at __dbx_link during 3374 the startup phase. The following two variables are used to record 3375 the address of the breakpoint, and the code that was replaced by 3376 a breakpoint. */ 3377static int dbx_link_bpt_addr = 0; 3378static void *dbx_link_bpt; 3379 3380/* 3381 * Function: procfs_debug_inferior 3382 * 3383 * Sets up the inferior to be debugged. 3384 * Registers to trace signals, hardware faults, and syscalls. 3385 * Note: does not set RLC flag: caller may want to customize that. 3386 * 3387 * Returns: zero for success (note! unlike most functions in this module) 3388 * On failure, returns the LINE NUMBER where it failed! 3389 */ 3390 3391static int 3392procfs_debug_inferior (procinfo *pi) 3393{ 3394 fltset_t traced_faults; 3395 gdb_sigset_t traced_signals; 3396 sysset_t *traced_syscall_entries; 3397 sysset_t *traced_syscall_exits; 3398 int status; 3399 3400#ifdef PROCFS_DONT_TRACE_FAULTS 3401 /* On some systems (OSF), we don't trace hardware faults. 3402 Apparently it's enough that we catch them as signals. 3403 Wonder why we don't just do that in general? */ 3404 premptyset (&traced_faults); /* don't trace faults. */ 3405#else 3406 /* Register to trace hardware faults in the child. */ 3407 prfillset (&traced_faults); /* trace all faults... */ 3408 prdelset (&traced_faults, FLTPAGE); /* except page fault. */ 3409#endif 3410 if (!proc_set_traced_faults (pi, &traced_faults)) 3411 return __LINE__; 3412 3413 /* Register to trace selected signals in the child. */ 3414 premptyset (&traced_signals); 3415 if (!register_gdb_signals (pi, &traced_signals)) 3416 return __LINE__; 3417 3418 3419 /* Register to trace the 'exit' system call (on entry). */ 3420 traced_syscall_entries = sysset_t_alloc (pi); 3421 gdb_premptysysset (traced_syscall_entries); 3422#ifdef SYS_exit 3423 gdb_praddsysset (traced_syscall_entries, SYS_exit); 3424#endif 3425#ifdef SYS_lwpexit 3426 gdb_praddsysset (traced_syscall_entries, SYS_lwpexit); /* And _lwp_exit... */ 3427#endif 3428#ifdef SYS_lwp_exit 3429 gdb_praddsysset (traced_syscall_entries, SYS_lwp_exit); 3430#endif 3431#ifdef DYNAMIC_SYSCALLS 3432 { 3433 int callnum = find_syscall (pi, "_exit"); 3434 if (callnum >= 0) 3435 gdb_praddsysset (traced_syscall_entries, callnum); 3436 } 3437#endif 3438 3439 status = proc_set_traced_sysentry (pi, traced_syscall_entries); 3440 xfree (traced_syscall_entries); 3441 if (!status) 3442 return __LINE__; 3443 3444#ifdef PRFS_STOPEXEC /* defined on OSF */ 3445 /* OSF method for tracing exec syscalls. Quoting: 3446 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace 3447 exits from exec system calls because of the user level loader. */ 3448 /* FIXME: make nice and maybe move into an access function. */ 3449 { 3450 int prfs_flags; 3451 3452 if (ioctl (pi->ctl_fd, PIOCGSPCACT, &prfs_flags) < 0) 3453 return __LINE__; 3454 3455 prfs_flags |= PRFS_STOPEXEC; 3456 3457 if (ioctl (pi->ctl_fd, PIOCSSPCACT, &prfs_flags) < 0) 3458 return __LINE__; 3459 } 3460#else /* not PRFS_STOPEXEC */ 3461 /* Everyone else's (except OSF) method for tracing exec syscalls */ 3462 /* GW: Rationale... 3463 Not all systems with /proc have all the exec* syscalls with the same 3464 names. On the SGI, for example, there is no SYS_exec, but there 3465 *is* a SYS_execv. So, we try to account for that. */ 3466 3467 traced_syscall_exits = sysset_t_alloc (pi); 3468 gdb_premptysysset (traced_syscall_exits); 3469#ifdef SYS_exec 3470 gdb_praddsysset (traced_syscall_exits, SYS_exec); 3471#endif 3472#ifdef SYS_execve 3473 gdb_praddsysset (traced_syscall_exits, SYS_execve); 3474#endif 3475#ifdef SYS_execv 3476 gdb_praddsysset (traced_syscall_exits, SYS_execv); 3477#endif 3478 3479#ifdef SYS_lwpcreate 3480 gdb_praddsysset (traced_syscall_exits, SYS_lwpcreate); 3481 gdb_praddsysset (traced_syscall_exits, SYS_lwpexit); 3482#endif 3483 3484#ifdef SYS_lwp_create /* FIXME: once only, please */ 3485 gdb_praddsysset (traced_syscall_exits, SYS_lwp_create); 3486 gdb_praddsysset (traced_syscall_exits, SYS_lwp_exit); 3487#endif 3488 3489#ifdef DYNAMIC_SYSCALLS 3490 { 3491 int callnum = find_syscall (pi, "execve"); 3492 if (callnum >= 0) 3493 gdb_praddsysset (traced_syscall_exits, callnum); 3494 callnum = find_syscall (pi, "ra_execve"); 3495 if (callnum >= 0) 3496 gdb_praddsysset (traced_syscall_exits, callnum); 3497 } 3498#endif 3499 3500 status = proc_set_traced_sysexit (pi, traced_syscall_exits); 3501 xfree (traced_syscall_exits); 3502 if (!status) 3503 return __LINE__; 3504 3505#endif /* PRFS_STOPEXEC */ 3506 return 0; 3507} 3508 3509static void 3510procfs_attach (char *args, int from_tty) 3511{ 3512 char *exec_file; 3513 int pid; 3514 3515 if (!args) 3516 error_no_arg (_("process-id to attach")); 3517 3518 pid = atoi (args); 3519 if (pid == getpid ()) 3520 error (_("Attaching GDB to itself is not a good idea...")); 3521 3522 if (from_tty) 3523 { 3524 exec_file = get_exec_file (0); 3525 3526 if (exec_file) 3527 printf_filtered (_("Attaching to program `%s', %s\n"), 3528 exec_file, target_pid_to_str (pid_to_ptid (pid))); 3529 else 3530 printf_filtered (_("Attaching to %s\n"), 3531 target_pid_to_str (pid_to_ptid (pid))); 3532 3533 fflush (stdout); 3534 } 3535 inferior_ptid = do_attach (pid_to_ptid (pid)); 3536 push_target (&procfs_ops); 3537} 3538 3539static void 3540procfs_detach (char *args, int from_tty) 3541{ 3542 int sig = 0; 3543 3544 if (args) 3545 sig = atoi (args); 3546 3547 if (from_tty) 3548 { 3549 int pid = PIDGET (inferior_ptid); 3550 char *exec_file; 3551 3552 exec_file = get_exec_file (0); 3553 if (exec_file == NULL) 3554 exec_file = ""; 3555 3556 printf_filtered (_("Detaching from program: %s, %s\n"), exec_file, 3557 target_pid_to_str (pid_to_ptid (pid))); 3558 gdb_flush (gdb_stdout); 3559 } 3560 3561 do_detach (sig); 3562 3563 inferior_ptid = null_ptid; 3564 unpush_target (&procfs_ops); 3565} 3566 3567static ptid_t 3568do_attach (ptid_t ptid) 3569{ 3570 procinfo *pi; 3571 int fail; 3572 3573 if ((pi = create_procinfo (PIDGET (ptid), 0)) == NULL) 3574 perror (_("procfs: out of memory in 'attach'")); 3575 3576 if (!open_procinfo_files (pi, FD_CTL)) 3577 { 3578 fprintf_filtered (gdb_stderr, "procfs:%d -- ", __LINE__); 3579 sprintf (errmsg, "do_attach: couldn't open /proc file for process %d", 3580 PIDGET (ptid)); 3581 dead_procinfo (pi, errmsg, NOKILL); 3582 } 3583 3584 /* Stop the process (if it isn't already stopped). */ 3585 if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) 3586 { 3587 pi->was_stopped = 1; 3588 proc_prettyprint_why (proc_why (pi), proc_what (pi), 1); 3589 } 3590 else 3591 { 3592 pi->was_stopped = 0; 3593 /* Set the process to run again when we close it. */ 3594 if (!proc_set_run_on_last_close (pi)) 3595 dead_procinfo (pi, "do_attach: couldn't set RLC.", NOKILL); 3596 3597 /* Now stop the process. */ 3598 if (!proc_stop_process (pi)) 3599 dead_procinfo (pi, "do_attach: couldn't stop the process.", NOKILL); 3600 pi->ignore_next_sigstop = 1; 3601 } 3602 /* Save some of the /proc state to be restored if we detach. */ 3603 if (!proc_get_traced_faults (pi, &pi->saved_fltset)) 3604 dead_procinfo (pi, "do_attach: couldn't save traced faults.", NOKILL); 3605 if (!proc_get_traced_signals (pi, &pi->saved_sigset)) 3606 dead_procinfo (pi, "do_attach: couldn't save traced signals.", NOKILL); 3607 if (!proc_get_traced_sysentry (pi, pi->saved_entryset)) 3608 dead_procinfo (pi, "do_attach: couldn't save traced syscall entries.", 3609 NOKILL); 3610 if (!proc_get_traced_sysexit (pi, pi->saved_exitset)) 3611 dead_procinfo (pi, "do_attach: couldn't save traced syscall exits.", 3612 NOKILL); 3613 if (!proc_get_held_signals (pi, &pi->saved_sighold)) 3614 dead_procinfo (pi, "do_attach: couldn't save held signals.", NOKILL); 3615 3616 if ((fail = procfs_debug_inferior (pi)) != 0) 3617 dead_procinfo (pi, "do_attach: failed in procfs_debug_inferior", NOKILL); 3618 3619 /* Let GDB know that the inferior was attached. */ 3620 attach_flag = 1; 3621 return MERGEPID (pi->pid, proc_get_current_thread (pi)); 3622} 3623 3624static void 3625do_detach (int signo) 3626{ 3627 procinfo *pi; 3628 3629 /* Find procinfo for the main process */ 3630 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); /* FIXME: threads */ 3631 if (signo) 3632 if (!proc_set_current_signal (pi, signo)) 3633 proc_warn (pi, "do_detach, set_current_signal", __LINE__); 3634 3635 if (!proc_set_traced_signals (pi, &pi->saved_sigset)) 3636 proc_warn (pi, "do_detach, set_traced_signal", __LINE__); 3637 3638 if (!proc_set_traced_faults (pi, &pi->saved_fltset)) 3639 proc_warn (pi, "do_detach, set_traced_faults", __LINE__); 3640 3641 if (!proc_set_traced_sysentry (pi, pi->saved_entryset)) 3642 proc_warn (pi, "do_detach, set_traced_sysentry", __LINE__); 3643 3644 if (!proc_set_traced_sysexit (pi, pi->saved_exitset)) 3645 proc_warn (pi, "do_detach, set_traced_sysexit", __LINE__); 3646 3647 if (!proc_set_held_signals (pi, &pi->saved_sighold)) 3648 proc_warn (pi, "do_detach, set_held_signals", __LINE__); 3649 3650 if (signo || (proc_flags (pi) & (PR_STOPPED | PR_ISTOP))) 3651 if (signo || !(pi->was_stopped) || 3652 query (_("Was stopped when attached, make it runnable again? "))) 3653 { 3654 /* Clear any pending signal. */ 3655 if (!proc_clear_current_fault (pi)) 3656 proc_warn (pi, "do_detach, clear_current_fault", __LINE__); 3657 3658 if (signo == 0 && !proc_clear_current_signal (pi)) 3659 proc_warn (pi, "do_detach, clear_current_signal", __LINE__); 3660 3661 if (!proc_set_run_on_last_close (pi)) 3662 proc_warn (pi, "do_detach, set_rlc", __LINE__); 3663 } 3664 3665 attach_flag = 0; 3666 destroy_procinfo (pi); 3667} 3668 3669/* Fetch register REGNUM from the inferior. If REGNUM is -1, do this 3670 for all registers. 3671 3672 ??? Is the following note still relevant? We can't get individual 3673 registers with the PT_GETREGS ptrace(2) request either, yet we 3674 don't bother with caching at all in that case. 3675 3676 NOTE: Since the /proc interface cannot give us individual 3677 registers, we pay no attention to REGNUM, and just fetch them all. 3678 This results in the possibility that we will do unnecessarily many 3679 fetches, since we may be called repeatedly for individual 3680 registers. So we cache the results, and mark the cache invalid 3681 when the process is resumed. */ 3682 3683static void 3684procfs_fetch_registers (struct regcache *regcache, int regnum) 3685{ 3686 gdb_gregset_t *gregs; 3687 procinfo *pi; 3688 int pid = PIDGET (inferior_ptid); 3689 int tid = TIDGET (inferior_ptid); 3690 3691 /* First look up procinfo for the main process. */ 3692 pi = find_procinfo_or_die (pid, 0); 3693 3694 /* If the event thread is not the same as GDB's requested thread 3695 (ie. inferior_ptid), then look up procinfo for the requested 3696 thread. */ 3697 if (tid != 0 && tid != proc_get_current_thread (pi)) 3698 pi = find_procinfo_or_die (pid, tid); 3699 3700 if (pi == NULL) 3701 error (_("procfs: fetch_registers failed to find procinfo for %s"), 3702 target_pid_to_str (inferior_ptid)); 3703 3704 gregs = proc_get_gregs (pi); 3705 if (gregs == NULL) 3706 proc_error (pi, "fetch_registers, get_gregs", __LINE__); 3707 3708 supply_gregset (regcache, (const gdb_gregset_t *) gregs); 3709 3710 if (gdbarch_fp0_regnum (current_gdbarch) >= 0) /* Do we have an FPU? */ 3711 { 3712 gdb_fpregset_t *fpregs; 3713 3714 if ((regnum >= 0 && regnum < gdbarch_fp0_regnum (current_gdbarch)) 3715 || regnum == gdbarch_pc_regnum (current_gdbarch) 3716 || regnum == gdbarch_sp_regnum (current_gdbarch)) 3717 return; /* Not a floating point register. */ 3718 3719 fpregs = proc_get_fpregs (pi); 3720 if (fpregs == NULL) 3721 proc_error (pi, "fetch_registers, get_fpregs", __LINE__); 3722 3723 supply_fpregset (regcache, (const gdb_fpregset_t *) fpregs); 3724 } 3725} 3726 3727/* Get ready to modify the registers array. On machines which store 3728 individual registers, this doesn't need to do anything. On 3729 machines which store all the registers in one fell swoop, such as 3730 /proc, this makes sure that registers contains all the registers 3731 from the program being debugged. */ 3732 3733static void 3734procfs_prepare_to_store (struct regcache *regcache) 3735{ 3736} 3737 3738/* Store register REGNUM back into the inferior. If REGNUM is -1, do 3739 this for all registers. 3740 3741 NOTE: Since the /proc interface will not read individual registers, 3742 we will cache these requests until the process is resumed, and only 3743 then write them back to the inferior process. 3744 3745 FIXME: is that a really bad idea? Have to think about cases where 3746 writing one register might affect the value of others, etc. */ 3747 3748static void 3749procfs_store_registers (struct regcache *regcache, int regnum) 3750{ 3751 gdb_gregset_t *gregs; 3752 procinfo *pi; 3753 int pid = PIDGET (inferior_ptid); 3754 int tid = TIDGET (inferior_ptid); 3755 3756 /* First find procinfo for main process. */ 3757 pi = find_procinfo_or_die (pid, 0); 3758 3759 /* If the event thread is not the same as GDB's requested thread 3760 (ie. inferior_ptid), then look up procinfo for the requested 3761 thread. */ 3762 if (tid != 0 && tid != proc_get_current_thread (pi)) 3763 pi = find_procinfo_or_die (pid, tid); 3764 3765 if (pi == NULL) 3766 error (_("procfs: store_registers: failed to find procinfo for %s"), 3767 target_pid_to_str (inferior_ptid)); 3768 3769 gregs = proc_get_gregs (pi); 3770 if (gregs == NULL) 3771 proc_error (pi, "store_registers, get_gregs", __LINE__); 3772 3773 fill_gregset (regcache, gregs, regnum); 3774 if (!proc_set_gregs (pi)) 3775 proc_error (pi, "store_registers, set_gregs", __LINE__); 3776 3777 if (gdbarch_fp0_regnum (current_gdbarch) >= 0) /* Do we have an FPU? */ 3778 { 3779 gdb_fpregset_t *fpregs; 3780 3781 if ((regnum >= 0 && regnum < gdbarch_fp0_regnum (current_gdbarch)) 3782 || regnum == gdbarch_pc_regnum (current_gdbarch) 3783 || regnum == gdbarch_sp_regnum (current_gdbarch)) 3784 return; /* Not a floating point register. */ 3785 3786 fpregs = proc_get_fpregs (pi); 3787 if (fpregs == NULL) 3788 proc_error (pi, "store_registers, get_fpregs", __LINE__); 3789 3790 fill_fpregset (regcache, fpregs, regnum); 3791 if (!proc_set_fpregs (pi)) 3792 proc_error (pi, "store_registers, set_fpregs", __LINE__); 3793 } 3794} 3795 3796static int 3797syscall_is_lwp_exit (procinfo *pi, int scall) 3798{ 3799 3800#ifdef SYS_lwp_exit 3801 if (scall == SYS_lwp_exit) 3802 return 1; 3803#endif 3804#ifdef SYS_lwpexit 3805 if (scall == SYS_lwpexit) 3806 return 1; 3807#endif 3808 return 0; 3809} 3810 3811static int 3812syscall_is_exit (procinfo *pi, int scall) 3813{ 3814#ifdef SYS_exit 3815 if (scall == SYS_exit) 3816 return 1; 3817#endif 3818#ifdef DYNAMIC_SYSCALLS 3819 if (find_syscall (pi, "_exit") == scall) 3820 return 1; 3821#endif 3822 return 0; 3823} 3824 3825static int 3826syscall_is_exec (procinfo *pi, int scall) 3827{ 3828#ifdef SYS_exec 3829 if (scall == SYS_exec) 3830 return 1; 3831#endif 3832#ifdef SYS_execv 3833 if (scall == SYS_execv) 3834 return 1; 3835#endif 3836#ifdef SYS_execve 3837 if (scall == SYS_execve) 3838 return 1; 3839#endif 3840#ifdef DYNAMIC_SYSCALLS 3841 if (find_syscall (pi, "_execve")) 3842 return 1; 3843 if (find_syscall (pi, "ra_execve")) 3844 return 1; 3845#endif 3846 return 0; 3847} 3848 3849static int 3850syscall_is_lwp_create (procinfo *pi, int scall) 3851{ 3852#ifdef SYS_lwp_create 3853 if (scall == SYS_lwp_create) 3854 return 1; 3855#endif 3856#ifdef SYS_lwpcreate 3857 if (scall == SYS_lwpcreate) 3858 return 1; 3859#endif 3860 return 0; 3861} 3862 3863/* 3864 * Function: target_wait 3865 * 3866 * Retrieve the next stop event from the child process. 3867 * If child has not stopped yet, wait for it to stop. 3868 * Translate /proc eventcodes (or possibly wait eventcodes) 3869 * into gdb internal event codes. 3870 * 3871 * Return: id of process (and possibly thread) that incurred the event. 3872 * event codes are returned thru a pointer parameter. 3873 */ 3874 3875static ptid_t 3876procfs_wait (ptid_t ptid, struct target_waitstatus *status) 3877{ 3878 /* First cut: loosely based on original version 2.1 */ 3879 procinfo *pi; 3880 int wstat; 3881 int temp_tid; 3882 ptid_t retval, temp_ptid; 3883 int why, what, flags; 3884 int retry = 0; 3885 3886wait_again: 3887 3888 retry++; 3889 wstat = 0; 3890 retval = pid_to_ptid (-1); 3891 3892 /* Find procinfo for main process */ 3893 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); 3894 if (pi) 3895 { 3896 /* We must assume that the status is stale now... */ 3897 pi->status_valid = 0; 3898 pi->gregs_valid = 0; 3899 pi->fpregs_valid = 0; 3900 3901#if 0 /* just try this out... */ 3902 flags = proc_flags (pi); 3903 why = proc_why (pi); 3904 if ((flags & PR_STOPPED) && (why == PR_REQUESTED)) 3905 pi->status_valid = 0; /* re-read again, IMMEDIATELY... */ 3906#endif 3907 /* If child is not stopped, wait for it to stop. */ 3908 if (!(proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) && 3909 !proc_wait_for_stop (pi)) 3910 { 3911 /* wait_for_stop failed: has the child terminated? */ 3912 if (errno == ENOENT) 3913 { 3914 int wait_retval; 3915 3916 /* /proc file not found; presumably child has terminated. */ 3917 wait_retval = wait (&wstat); /* "wait" for the child's exit */ 3918 3919 if (wait_retval != PIDGET (inferior_ptid)) /* wrong child? */ 3920 error (_("procfs: couldn't stop process %d: wait returned %d."), 3921 PIDGET (inferior_ptid), wait_retval); 3922 /* FIXME: might I not just use waitpid? 3923 Or try find_procinfo to see if I know about this child? */ 3924 retval = pid_to_ptid (wait_retval); 3925 } 3926 else if (errno == EINTR) 3927 goto wait_again; 3928 else 3929 { 3930 /* Unknown error from wait_for_stop. */ 3931 proc_error (pi, "target_wait (wait_for_stop)", __LINE__); 3932 } 3933 } 3934 else 3935 { 3936 /* This long block is reached if either: 3937 a) the child was already stopped, or 3938 b) we successfully waited for the child with wait_for_stop. 3939 This block will analyze the /proc status, and translate it 3940 into a waitstatus for GDB. 3941 3942 If we actually had to call wait because the /proc file 3943 is gone (child terminated), then we skip this block, 3944 because we already have a waitstatus. */ 3945 3946 flags = proc_flags (pi); 3947 why = proc_why (pi); 3948 what = proc_what (pi); 3949 3950 if (flags & (PR_STOPPED | PR_ISTOP)) 3951 { 3952#ifdef PR_ASYNC 3953 /* If it's running async (for single_thread control), 3954 set it back to normal again. */ 3955 if (flags & PR_ASYNC) 3956 if (!proc_unset_async (pi)) 3957 proc_error (pi, "target_wait, unset_async", __LINE__); 3958#endif 3959 3960 if (info_verbose) 3961 proc_prettyprint_why (why, what, 1); 3962 3963 /* The 'pid' we will return to GDB is composed of 3964 the process ID plus the lwp ID. */ 3965 retval = MERGEPID (pi->pid, proc_get_current_thread (pi)); 3966 3967 switch (why) { 3968 case PR_SIGNALLED: 3969 wstat = (what << 8) | 0177; 3970 break; 3971 case PR_SYSENTRY: 3972 if (syscall_is_lwp_exit (pi, what)) 3973 { 3974 printf_filtered (_("[%s exited]\n"), 3975 target_pid_to_str (retval)); 3976 delete_thread (retval); 3977 status->kind = TARGET_WAITKIND_SPURIOUS; 3978 return retval; 3979 } 3980 else if (syscall_is_exit (pi, what)) 3981 { 3982 /* Handle SYS_exit call only */ 3983 /* Stopped at entry to SYS_exit. 3984 Make it runnable, resume it, then use 3985 the wait system call to get its exit code. 3986 Proc_run_process always clears the current 3987 fault and signal. 3988 Then return its exit status. */ 3989 pi->status_valid = 0; 3990 wstat = 0; 3991 /* FIXME: what we should do is return 3992 TARGET_WAITKIND_SPURIOUS. */ 3993 if (!proc_run_process (pi, 0, 0)) 3994 proc_error (pi, "target_wait, run_process", __LINE__); 3995 if (attach_flag) 3996 { 3997 /* Don't call wait: simulate waiting for exit, 3998 return a "success" exit code. Bogus: what if 3999 it returns something else? */ 4000 wstat = 0; 4001 retval = inferior_ptid; /* ? ? ? */ 4002 } 4003 else 4004 { 4005 int temp = wait (&wstat); 4006 4007 /* FIXME: shouldn't I make sure I get the right 4008 event from the right process? If (for 4009 instance) I have killed an earlier inferior 4010 process but failed to clean up after it 4011 somehow, I could get its termination event 4012 here. */ 4013 4014 /* If wait returns -1, that's what we return to GDB. */ 4015 if (temp < 0) 4016 retval = pid_to_ptid (temp); 4017 } 4018 } 4019 else 4020 { 4021 printf_filtered (_("procfs: trapped on entry to ")); 4022 proc_prettyprint_syscall (proc_what (pi), 0); 4023 printf_filtered ("\n"); 4024#ifndef PIOCSSPCACT 4025 { 4026 long i, nsysargs, *sysargs; 4027 4028 if ((nsysargs = proc_nsysarg (pi)) > 0 && 4029 (sysargs = proc_sysargs (pi)) != NULL) 4030 { 4031 printf_filtered (_("%ld syscall arguments:\n"), nsysargs); 4032 for (i = 0; i < nsysargs; i++) 4033 printf_filtered ("#%ld: 0x%08lx\n", 4034 i, sysargs[i]); 4035 } 4036 4037 } 4038#endif 4039 if (status) 4040 { 4041 /* How to exit gracefully, returning "unknown event" */ 4042 status->kind = TARGET_WAITKIND_SPURIOUS; 4043 return inferior_ptid; 4044 } 4045 else 4046 { 4047 /* How to keep going without returning to wfi: */ 4048 target_resume (ptid, 0, TARGET_SIGNAL_0); 4049 goto wait_again; 4050 } 4051 } 4052 break; 4053 case PR_SYSEXIT: 4054 if (syscall_is_exec (pi, what)) 4055 { 4056 /* Hopefully this is our own "fork-child" execing 4057 the real child. Hoax this event into a trap, and 4058 GDB will see the child about to execute its start 4059 address. */ 4060 wstat = (SIGTRAP << 8) | 0177; 4061 } 4062#ifdef SYS_syssgi 4063 else if (what == SYS_syssgi) 4064 { 4065 /* see if we can break on dbx_link(). If yes, then 4066 we no longer need the SYS_syssgi notifications. */ 4067 if (insert_dbx_link_breakpoint (pi)) 4068 proc_trace_syscalls_1 (pi, SYS_syssgi, PR_SYSEXIT, 4069 FLAG_RESET, 0); 4070 4071 /* This is an internal event and should be transparent 4072 to wfi, so resume the execution and wait again. See 4073 comment in procfs_init_inferior() for more details. */ 4074 target_resume (ptid, 0, TARGET_SIGNAL_0); 4075 goto wait_again; 4076 } 4077#endif 4078 else if (syscall_is_lwp_create (pi, what)) 4079 { 4080 /* 4081 * This syscall is somewhat like fork/exec. 4082 * We will get the event twice: once for the parent LWP, 4083 * and once for the child. We should already know about 4084 * the parent LWP, but the child will be new to us. So, 4085 * whenever we get this event, if it represents a new 4086 * thread, simply add the thread to the list. 4087 */ 4088 4089 /* If not in procinfo list, add it. */ 4090 temp_tid = proc_get_current_thread (pi); 4091 if (!find_procinfo (pi->pid, temp_tid)) 4092 create_procinfo (pi->pid, temp_tid); 4093 4094 temp_ptid = MERGEPID (pi->pid, temp_tid); 4095 /* If not in GDB's thread list, add it. */ 4096 if (!in_thread_list (temp_ptid)) 4097 { 4098 printf_filtered (_("[New %s]\n"), 4099 target_pid_to_str (temp_ptid)); 4100 add_thread (temp_ptid); 4101 } 4102 /* Return to WFI, but tell it to immediately resume. */ 4103 status->kind = TARGET_WAITKIND_SPURIOUS; 4104 return inferior_ptid; 4105 } 4106 else if (syscall_is_lwp_exit (pi, what)) 4107 { 4108 printf_filtered (_("[%s exited]\n"), 4109 target_pid_to_str (retval)); 4110 delete_thread (retval); 4111 status->kind = TARGET_WAITKIND_SPURIOUS; 4112 return retval; 4113 } 4114 else if (0) 4115 { 4116 /* FIXME: Do we need to handle SYS_sproc, 4117 SYS_fork, or SYS_vfork here? The old procfs 4118 seemed to use this event to handle threads on 4119 older (non-LWP) systems, where I'm assuming 4120 that threads were actually separate processes. 4121 Irix, maybe? Anyway, low priority for now. */ 4122 } 4123 else 4124 { 4125 printf_filtered (_("procfs: trapped on exit from ")); 4126 proc_prettyprint_syscall (proc_what (pi), 0); 4127 printf_filtered ("\n"); 4128#ifndef PIOCSSPCACT 4129 { 4130 long i, nsysargs, *sysargs; 4131 4132 if ((nsysargs = proc_nsysarg (pi)) > 0 && 4133 (sysargs = proc_sysargs (pi)) != NULL) 4134 { 4135 printf_filtered (_("%ld syscall arguments:\n"), nsysargs); 4136 for (i = 0; i < nsysargs; i++) 4137 printf_filtered ("#%ld: 0x%08lx\n", 4138 i, sysargs[i]); 4139 } 4140 } 4141#endif 4142 status->kind = TARGET_WAITKIND_SPURIOUS; 4143 return inferior_ptid; 4144 } 4145 break; 4146 case PR_REQUESTED: 4147#if 0 /* FIXME */ 4148 wstat = (SIGSTOP << 8) | 0177; 4149 break; 4150#else 4151 if (retry < 5) 4152 { 4153 printf_filtered (_("Retry #%d:\n"), retry); 4154 pi->status_valid = 0; 4155 goto wait_again; 4156 } 4157 else 4158 { 4159 /* If not in procinfo list, add it. */ 4160 temp_tid = proc_get_current_thread (pi); 4161 if (!find_procinfo (pi->pid, temp_tid)) 4162 create_procinfo (pi->pid, temp_tid); 4163 4164 /* If not in GDB's thread list, add it. */ 4165 temp_ptid = MERGEPID (pi->pid, temp_tid); 4166 if (!in_thread_list (temp_ptid)) 4167 { 4168 printf_filtered (_("[New %s]\n"), 4169 target_pid_to_str (temp_ptid)); 4170 add_thread (temp_ptid); 4171 } 4172 4173 status->kind = TARGET_WAITKIND_STOPPED; 4174 status->value.sig = 0; 4175 return retval; 4176 } 4177#endif 4178 case PR_JOBCONTROL: 4179 wstat = (what << 8) | 0177; 4180 break; 4181 case PR_FAULTED: 4182 switch (what) { 4183#ifdef FLTWATCH 4184 case FLTWATCH: 4185 wstat = (SIGTRAP << 8) | 0177; 4186 break; 4187#endif 4188#ifdef FLTKWATCH 4189 case FLTKWATCH: 4190 wstat = (SIGTRAP << 8) | 0177; 4191 break; 4192#endif 4193 /* FIXME: use si_signo where possible. */ 4194 case FLTPRIV: 4195#if (FLTILL != FLTPRIV) /* avoid "duplicate case" error */ 4196 case FLTILL: 4197#endif 4198 wstat = (SIGILL << 8) | 0177; 4199 break; 4200 case FLTBPT: 4201#if (FLTTRACE != FLTBPT) /* avoid "duplicate case" error */ 4202 case FLTTRACE: 4203#endif 4204 /* If we hit our __dbx_link() internal breakpoint, 4205 then remove it. See comments in procfs_init_inferior() 4206 for more details. */ 4207 if (dbx_link_bpt_addr != 0 4208 && dbx_link_bpt_addr == read_pc ()) 4209 remove_dbx_link_breakpoint (); 4210 4211 wstat = (SIGTRAP << 8) | 0177; 4212 break; 4213 case FLTSTACK: 4214 case FLTACCESS: 4215#if (FLTBOUNDS != FLTSTACK) /* avoid "duplicate case" error */ 4216 case FLTBOUNDS: 4217#endif 4218 wstat = (SIGSEGV << 8) | 0177; 4219 break; 4220 case FLTIOVF: 4221 case FLTIZDIV: 4222#if (FLTFPE != FLTIOVF) /* avoid "duplicate case" error */ 4223 case FLTFPE: 4224#endif 4225 wstat = (SIGFPE << 8) | 0177; 4226 break; 4227 case FLTPAGE: /* Recoverable page fault */ 4228 default: /* FIXME: use si_signo if possible for fault */ 4229 retval = pid_to_ptid (-1); 4230 printf_filtered ("procfs:%d -- ", __LINE__); 4231 printf_filtered (_("child stopped for unknown reason:\n")); 4232 proc_prettyprint_why (why, what, 1); 4233 error (_("... giving up...")); 4234 break; 4235 } 4236 break; /* case PR_FAULTED: */ 4237 default: /* switch (why) unmatched */ 4238 printf_filtered ("procfs:%d -- ", __LINE__); 4239 printf_filtered (_("child stopped for unknown reason:\n")); 4240 proc_prettyprint_why (why, what, 1); 4241 error (_("... giving up...")); 4242 break; 4243 } 4244 /* 4245 * Got this far without error: 4246 * If retval isn't in the threads database, add it. 4247 */ 4248 if (PIDGET (retval) > 0 && 4249 !ptid_equal (retval, inferior_ptid) && 4250 !in_thread_list (retval)) 4251 { 4252 /* 4253 * We have a new thread. 4254 * We need to add it both to GDB's list and to our own. 4255 * If we don't create a procinfo, resume may be unhappy 4256 * later. 4257 */ 4258 printf_filtered (_("[New %s]\n"), target_pid_to_str (retval)); 4259 add_thread (retval); 4260 if (find_procinfo (PIDGET (retval), TIDGET (retval)) == NULL) 4261 create_procinfo (PIDGET (retval), TIDGET (retval)); 4262 4263 /* In addition, it's possible that this is the first 4264 * new thread we've seen, in which case we may not 4265 * have created entries for inferior_ptid yet. 4266 */ 4267 if (TIDGET (inferior_ptid) != 0) 4268 { 4269 if (!in_thread_list (inferior_ptid)) 4270 add_thread (inferior_ptid); 4271 if (find_procinfo (PIDGET (inferior_ptid), 4272 TIDGET (inferior_ptid)) == NULL) 4273 create_procinfo (PIDGET (inferior_ptid), 4274 TIDGET (inferior_ptid)); 4275 } 4276 } 4277 } 4278 else /* flags do not indicate STOPPED */ 4279 { 4280 /* surely this can't happen... */ 4281 printf_filtered ("procfs:%d -- process not stopped.\n", 4282 __LINE__); 4283 proc_prettyprint_flags (flags, 1); 4284 error (_("procfs: ...giving up...")); 4285 } 4286 } 4287 4288 if (status) 4289 store_waitstatus (status, wstat); 4290 } 4291 4292 return retval; 4293} 4294 4295/* Perform a partial transfer to/from the specified object. For 4296 memory transfers, fall back to the old memory xfer functions. */ 4297 4298static LONGEST 4299procfs_xfer_partial (struct target_ops *ops, enum target_object object, 4300 const char *annex, void *readbuf, 4301 const void *writebuf, ULONGEST offset, LONGEST len) 4302{ 4303 switch (object) 4304 { 4305 case TARGET_OBJECT_MEMORY: 4306 if (readbuf) 4307 return (*ops->deprecated_xfer_memory) (offset, readbuf, len, 4308 0/*write*/, NULL, ops); 4309 if (writebuf) 4310 return (*ops->deprecated_xfer_memory) (offset, writebuf, len, 4311 1/*write*/, NULL, ops); 4312 return -1; 4313 4314#ifdef NEW_PROC_API 4315 case TARGET_OBJECT_AUXV: 4316 return procfs_xfer_auxv (ops, object, annex, readbuf, writebuf, 4317 offset, len); 4318#endif 4319 4320 default: 4321 if (ops->beneath != NULL) 4322 return ops->beneath->to_xfer_partial (ops->beneath, object, annex, 4323 readbuf, writebuf, offset, len); 4324 return -1; 4325 } 4326} 4327 4328 4329/* Transfer LEN bytes between GDB address MYADDR and target address 4330 MEMADDR. If DOWRITE is non-zero, transfer them to the target, 4331 otherwise transfer them from the target. TARGET is unused. 4332 4333 The return value is 0 if an error occurred or no bytes were 4334 transferred. Otherwise, it will be a positive value which 4335 indicates the number of bytes transferred between gdb and the 4336 target. (Note that the interface also makes provisions for 4337 negative values, but this capability isn't implemented here.) */ 4338 4339static int 4340procfs_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int dowrite, 4341 struct mem_attrib *attrib, struct target_ops *target) 4342{ 4343 procinfo *pi; 4344 int nbytes = 0; 4345 4346 /* Find procinfo for main process */ 4347 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); 4348 if (pi->as_fd == 0 && 4349 open_procinfo_files (pi, FD_AS) == 0) 4350 { 4351 proc_warn (pi, "xfer_memory, open_proc_files", __LINE__); 4352 return 0; 4353 } 4354 4355 if (lseek (pi->as_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr) 4356 { 4357 if (dowrite) 4358 { 4359#ifdef NEW_PROC_API 4360 PROCFS_NOTE ("write memory: "); 4361#else 4362 PROCFS_NOTE ("write memory: \n"); 4363#endif 4364 nbytes = write (pi->as_fd, myaddr, len); 4365 } 4366 else 4367 { 4368 PROCFS_NOTE ("read memory: \n"); 4369 nbytes = read (pi->as_fd, myaddr, len); 4370 } 4371 if (nbytes < 0) 4372 { 4373 nbytes = 0; 4374 } 4375 } 4376 return nbytes; 4377} 4378 4379/* 4380 * Function: invalidate_cache 4381 * 4382 * Called by target_resume before making child runnable. 4383 * Mark cached registers and status's invalid. 4384 * If there are "dirty" caches that need to be written back 4385 * to the child process, do that. 4386 * 4387 * File descriptors are also cached. 4388 * As they are a limited resource, we cannot hold onto them indefinitely. 4389 * However, as they are expensive to open, we don't want to throw them 4390 * away indescriminately either. As a compromise, we will keep the 4391 * file descriptors for the parent process, but discard any file 4392 * descriptors we may have accumulated for the threads. 4393 * 4394 * Return value: 4395 * As this function is called by iterate_over_threads, it always 4396 * returns zero (so that iterate_over_threads will keep iterating). 4397 */ 4398 4399 4400static int 4401invalidate_cache (procinfo *parent, procinfo *pi, void *ptr) 4402{ 4403 /* 4404 * About to run the child; invalidate caches and do any other cleanup. 4405 */ 4406 4407#if 0 4408 if (pi->gregs_dirty) 4409 if (parent == NULL || 4410 proc_get_current_thread (parent) != pi->tid) 4411 if (!proc_set_gregs (pi)) /* flush gregs cache */ 4412 proc_warn (pi, "target_resume, set_gregs", 4413 __LINE__); 4414 if (gdbarch_fp0_regnum (current_gdbarch) >= 0) 4415 if (pi->fpregs_dirty) 4416 if (parent == NULL || 4417 proc_get_current_thread (parent) != pi->tid) 4418 if (!proc_set_fpregs (pi)) /* flush fpregs cache */ 4419 proc_warn (pi, "target_resume, set_fpregs", 4420 __LINE__); 4421#endif 4422 4423 if (parent != NULL) 4424 { 4425 /* The presence of a parent indicates that this is an LWP. 4426 Close any file descriptors that it might have open. 4427 We don't do this to the master (parent) procinfo. */ 4428 4429 close_procinfo_files (pi); 4430 } 4431 pi->gregs_valid = 0; 4432 pi->fpregs_valid = 0; 4433#if 0 4434 pi->gregs_dirty = 0; 4435 pi->fpregs_dirty = 0; 4436#endif 4437 pi->status_valid = 0; 4438 pi->threads_valid = 0; 4439 4440 return 0; 4441} 4442 4443#if 0 4444/* 4445 * Function: make_signal_thread_runnable 4446 * 4447 * A callback function for iterate_over_threads. 4448 * Find the asynchronous signal thread, and make it runnable. 4449 * See if that helps matters any. 4450 */ 4451 4452static int 4453make_signal_thread_runnable (procinfo *process, procinfo *pi, void *ptr) 4454{ 4455#ifdef PR_ASLWP 4456 if (proc_flags (pi) & PR_ASLWP) 4457 { 4458 if (!proc_run_process (pi, 0, -1)) 4459 proc_error (pi, "make_signal_thread_runnable", __LINE__); 4460 return 1; 4461 } 4462#endif 4463 return 0; 4464} 4465#endif 4466 4467/* 4468 * Function: target_resume 4469 * 4470 * Make the child process runnable. Normally we will then call 4471 * procfs_wait and wait for it to stop again (unles gdb is async). 4472 * 4473 * Arguments: 4474 * step: if true, then arrange for the child to stop again 4475 * after executing a single instruction. 4476 * signo: if zero, then cancel any pending signal. 4477 * If non-zero, then arrange for the indicated signal 4478 * to be delivered to the child when it runs. 4479 * pid: if -1, then allow any child thread to run. 4480 * if non-zero, then allow only the indicated thread to run. 4481 ******* (not implemented yet) 4482 */ 4483 4484static void 4485procfs_resume (ptid_t ptid, int step, enum target_signal signo) 4486{ 4487 procinfo *pi, *thread; 4488 int native_signo; 4489 4490 /* 2.1: 4491 prrun.prflags |= PRSVADDR; 4492 prrun.pr_vaddr = $PC; set resume address 4493 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all) 4494 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE) 4495 prrun.prflags |= PRCFAULT; clear current fault. 4496 4497 PRSTRACE and PRSFAULT can be done by other means 4498 (proc_trace_signals, proc_trace_faults) 4499 PRSVADDR is unnecessary. 4500 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault) 4501 This basically leaves PRSTEP and PRCSIG. 4502 PRCSIG is like PIOCSSIG (proc_clear_current_signal). 4503 So basically PR_STEP is the sole argument that must be passed 4504 to proc_run_process (for use in the prrun struct by ioctl). */ 4505 4506 /* Find procinfo for main process */ 4507 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); 4508 4509 /* First cut: ignore pid argument */ 4510 errno = 0; 4511 4512 /* Convert signal to host numbering. */ 4513 if (signo == 0 || 4514 (signo == TARGET_SIGNAL_STOP && pi->ignore_next_sigstop)) 4515 native_signo = 0; 4516 else 4517 native_signo = target_signal_to_host (signo); 4518 4519 pi->ignore_next_sigstop = 0; 4520 4521 /* Running the process voids all cached registers and status. */ 4522 /* Void the threads' caches first */ 4523 proc_iterate_over_threads (pi, invalidate_cache, NULL); 4524 /* Void the process procinfo's caches. */ 4525 invalidate_cache (NULL, pi, NULL); 4526 4527 if (PIDGET (ptid) != -1) 4528 { 4529 /* Resume a specific thread, presumably suppressing the others. */ 4530 thread = find_procinfo (PIDGET (ptid), TIDGET (ptid)); 4531 if (thread != NULL) 4532 { 4533 if (thread->tid != 0) 4534 { 4535 /* We're to resume a specific thread, and not the others. 4536 * Set the child process's PR_ASYNC flag. 4537 */ 4538#ifdef PR_ASYNC 4539 if (!proc_set_async (pi)) 4540 proc_error (pi, "target_resume, set_async", __LINE__); 4541#endif 4542#if 0 4543 proc_iterate_over_threads (pi, 4544 make_signal_thread_runnable, 4545 NULL); 4546#endif 4547 pi = thread; /* substitute the thread's procinfo for run */ 4548 } 4549 } 4550 } 4551 4552 if (!proc_run_process (pi, step, native_signo)) 4553 { 4554 if (errno == EBUSY) 4555 warning (_("resume: target already running. Pretend to resume, and hope for the best!")); 4556 else 4557 proc_error (pi, "target_resume", __LINE__); 4558 } 4559} 4560 4561/* 4562 * Function: register_gdb_signals 4563 * 4564 * Traverse the list of signals that GDB knows about 4565 * (see "handle" command), and arrange for the target 4566 * to be stopped or not, according to these settings. 4567 * 4568 * Returns non-zero for success, zero for failure. 4569 */ 4570 4571static int 4572register_gdb_signals (procinfo *pi, gdb_sigset_t *signals) 4573{ 4574 int signo; 4575 4576 for (signo = 0; signo < NSIG; signo ++) 4577 if (signal_stop_state (target_signal_from_host (signo)) == 0 && 4578 signal_print_state (target_signal_from_host (signo)) == 0 && 4579 signal_pass_state (target_signal_from_host (signo)) == 1) 4580 prdelset (signals, signo); 4581 else 4582 praddset (signals, signo); 4583 4584 return proc_set_traced_signals (pi, signals); 4585} 4586 4587/* 4588 * Function: target_notice_signals 4589 * 4590 * Set up to trace signals in the child process. 4591 */ 4592 4593static void 4594procfs_notice_signals (ptid_t ptid) 4595{ 4596 gdb_sigset_t signals; 4597 procinfo *pi = find_procinfo_or_die (PIDGET (ptid), 0); 4598 4599 if (proc_get_traced_signals (pi, &signals) && 4600 register_gdb_signals (pi, &signals)) 4601 return; 4602 else 4603 proc_error (pi, "notice_signals", __LINE__); 4604} 4605 4606/* 4607 * Function: target_files_info 4608 * 4609 * Print status information about the child process. 4610 */ 4611 4612static void 4613procfs_files_info (struct target_ops *ignore) 4614{ 4615 printf_filtered (_("\tUsing the running image of %s %s via /proc.\n"), 4616 attach_flag? "attached": "child", 4617 target_pid_to_str (inferior_ptid)); 4618} 4619 4620/* 4621 * Function: target_open 4622 * 4623 * A dummy: you don't open procfs. 4624 */ 4625 4626static void 4627procfs_open (char *args, int from_tty) 4628{ 4629 error (_("Use the \"run\" command to start a Unix child process.")); 4630} 4631 4632/* 4633 * Function: target_can_run 4634 * 4635 * This tells GDB that this target vector can be invoked 4636 * for "run" or "attach". 4637 */ 4638 4639int procfs_suppress_run = 0; /* Non-zero if procfs should pretend not to 4640 be a runnable target. Used by targets 4641 that can sit atop procfs, such as solaris 4642 thread support. */ 4643 4644 4645static int 4646procfs_can_run (void) 4647{ 4648 /* This variable is controlled by modules that sit atop procfs that 4649 may layer their own process structure atop that provided here. 4650 sol-thread.c does this because of the Solaris two-level thread 4651 model. */ 4652 4653 /* NOTE: possibly obsolete -- use the thread_stratum approach instead. */ 4654 4655 return !procfs_suppress_run; 4656} 4657 4658/* 4659 * Function: target_stop 4660 * 4661 * Stop the child process asynchronously, as when the 4662 * gdb user types control-c or presses a "stop" button. 4663 * 4664 * Works by sending kill(SIGINT) to the child's process group. 4665 */ 4666 4667static void 4668procfs_stop (void) 4669{ 4670 kill (-inferior_process_group, SIGINT); 4671} 4672 4673/* 4674 * Function: unconditionally_kill_inferior 4675 * 4676 * Make it die. Wait for it to die. Clean up after it. 4677 * Note: this should only be applied to the real process, 4678 * not to an LWP, because of the check for parent-process. 4679 * If we need this to work for an LWP, it needs some more logic. 4680 */ 4681 4682static void 4683unconditionally_kill_inferior (procinfo *pi) 4684{ 4685 int parent_pid; 4686 4687 parent_pid = proc_parent_pid (pi); 4688#ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL 4689 /* FIXME: use access functions */ 4690 /* Alpha OSF/1-3.x procfs needs a clear of the current signal 4691 before the PIOCKILL, otherwise it might generate a corrupted core 4692 file for the inferior. */ 4693 if (ioctl (pi->ctl_fd, PIOCSSIG, NULL) < 0) 4694 { 4695 printf_filtered ("unconditionally_kill: SSIG failed!\n"); 4696 } 4697#endif 4698#ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL 4699 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal 4700 to kill the inferior, otherwise it might remain stopped with a 4701 pending SIGKILL. 4702 We do not check the result of the PIOCSSIG, the inferior might have 4703 died already. */ 4704 { 4705 gdb_siginfo_t newsiginfo; 4706 4707 memset ((char *) &newsiginfo, 0, sizeof (newsiginfo)); 4708 newsiginfo.si_signo = SIGKILL; 4709 newsiginfo.si_code = 0; 4710 newsiginfo.si_errno = 0; 4711 newsiginfo.si_pid = getpid (); 4712 newsiginfo.si_uid = getuid (); 4713 /* FIXME: use proc_set_current_signal */ 4714 ioctl (pi->ctl_fd, PIOCSSIG, &newsiginfo); 4715 } 4716#else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */ 4717 if (!proc_kill (pi, SIGKILL)) 4718 proc_error (pi, "unconditionally_kill, proc_kill", __LINE__); 4719#endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */ 4720 destroy_procinfo (pi); 4721 4722 /* If pi is GDB's child, wait for it to die. */ 4723 if (parent_pid == getpid ()) 4724 /* FIXME: should we use waitpid to make sure we get the right event? 4725 Should we check the returned event? */ 4726 { 4727#if 0 4728 int status, ret; 4729 4730 ret = waitpid (pi->pid, &status, 0); 4731#else 4732 wait (NULL); 4733#endif 4734 } 4735} 4736 4737/* 4738 * Function: target_kill_inferior 4739 * 4740 * We're done debugging it, and we want it to go away. 4741 * Then we want GDB to forget all about it. 4742 */ 4743 4744static void 4745procfs_kill_inferior (void) 4746{ 4747 if (!ptid_equal (inferior_ptid, null_ptid)) /* ? */ 4748 { 4749 /* Find procinfo for main process */ 4750 procinfo *pi = find_procinfo (PIDGET (inferior_ptid), 0); 4751 4752 if (pi) 4753 unconditionally_kill_inferior (pi); 4754 target_mourn_inferior (); 4755 } 4756} 4757 4758/* 4759 * Function: target_mourn_inferior 4760 * 4761 * Forget we ever debugged this thing! 4762 */ 4763 4764static void 4765procfs_mourn_inferior (void) 4766{ 4767 procinfo *pi; 4768 4769 if (!ptid_equal (inferior_ptid, null_ptid)) 4770 { 4771 /* Find procinfo for main process */ 4772 pi = find_procinfo (PIDGET (inferior_ptid), 0); 4773 if (pi) 4774 destroy_procinfo (pi); 4775 } 4776 unpush_target (&procfs_ops); 4777 4778 if (dbx_link_bpt != NULL) 4779 { 4780 deprecated_remove_raw_breakpoint (dbx_link_bpt); 4781 dbx_link_bpt_addr = 0; 4782 dbx_link_bpt = NULL; 4783 } 4784 4785 generic_mourn_inferior (); 4786} 4787 4788/* 4789 * Function: init_inferior 4790 * 4791 * When GDB forks to create a runnable inferior process, 4792 * this function is called on the parent side of the fork. 4793 * It's job is to do whatever is necessary to make the child 4794 * ready to be debugged, and then wait for the child to synchronize. 4795 */ 4796 4797static void 4798procfs_init_inferior (int pid) 4799{ 4800 procinfo *pi; 4801 gdb_sigset_t signals; 4802 int fail; 4803 4804 /* This routine called on the parent side (GDB side) 4805 after GDB forks the inferior. */ 4806 4807 push_target (&procfs_ops); 4808 4809 if ((pi = create_procinfo (pid, 0)) == NULL) 4810 perror ("procfs: out of memory in 'init_inferior'"); 4811 4812 if (!open_procinfo_files (pi, FD_CTL)) 4813 proc_error (pi, "init_inferior, open_proc_files", __LINE__); 4814 4815 /* 4816 xmalloc // done 4817 open_procinfo_files // done 4818 link list // done 4819 prfillset (trace) 4820 procfs_notice_signals 4821 prfillset (fault) 4822 prdelset (FLTPAGE) 4823 PIOCWSTOP 4824 PIOCSFAULT 4825 */ 4826 4827 /* If not stopped yet, wait for it to stop. */ 4828 if (!(proc_flags (pi) & PR_STOPPED) && 4829 !(proc_wait_for_stop (pi))) 4830 dead_procinfo (pi, "init_inferior: wait_for_stop failed", KILL); 4831 4832 /* Save some of the /proc state to be restored if we detach. */ 4833 /* FIXME: Why? In case another debugger was debugging it? 4834 We're it's parent, for Ghu's sake! */ 4835 if (!proc_get_traced_signals (pi, &pi->saved_sigset)) 4836 proc_error (pi, "init_inferior, get_traced_signals", __LINE__); 4837 if (!proc_get_held_signals (pi, &pi->saved_sighold)) 4838 proc_error (pi, "init_inferior, get_held_signals", __LINE__); 4839 if (!proc_get_traced_faults (pi, &pi->saved_fltset)) 4840 proc_error (pi, "init_inferior, get_traced_faults", __LINE__); 4841 if (!proc_get_traced_sysentry (pi, pi->saved_entryset)) 4842 proc_error (pi, "init_inferior, get_traced_sysentry", __LINE__); 4843 if (!proc_get_traced_sysexit (pi, pi->saved_exitset)) 4844 proc_error (pi, "init_inferior, get_traced_sysexit", __LINE__); 4845 4846 /* Register to trace selected signals in the child. */ 4847 prfillset (&signals); 4848 if (!register_gdb_signals (pi, &signals)) 4849 proc_error (pi, "init_inferior, register_signals", __LINE__); 4850 4851 if ((fail = procfs_debug_inferior (pi)) != 0) 4852 proc_error (pi, "init_inferior (procfs_debug_inferior)", fail); 4853 4854 /* FIXME: logically, we should really be turning OFF run-on-last-close, 4855 and possibly even turning ON kill-on-last-close at this point. But 4856 I can't make that change without careful testing which I don't have 4857 time to do right now... */ 4858 /* Turn on run-on-last-close flag so that the child 4859 will die if GDB goes away for some reason. */ 4860 if (!proc_set_run_on_last_close (pi)) 4861 proc_error (pi, "init_inferior, set_RLC", __LINE__); 4862 4863 /* The 'process ID' we return to GDB is composed of 4864 the actual process ID plus the lwp ID. */ 4865 inferior_ptid = MERGEPID (pi->pid, proc_get_current_thread (pi)); 4866 4867 /* Typically two, one trap to exec the shell, one to exec the 4868 program being debugged. Defined by "inferior.h". */ 4869 startup_inferior (START_INFERIOR_TRAPS_EXPECTED); 4870 4871#ifdef SYS_syssgi 4872 /* On mips-irix, we need to stop the inferior early enough during 4873 the startup phase in order to be able to load the shared library 4874 symbols and insert the breakpoints that are located in these shared 4875 libraries. Stopping at the program entry point is not good enough 4876 because the -init code is executed before the execution reaches 4877 that point. 4878 4879 So what we need to do is to insert a breakpoint in the runtime 4880 loader (rld), more precisely in __dbx_link(). This procedure is 4881 called by rld once all shared libraries have been mapped, but before 4882 the -init code is executed. Unfortuantely, this is not straightforward, 4883 as rld is not part of the executable we are running, and thus we need 4884 the inferior to run until rld itself has been mapped in memory. 4885 4886 For this, we trace all syssgi() syscall exit events. Each time 4887 we detect such an event, we iterate over each text memory maps, 4888 get its associated fd, and scan the symbol table for __dbx_link(). 4889 When found, we know that rld has been mapped, and that we can insert 4890 the breakpoint at the symbol address. Once the dbx_link() breakpoint 4891 has been inserted, the syssgi() notifications are no longer necessary, 4892 so they should be canceled. */ 4893 proc_trace_syscalls_1 (pi, SYS_syssgi, PR_SYSEXIT, FLAG_SET, 0); 4894#endif 4895} 4896 4897/* 4898 * Function: set_exec_trap 4899 * 4900 * When GDB forks to create a new process, this function is called 4901 * on the child side of the fork before GDB exec's the user program. 4902 * Its job is to make the child minimally debuggable, so that the 4903 * parent GDB process can connect to the child and take over. 4904 * This function should do only the minimum to make that possible, 4905 * and to synchronize with the parent process. The parent process 4906 * should take care of the details. 4907 */ 4908 4909static void 4910procfs_set_exec_trap (void) 4911{ 4912 /* This routine called on the child side (inferior side) 4913 after GDB forks the inferior. It must use only local variables, 4914 because it may be sharing data space with its parent. */ 4915 4916 procinfo *pi; 4917 sysset_t *exitset; 4918 4919 if ((pi = create_procinfo (getpid (), 0)) == NULL) 4920 perror_with_name (_("procfs: create_procinfo failed in child.")); 4921 4922 if (open_procinfo_files (pi, FD_CTL) == 0) 4923 { 4924 proc_warn (pi, "set_exec_trap, open_proc_files", __LINE__); 4925 gdb_flush (gdb_stderr); 4926 /* no need to call "dead_procinfo", because we're going to exit. */ 4927 _exit (127); 4928 } 4929 4930#ifdef PRFS_STOPEXEC /* defined on OSF */ 4931 /* OSF method for tracing exec syscalls. Quoting: 4932 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace 4933 exits from exec system calls because of the user level loader. */ 4934 /* FIXME: make nice and maybe move into an access function. */ 4935 { 4936 int prfs_flags; 4937 4938 if (ioctl (pi->ctl_fd, PIOCGSPCACT, &prfs_flags) < 0) 4939 { 4940 proc_warn (pi, "set_exec_trap (PIOCGSPCACT)", __LINE__); 4941 gdb_flush (gdb_stderr); 4942 _exit (127); 4943 } 4944 prfs_flags |= PRFS_STOPEXEC; 4945 4946 if (ioctl (pi->ctl_fd, PIOCSSPCACT, &prfs_flags) < 0) 4947 { 4948 proc_warn (pi, "set_exec_trap (PIOCSSPCACT)", __LINE__); 4949 gdb_flush (gdb_stderr); 4950 _exit (127); 4951 } 4952 } 4953#else /* not PRFS_STOPEXEC */ 4954 /* Everyone else's (except OSF) method for tracing exec syscalls */ 4955 /* GW: Rationale... 4956 Not all systems with /proc have all the exec* syscalls with the same 4957 names. On the SGI, for example, there is no SYS_exec, but there 4958 *is* a SYS_execv. So, we try to account for that. */ 4959 4960 exitset = sysset_t_alloc (pi); 4961 gdb_premptysysset (exitset); 4962#ifdef SYS_exec 4963 gdb_praddsysset (exitset, SYS_exec); 4964#endif 4965#ifdef SYS_execve 4966 gdb_praddsysset (exitset, SYS_execve); 4967#endif 4968#ifdef SYS_execv 4969 gdb_praddsysset (exitset, SYS_execv); 4970#endif 4971#ifdef DYNAMIC_SYSCALLS 4972 { 4973 int callnum = find_syscall (pi, "execve"); 4974 4975 if (callnum >= 0) 4976 gdb_praddsysset (exitset, callnum); 4977 4978 callnum = find_syscall (pi, "ra_execve"); 4979 if (callnum >= 0) 4980 gdb_praddsysset (exitset, callnum); 4981 } 4982#endif /* DYNAMIC_SYSCALLS */ 4983 4984 if (!proc_set_traced_sysexit (pi, exitset)) 4985 { 4986 proc_warn (pi, "set_exec_trap, set_traced_sysexit", __LINE__); 4987 gdb_flush (gdb_stderr); 4988 _exit (127); 4989 } 4990#endif /* PRFS_STOPEXEC */ 4991 4992 /* FIXME: should this be done in the parent instead? */ 4993 /* Turn off inherit on fork flag so that all grand-children 4994 of gdb start with tracing flags cleared. */ 4995 if (!proc_unset_inherit_on_fork (pi)) 4996 proc_warn (pi, "set_exec_trap, unset_inherit", __LINE__); 4997 4998 /* Turn off run on last close flag, so that the child process 4999 cannot run away just because we close our handle on it. 5000 We want it to wait for the parent to attach. */ 5001 if (!proc_unset_run_on_last_close (pi)) 5002 proc_warn (pi, "set_exec_trap, unset_RLC", __LINE__); 5003 5004 /* FIXME: No need to destroy the procinfo -- 5005 we have our own address space, and we're about to do an exec! */ 5006 /*destroy_procinfo (pi);*/ 5007} 5008 5009/* 5010 * Function: create_inferior 5011 * 5012 * This function is called BEFORE gdb forks the inferior process. 5013 * Its only real responsibility is to set things up for the fork, 5014 * and tell GDB which two functions to call after the fork (one 5015 * for the parent, and one for the child). 5016 * 5017 * This function does a complicated search for a unix shell program, 5018 * which it then uses to parse arguments and environment variables 5019 * to be sent to the child. I wonder whether this code could not 5020 * be abstracted out and shared with other unix targets such as 5021 * infptrace? 5022 */ 5023 5024static void 5025procfs_create_inferior (char *exec_file, char *allargs, char **env, 5026 int from_tty) 5027{ 5028 char *shell_file = getenv ("SHELL"); 5029 char *tryname; 5030 if (shell_file != NULL && strchr (shell_file, '/') == NULL) 5031 { 5032 5033 /* We will be looking down the PATH to find shell_file. If we 5034 just do this the normal way (via execlp, which operates by 5035 attempting an exec for each element of the PATH until it 5036 finds one which succeeds), then there will be an exec for 5037 each failed attempt, each of which will cause a PR_SYSEXIT 5038 stop, and we won't know how to distinguish the PR_SYSEXIT's 5039 for these failed execs with the ones for successful execs 5040 (whether the exec has succeeded is stored at that time in the 5041 carry bit or some such architecture-specific and 5042 non-ABI-specified place). 5043 5044 So I can't think of anything better than to search the PATH 5045 now. This has several disadvantages: (1) There is a race 5046 condition; if we find a file now and it is deleted before we 5047 exec it, we lose, even if the deletion leaves a valid file 5048 further down in the PATH, (2) there is no way to know exactly 5049 what an executable (in the sense of "capable of being 5050 exec'd") file is. Using access() loses because it may lose 5051 if the caller is the superuser; failing to use it loses if 5052 there are ACLs or some such. */ 5053 5054 char *p; 5055 char *p1; 5056 /* FIXME-maybe: might want "set path" command so user can change what 5057 path is used from within GDB. */ 5058 char *path = getenv ("PATH"); 5059 int len; 5060 struct stat statbuf; 5061 5062 if (path == NULL) 5063 path = "/bin:/usr/bin"; 5064 5065 tryname = alloca (strlen (path) + strlen (shell_file) + 2); 5066 for (p = path; p != NULL; p = p1 ? p1 + 1: NULL) 5067 { 5068 p1 = strchr (p, ':'); 5069 if (p1 != NULL) 5070 len = p1 - p; 5071 else 5072 len = strlen (p); 5073 strncpy (tryname, p, len); 5074 tryname[len] = '\0'; 5075 strcat (tryname, "/"); 5076 strcat (tryname, shell_file); 5077 if (access (tryname, X_OK) < 0) 5078 continue; 5079 if (stat (tryname, &statbuf) < 0) 5080 continue; 5081 if (!S_ISREG (statbuf.st_mode)) 5082 /* We certainly need to reject directories. I'm not quite 5083 as sure about FIFOs, sockets, etc., but I kind of doubt 5084 that people want to exec() these things. */ 5085 continue; 5086 break; 5087 } 5088 if (p == NULL) 5089 /* Not found. This must be an error rather than merely passing 5090 the file to execlp(), because execlp() would try all the 5091 exec()s, causing GDB to get confused. */ 5092 error (_("procfs:%d -- Can't find shell %s in PATH"), 5093 __LINE__, shell_file); 5094 5095 shell_file = tryname; 5096 } 5097 5098 fork_inferior (exec_file, allargs, env, procfs_set_exec_trap, 5099 procfs_init_inferior, NULL, shell_file); 5100 5101#ifdef SYS_syssgi 5102 /* Make sure to cancel the syssgi() syscall-exit notifications. 5103 They should normally have been removed by now, but they may still 5104 be activated if the inferior doesn't use shared libraries, or if 5105 we didn't locate __dbx_link, or if we never stopped in __dbx_link. 5106 See procfs_init_inferior() for more details. */ 5107 proc_trace_syscalls_1 (find_procinfo_or_die (PIDGET (inferior_ptid), 0), 5108 SYS_syssgi, PR_SYSEXIT, FLAG_RESET, 0); 5109#endif 5110} 5111 5112/* 5113 * Function: notice_thread 5114 * 5115 * Callback for find_new_threads. 5116 * Calls "add_thread". 5117 */ 5118 5119static int 5120procfs_notice_thread (procinfo *pi, procinfo *thread, void *ptr) 5121{ 5122 ptid_t gdb_threadid = MERGEPID (pi->pid, thread->tid); 5123 5124 if (!in_thread_list (gdb_threadid)) 5125 add_thread (gdb_threadid); 5126 5127 return 0; 5128} 5129 5130/* 5131 * Function: target_find_new_threads 5132 * 5133 * Query all the threads that the target knows about, 5134 * and give them back to GDB to add to its list. 5135 */ 5136 5137void 5138procfs_find_new_threads (void) 5139{ 5140 procinfo *pi; 5141 5142 /* Find procinfo for main process */ 5143 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); 5144 proc_update_threads (pi); 5145 proc_iterate_over_threads (pi, procfs_notice_thread, NULL); 5146} 5147 5148/* 5149 * Function: target_thread_alive 5150 * 5151 * Return true if the thread is still 'alive'. 5152 * 5153 * This guy doesn't really seem to be doing his job. 5154 * Got to investigate how to tell when a thread is really gone. 5155 */ 5156 5157static int 5158procfs_thread_alive (ptid_t ptid) 5159{ 5160 int proc, thread; 5161 procinfo *pi; 5162 5163 proc = PIDGET (ptid); 5164 thread = TIDGET (ptid); 5165 /* If I don't know it, it ain't alive! */ 5166 if ((pi = find_procinfo (proc, thread)) == NULL) 5167 return 0; 5168 5169 /* If I can't get its status, it ain't alive! 5170 What's more, I need to forget about it! */ 5171 if (!proc_get_status (pi)) 5172 { 5173 destroy_procinfo (pi); 5174 return 0; 5175 } 5176 /* I couldn't have got its status if it weren't alive, so it's alive. */ 5177 return 1; 5178} 5179 5180/* Convert PTID to a string. Returns the string in a static buffer. */ 5181 5182char * 5183procfs_pid_to_str (ptid_t ptid) 5184{ 5185 static char buf[80]; 5186 5187 if (TIDGET (ptid) == 0) 5188 sprintf (buf, "process %d", PIDGET (ptid)); 5189 else 5190 sprintf (buf, "LWP %ld", TIDGET (ptid)); 5191 5192 return buf; 5193} 5194 5195/* 5196 * Function: procfs_set_watchpoint 5197 * Insert a watchpoint 5198 */ 5199 5200int 5201procfs_set_watchpoint (ptid_t ptid, CORE_ADDR addr, int len, int rwflag, 5202 int after) 5203{ 5204#ifndef UNIXWARE 5205#ifndef AIX5 5206 int pflags = 0; 5207 procinfo *pi; 5208 5209 pi = find_procinfo_or_die (PIDGET (ptid) == -1 ? 5210 PIDGET (inferior_ptid) : PIDGET (ptid), 0); 5211 5212 /* Translate from GDB's flags to /proc's */ 5213 if (len > 0) /* len == 0 means delete watchpoint */ 5214 { 5215 switch (rwflag) { /* FIXME: need an enum! */ 5216 case hw_write: /* default watchpoint (write) */ 5217 pflags = WRITE_WATCHFLAG; 5218 break; 5219 case hw_read: /* read watchpoint */ 5220 pflags = READ_WATCHFLAG; 5221 break; 5222 case hw_access: /* access watchpoint */ 5223 pflags = READ_WATCHFLAG | WRITE_WATCHFLAG; 5224 break; 5225 case hw_execute: /* execution HW breakpoint */ 5226 pflags = EXEC_WATCHFLAG; 5227 break; 5228 default: /* Something weird. Return error. */ 5229 return -1; 5230 } 5231 if (after) /* Stop after r/w access is completed. */ 5232 pflags |= AFTER_WATCHFLAG; 5233 } 5234 5235 if (!proc_set_watchpoint (pi, addr, len, pflags)) 5236 { 5237 if (errno == E2BIG) /* Typical error for no resources */ 5238 return -1; /* fail */ 5239 /* GDB may try to remove the same watchpoint twice. 5240 If a remove request returns no match, don't error. */ 5241 if (errno == ESRCH && len == 0) 5242 return 0; /* ignore */ 5243 proc_error (pi, "set_watchpoint", __LINE__); 5244 } 5245#endif /* AIX5 */ 5246#endif /* UNIXWARE */ 5247 return 0; 5248} 5249 5250/* Return non-zero if we can set a hardware watchpoint of type TYPE. TYPE 5251 is one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint, 5252 or bp_hardware_watchpoint. CNT is the number of watchpoints used so 5253 far. 5254 5255 Note: procfs_can_use_hw_breakpoint() is not yet used by all 5256 procfs.c targets due to the fact that some of them still define 5257 TARGET_CAN_USE_HARDWARE_WATCHPOINT. */ 5258 5259static int 5260procfs_can_use_hw_breakpoint (int type, int cnt, int othertype) 5261{ 5262#ifndef TARGET_HAS_HARDWARE_WATCHPOINTS 5263 return 0; 5264#else 5265 /* Due to the way that proc_set_watchpoint() is implemented, host 5266 and target pointers must be of the same size. If they are not, 5267 we can't use hardware watchpoints. This limitation is due to the 5268 fact that proc_set_watchpoint() calls 5269 procfs_address_to_host_pointer(); a close inspection of 5270 procfs_address_to_host_pointer will reveal that an internal error 5271 will be generated when the host and target pointer sizes are 5272 different. */ 5273 if (sizeof (void *) != TYPE_LENGTH (builtin_type_void_data_ptr)) 5274 return 0; 5275 5276 /* Other tests here??? */ 5277 5278 return 1; 5279#endif 5280} 5281 5282/* 5283 * Function: stopped_by_watchpoint 5284 * 5285 * Returns non-zero if process is stopped on a hardware watchpoint fault, 5286 * else returns zero. 5287 */ 5288 5289int 5290procfs_stopped_by_watchpoint (ptid_t ptid) 5291{ 5292 procinfo *pi; 5293 5294 pi = find_procinfo_or_die (PIDGET (ptid) == -1 ? 5295 PIDGET (inferior_ptid) : PIDGET (ptid), 0); 5296 5297 if (!pi) /* If no process, then not stopped by watchpoint! */ 5298 return 0; 5299 5300 if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) 5301 { 5302 if (proc_why (pi) == PR_FAULTED) 5303 { 5304#ifdef FLTWATCH 5305 if (proc_what (pi) == FLTWATCH) 5306 return 1; 5307#endif 5308#ifdef FLTKWATCH 5309 if (proc_what (pi) == FLTKWATCH) 5310 return 1; 5311#endif 5312 } 5313 } 5314 return 0; 5315} 5316 5317#ifdef TM_I386SOL2_H 5318/* 5319 * Function: procfs_find_LDT_entry 5320 * 5321 * Input: 5322 * ptid_t ptid; // The GDB-style pid-plus-LWP. 5323 * 5324 * Return: 5325 * pointer to the corresponding LDT entry. 5326 */ 5327 5328struct ssd * 5329procfs_find_LDT_entry (ptid_t ptid) 5330{ 5331 gdb_gregset_t *gregs; 5332 int key; 5333 procinfo *pi; 5334 5335 /* Find procinfo for the lwp. */ 5336 if ((pi = find_procinfo (PIDGET (ptid), TIDGET (ptid))) == NULL) 5337 { 5338 warning (_("procfs_find_LDT_entry: could not find procinfo for %d:%d."), 5339 PIDGET (ptid), TIDGET (ptid)); 5340 return NULL; 5341 } 5342 /* get its general registers. */ 5343 if ((gregs = proc_get_gregs (pi)) == NULL) 5344 { 5345 warning (_("procfs_find_LDT_entry: could not read gregs for %d:%d."), 5346 PIDGET (ptid), TIDGET (ptid)); 5347 return NULL; 5348 } 5349 /* Now extract the GS register's lower 16 bits. */ 5350 key = (*gregs)[GS] & 0xffff; 5351 5352 /* Find the matching entry and return it. */ 5353 return proc_get_LDT_entry (pi, key); 5354} 5355#endif /* TM_I386SOL2_H */ 5356 5357/* 5358 * Memory Mappings Functions: 5359 */ 5360 5361/* 5362 * Function: iterate_over_mappings 5363 * 5364 * Call a callback function once for each mapping, passing it the mapping, 5365 * an optional secondary callback function, and some optional opaque data. 5366 * Quit and return the first non-zero value returned from the callback. 5367 * 5368 * Arguments: 5369 * pi -- procinfo struct for the process to be mapped. 5370 * func -- callback function to be called by this iterator. 5371 * data -- optional opaque data to be passed to the callback function. 5372 * child_func -- optional secondary function pointer to be passed 5373 * to the child function. 5374 * 5375 * Return: First non-zero return value from the callback function, 5376 * or zero. 5377 */ 5378 5379static int 5380iterate_over_mappings (procinfo *pi, int (*child_func) (), void *data, 5381 int (*func) (struct prmap *map, 5382 int (*child_func) (), 5383 void *data)) 5384{ 5385 char pathname[MAX_PROC_NAME_SIZE]; 5386 struct prmap *prmaps; 5387 struct prmap *prmap; 5388 int funcstat; 5389 int map_fd; 5390 int nmap; 5391#ifdef NEW_PROC_API 5392 struct stat sbuf; 5393#endif 5394 5395 /* Get the number of mappings, allocate space, 5396 and read the mappings into prmaps. */ 5397#ifdef NEW_PROC_API 5398 /* Open map fd. */ 5399 sprintf (pathname, "/proc/%d/map", pi->pid); 5400 if ((map_fd = open (pathname, O_RDONLY)) < 0) 5401 proc_error (pi, "iterate_over_mappings (open)", __LINE__); 5402 5403 /* Make sure it gets closed again. */ 5404 make_cleanup_close (map_fd); 5405 5406 /* Use stat to determine the file size, and compute 5407 the number of prmap_t objects it contains. */ 5408 if (fstat (map_fd, &sbuf) != 0) 5409 proc_error (pi, "iterate_over_mappings (fstat)", __LINE__); 5410 5411 nmap = sbuf.st_size / sizeof (prmap_t); 5412 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps)); 5413 if (read (map_fd, (char *) prmaps, nmap * sizeof (*prmaps)) 5414 != (nmap * sizeof (*prmaps))) 5415 proc_error (pi, "iterate_over_mappings (read)", __LINE__); 5416#else 5417 /* Use ioctl command PIOCNMAP to get number of mappings. */ 5418 if (ioctl (pi->ctl_fd, PIOCNMAP, &nmap) != 0) 5419 proc_error (pi, "iterate_over_mappings (PIOCNMAP)", __LINE__); 5420 5421 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps)); 5422 if (ioctl (pi->ctl_fd, PIOCMAP, prmaps) != 0) 5423 proc_error (pi, "iterate_over_mappings (PIOCMAP)", __LINE__); 5424#endif 5425 5426 for (prmap = prmaps; nmap > 0; prmap++, nmap--) 5427 if ((funcstat = (*func) (prmap, child_func, data)) != 0) 5428 return funcstat; 5429 5430 return 0; 5431} 5432 5433/* 5434 * Function: solib_mappings_callback 5435 * 5436 * Calls the supplied callback function once for each mapped address 5437 * space in the process. The callback function receives an open 5438 * file descriptor for the file corresponding to that mapped 5439 * address space (if there is one), and the base address of the 5440 * mapped space. Quit when the callback function returns a 5441 * nonzero value, or at teh end of the mappings. 5442 * 5443 * Returns: the first non-zero return value of the callback function, 5444 * or zero. 5445 */ 5446 5447int solib_mappings_callback (struct prmap *map, 5448 int (*func) (int, CORE_ADDR), 5449 void *data) 5450{ 5451 procinfo *pi = data; 5452 int fd; 5453 5454#ifdef NEW_PROC_API 5455 char name[MAX_PROC_NAME_SIZE + sizeof (map->pr_mapname)]; 5456 5457 if (map->pr_vaddr == 0 && map->pr_size == 0) 5458 return -1; /* sanity */ 5459 5460 if (map->pr_mapname[0] == 0) 5461 { 5462 fd = -1; /* no map file */ 5463 } 5464 else 5465 { 5466 sprintf (name, "/proc/%d/object/%s", pi->pid, map->pr_mapname); 5467 /* Note: caller's responsibility to close this fd! */ 5468 fd = open_with_retry (name, O_RDONLY); 5469 /* Note: we don't test the above call for failure; 5470 we just pass the FD on as given. Sometimes there is 5471 no file, so the open may return failure, but that's 5472 not a problem. */ 5473 } 5474#else 5475 fd = ioctl (pi->ctl_fd, PIOCOPENM, &map->pr_vaddr); 5476 /* Note: we don't test the above call for failure; 5477 we just pass the FD on as given. Sometimes there is 5478 no file, so the ioctl may return failure, but that's 5479 not a problem. */ 5480#endif 5481 return (*func) (fd, (CORE_ADDR) map->pr_vaddr); 5482} 5483 5484/* 5485 * Function: proc_iterate_over_mappings 5486 * 5487 * Uses the unified "iterate_over_mappings" function 5488 * to implement the exported interface to solib-svr4.c. 5489 * 5490 * Given a pointer to a function, call that function once for every 5491 * mapped address space in the process. The callback function 5492 * receives an open file descriptor for the file corresponding to 5493 * that mapped address space (if there is one), and the base address 5494 * of the mapped space. Quit when the callback function returns a 5495 * nonzero value, or at teh end of the mappings. 5496 * 5497 * Returns: the first non-zero return value of the callback function, 5498 * or zero. 5499 */ 5500 5501int 5502proc_iterate_over_mappings (int (*func) (int, CORE_ADDR)) 5503{ 5504 procinfo *pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); 5505 5506 return iterate_over_mappings (pi, func, pi, solib_mappings_callback); 5507} 5508 5509/* 5510 * Function: find_memory_regions_callback 5511 * 5512 * Implements the to_find_memory_regions method. 5513 * Calls an external function for each memory region. 5514 * External function will have the signiture: 5515 * 5516 * int callback (CORE_ADDR vaddr, 5517 * unsigned long size, 5518 * int read, int write, int execute, 5519 * void *data); 5520 * 5521 * Returns the integer value returned by the callback. 5522 */ 5523 5524static int 5525find_memory_regions_callback (struct prmap *map, 5526 int (*func) (CORE_ADDR, 5527 unsigned long, 5528 int, int, int, 5529 void *), 5530 void *data) 5531{ 5532 return (*func) ((CORE_ADDR) map->pr_vaddr, 5533 map->pr_size, 5534 (map->pr_mflags & MA_READ) != 0, 5535 (map->pr_mflags & MA_WRITE) != 0, 5536 (map->pr_mflags & MA_EXEC) != 0, 5537 data); 5538} 5539 5540/* 5541 * Function: proc_find_memory_regions 5542 * 5543 * External interface. Calls a callback function once for each 5544 * mapped memory region in the child process, passing as arguments 5545 * CORE_ADDR virtual_address, 5546 * unsigned long size, 5547 * int read, TRUE if region is readable by the child 5548 * int write, TRUE if region is writable by the child 5549 * int execute TRUE if region is executable by the child. 5550 * 5551 * Stops iterating and returns the first non-zero value 5552 * returned by the callback. 5553 */ 5554 5555static int 5556proc_find_memory_regions (int (*func) (CORE_ADDR, 5557 unsigned long, 5558 int, int, int, 5559 void *), 5560 void *data) 5561{ 5562 procinfo *pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); 5563 5564 return iterate_over_mappings (pi, func, data, 5565 find_memory_regions_callback); 5566} 5567 5568/* Remove the breakpoint that we inserted in __dbx_link(). 5569 Does nothing if the breakpoint hasn't been inserted or has already 5570 been removed. */ 5571 5572static void 5573remove_dbx_link_breakpoint (void) 5574{ 5575 if (dbx_link_bpt_addr == 0) 5576 return; 5577 5578 if (deprecated_remove_raw_breakpoint (dbx_link_bpt) != 0) 5579 warning (_("Unable to remove __dbx_link breakpoint.")); 5580 5581 dbx_link_bpt_addr = 0; 5582 dbx_link_bpt = NULL; 5583} 5584 5585/* Return the address of the __dbx_link() function in the file 5586 refernced by ABFD by scanning its symbol table. Return 0 if 5587 the symbol was not found. */ 5588 5589static CORE_ADDR 5590dbx_link_addr (bfd *abfd) 5591{ 5592 long storage_needed; 5593 asymbol **symbol_table; 5594 long number_of_symbols; 5595 long i; 5596 5597 storage_needed = bfd_get_symtab_upper_bound (abfd); 5598 if (storage_needed <= 0) 5599 return 0; 5600 5601 symbol_table = (asymbol **) xmalloc (storage_needed); 5602 make_cleanup (xfree, symbol_table); 5603 5604 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); 5605 5606 for (i = 0; i < number_of_symbols; i++) 5607 { 5608 asymbol *sym = symbol_table[i]; 5609 5610 if ((sym->flags & BSF_GLOBAL) 5611 && sym->name != NULL && strcmp (sym->name, "__dbx_link") == 0) 5612 return (sym->value + sym->section->vma); 5613 } 5614 5615 /* Symbol not found, return NULL. */ 5616 return 0; 5617} 5618 5619/* Search the symbol table of the file referenced by FD for a symbol 5620 named __dbx_link(). If found, then insert a breakpoint at this location, 5621 and return nonzero. Return zero otherwise. */ 5622 5623static int 5624insert_dbx_link_bpt_in_file (int fd, CORE_ADDR ignored) 5625{ 5626 bfd *abfd; 5627 long storage_needed; 5628 CORE_ADDR sym_addr; 5629 5630 abfd = bfd_fdopenr ("unamed", 0, fd); 5631 if (abfd == NULL) 5632 { 5633 warning (_("Failed to create a bfd: %s."), bfd_errmsg (bfd_get_error ())); 5634 return 0; 5635 } 5636 5637 if (!bfd_check_format (abfd, bfd_object)) 5638 { 5639 /* Not the correct format, so we can not possibly find the dbx_link 5640 symbol in it. */ 5641 bfd_close (abfd); 5642 return 0; 5643 } 5644 5645 sym_addr = dbx_link_addr (abfd); 5646 if (sym_addr != 0) 5647 { 5648 /* Insert the breakpoint. */ 5649 dbx_link_bpt_addr = sym_addr; 5650 dbx_link_bpt = deprecated_insert_raw_breakpoint (sym_addr); 5651 if (dbx_link_bpt == NULL) 5652 { 5653 warning (_("Failed to insert dbx_link breakpoint.")); 5654 bfd_close (abfd); 5655 return 0; 5656 } 5657 bfd_close (abfd); 5658 return 1; 5659 } 5660 5661 bfd_close (abfd); 5662 return 0; 5663} 5664 5665/* If the given memory region MAP contains a symbol named __dbx_link, 5666 insert a breakpoint at this location and return nonzero. Return 5667 zero otherwise. */ 5668 5669static int 5670insert_dbx_link_bpt_in_region (struct prmap *map, 5671 int (*child_func) (), 5672 void *data) 5673{ 5674 procinfo *pi = (procinfo *) data; 5675 5676 /* We know the symbol we're looking for is in a text region, so 5677 only look for it if the region is a text one. */ 5678 if (map->pr_mflags & MA_EXEC) 5679 return solib_mappings_callback (map, insert_dbx_link_bpt_in_file, pi); 5680 5681 return 0; 5682} 5683 5684/* Search all memory regions for a symbol named __dbx_link. If found, 5685 insert a breakpoint at its location, and return nonzero. Return zero 5686 otherwise. */ 5687 5688static int 5689insert_dbx_link_breakpoint (procinfo *pi) 5690{ 5691 return iterate_over_mappings (pi, NULL, pi, insert_dbx_link_bpt_in_region); 5692} 5693 5694/* 5695 * Function: mappingflags 5696 * 5697 * Returns an ascii representation of a memory mapping's flags. 5698 */ 5699 5700static char * 5701mappingflags (long flags) 5702{ 5703 static char asciiflags[8]; 5704 5705 strcpy (asciiflags, "-------"); 5706#if defined (MA_PHYS) 5707 if (flags & MA_PHYS) 5708 asciiflags[0] = 'd'; 5709#endif 5710 if (flags & MA_STACK) 5711 asciiflags[1] = 's'; 5712 if (flags & MA_BREAK) 5713 asciiflags[2] = 'b'; 5714 if (flags & MA_SHARED) 5715 asciiflags[3] = 's'; 5716 if (flags & MA_READ) 5717 asciiflags[4] = 'r'; 5718 if (flags & MA_WRITE) 5719 asciiflags[5] = 'w'; 5720 if (flags & MA_EXEC) 5721 asciiflags[6] = 'x'; 5722 return (asciiflags); 5723} 5724 5725/* 5726 * Function: info_mappings_callback 5727 * 5728 * Callback function, does the actual work for 'info proc mappings'. 5729 */ 5730 5731static int 5732info_mappings_callback (struct prmap *map, int (*ignore) (), void *unused) 5733{ 5734 char *data_fmt_string; 5735 5736 if (gdbarch_addr_bit (current_gdbarch) == 32) 5737 data_fmt_string = "\t%#10lx %#10lx %#10x %#10x %7s\n"; 5738 else 5739 data_fmt_string = " %#18lx %#18lx %#10x %#10x %7s\n"; 5740 5741 printf_filtered (data_fmt_string, 5742 (unsigned long) map->pr_vaddr, 5743 (unsigned long) map->pr_vaddr + map->pr_size - 1, 5744 map->pr_size, 5745#ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */ 5746 (unsigned int) map->pr_offset, 5747#else 5748 map->pr_off, 5749#endif 5750 mappingflags (map->pr_mflags)); 5751 5752 return 0; 5753} 5754 5755/* 5756 * Function: info_proc_mappings 5757 * 5758 * Implement the "info proc mappings" subcommand. 5759 */ 5760 5761static void 5762info_proc_mappings (procinfo *pi, int summary) 5763{ 5764 char *header_fmt_string; 5765 5766 if (gdbarch_ptr_bit (current_gdbarch) == 32) 5767 header_fmt_string = "\t%10s %10s %10s %10s %7s\n"; 5768 else 5769 header_fmt_string = " %18s %18s %10s %10s %7s\n"; 5770 5771 if (summary) 5772 return; /* No output for summary mode. */ 5773 5774 printf_filtered (_("Mapped address spaces:\n\n")); 5775 printf_filtered (header_fmt_string, 5776 "Start Addr", 5777 " End Addr", 5778 " Size", 5779 " Offset", 5780 "Flags"); 5781 5782 iterate_over_mappings (pi, NULL, NULL, info_mappings_callback); 5783 printf_filtered ("\n"); 5784} 5785 5786/* 5787 * Function: info_proc_cmd 5788 * 5789 * Implement the "info proc" command. 5790 */ 5791 5792static void 5793info_proc_cmd (char *args, int from_tty) 5794{ 5795 struct cleanup *old_chain; 5796 procinfo *process = NULL; 5797 procinfo *thread = NULL; 5798 char **argv = NULL; 5799 char *tmp = NULL; 5800 int pid = 0; 5801 int tid = 0; 5802 int mappings = 0; 5803 5804 old_chain = make_cleanup (null_cleanup, 0); 5805 if (args) 5806 { 5807 if ((argv = buildargv (args)) == NULL) 5808 nomem (0); 5809 else 5810 make_cleanup_freeargv (argv); 5811 } 5812 while (argv != NULL && *argv != NULL) 5813 { 5814 if (isdigit (argv[0][0])) 5815 { 5816 pid = strtoul (argv[0], &tmp, 10); 5817 if (*tmp == '/') 5818 tid = strtoul (++tmp, NULL, 10); 5819 } 5820 else if (argv[0][0] == '/') 5821 { 5822 tid = strtoul (argv[0] + 1, NULL, 10); 5823 } 5824 else if (strncmp (argv[0], "mappings", strlen (argv[0])) == 0) 5825 { 5826 mappings = 1; 5827 } 5828 else 5829 { 5830 /* [...] */ 5831 } 5832 argv++; 5833 } 5834 if (pid == 0) 5835 pid = PIDGET (inferior_ptid); 5836 if (pid == 0) 5837 error (_("No current process: you must name one.")); 5838 else 5839 { 5840 /* Have pid, will travel. 5841 First see if it's a process we're already debugging. */ 5842 process = find_procinfo (pid, 0); 5843 if (process == NULL) 5844 { 5845 /* No. So open a procinfo for it, but 5846 remember to close it again when finished. */ 5847 process = create_procinfo (pid, 0); 5848 make_cleanup (do_destroy_procinfo_cleanup, process); 5849 if (!open_procinfo_files (process, FD_CTL)) 5850 proc_error (process, "info proc, open_procinfo_files", __LINE__); 5851 } 5852 } 5853 if (tid != 0) 5854 thread = create_procinfo (pid, tid); 5855 5856 if (process) 5857 { 5858 printf_filtered (_("process %d flags:\n"), process->pid); 5859 proc_prettyprint_flags (proc_flags (process), 1); 5860 if (proc_flags (process) & (PR_STOPPED | PR_ISTOP)) 5861 proc_prettyprint_why (proc_why (process), proc_what (process), 1); 5862 if (proc_get_nthreads (process) > 1) 5863 printf_filtered ("Process has %d threads.\n", 5864 proc_get_nthreads (process)); 5865 } 5866 if (thread) 5867 { 5868 printf_filtered (_("thread %d flags:\n"), thread->tid); 5869 proc_prettyprint_flags (proc_flags (thread), 1); 5870 if (proc_flags (thread) & (PR_STOPPED | PR_ISTOP)) 5871 proc_prettyprint_why (proc_why (thread), proc_what (thread), 1); 5872 } 5873 5874 if (mappings) 5875 { 5876 info_proc_mappings (process, 0); 5877 } 5878 5879 do_cleanups (old_chain); 5880} 5881 5882/* Modify the status of the system call identified by SYSCALLNUM in 5883 the set of syscalls that are currently traced/debugged. 5884 5885 If ENTRY_OR_EXIT is set to PR_SYSENTRY, then the entry syscalls set 5886 will be updated. Otherwise, the exit syscalls set will be updated. 5887 5888 If MODE is FLAG_SET, then traces will be enabled. Otherwise, they 5889 will be disabled. */ 5890 5891static void 5892proc_trace_syscalls_1 (procinfo *pi, int syscallnum, int entry_or_exit, 5893 int mode, int from_tty) 5894{ 5895 sysset_t *sysset; 5896 5897 if (entry_or_exit == PR_SYSENTRY) 5898 sysset = proc_get_traced_sysentry (pi, NULL); 5899 else 5900 sysset = proc_get_traced_sysexit (pi, NULL); 5901 5902 if (sysset == NULL) 5903 proc_error (pi, "proc-trace, get_traced_sysset", __LINE__); 5904 5905 if (mode == FLAG_SET) 5906 gdb_praddsysset (sysset, syscallnum); 5907 else 5908 gdb_prdelsysset (sysset, syscallnum); 5909 5910 if (entry_or_exit == PR_SYSENTRY) 5911 { 5912 if (!proc_set_traced_sysentry (pi, sysset)) 5913 proc_error (pi, "proc-trace, set_traced_sysentry", __LINE__); 5914 } 5915 else 5916 { 5917 if (!proc_set_traced_sysexit (pi, sysset)) 5918 proc_error (pi, "proc-trace, set_traced_sysexit", __LINE__); 5919 } 5920} 5921 5922static void 5923proc_trace_syscalls (char *args, int from_tty, int entry_or_exit, int mode) 5924{ 5925 procinfo *pi; 5926 5927 if (PIDGET (inferior_ptid) <= 0) 5928 error (_("you must be debugging a process to use this command.")); 5929 5930 if (args == NULL || args[0] == 0) 5931 error_no_arg (_("system call to trace")); 5932 5933 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); 5934 if (isdigit (args[0])) 5935 { 5936 const int syscallnum = atoi (args); 5937 5938 proc_trace_syscalls_1 (pi, syscallnum, entry_or_exit, mode, from_tty); 5939 } 5940} 5941 5942static void 5943proc_trace_sysentry_cmd (char *args, int from_tty) 5944{ 5945 proc_trace_syscalls (args, from_tty, PR_SYSENTRY, FLAG_SET); 5946} 5947 5948static void 5949proc_trace_sysexit_cmd (char *args, int from_tty) 5950{ 5951 proc_trace_syscalls (args, from_tty, PR_SYSEXIT, FLAG_SET); 5952} 5953 5954static void 5955proc_untrace_sysentry_cmd (char *args, int from_tty) 5956{ 5957 proc_trace_syscalls (args, from_tty, PR_SYSENTRY, FLAG_RESET); 5958} 5959 5960static void 5961proc_untrace_sysexit_cmd (char *args, int from_tty) 5962{ 5963 proc_trace_syscalls (args, from_tty, PR_SYSEXIT, FLAG_RESET); 5964} 5965 5966 5967void 5968_initialize_procfs (void) 5969{ 5970 init_procfs_ops (); 5971 add_target (&procfs_ops); 5972 add_info ("proc", info_proc_cmd, _("\ 5973Show /proc process information about any running process.\n\ 5974Specify process id, or use the program being debugged by default.\n\ 5975Specify keyword 'mappings' for detailed info on memory mappings.")); 5976 add_com ("proc-trace-entry", no_class, proc_trace_sysentry_cmd, 5977 _("Give a trace of entries into the syscall.")); 5978 add_com ("proc-trace-exit", no_class, proc_trace_sysexit_cmd, 5979 _("Give a trace of exits from the syscall.")); 5980 add_com ("proc-untrace-entry", no_class, proc_untrace_sysentry_cmd, 5981 _("Cancel a trace of entries into the syscall.")); 5982 add_com ("proc-untrace-exit", no_class, proc_untrace_sysexit_cmd, 5983 _("Cancel a trace of exits from the syscall.")); 5984} 5985 5986/* =================== END, GDB "MODULE" =================== */ 5987 5988 5989 5990/* miscellaneous stubs: */ 5991/* The following satisfy a few random symbols mostly created by */ 5992/* the solaris threads implementation, which I will chase down */ 5993/* later. */ 5994 5995/* 5996 * Return a pid for which we guarantee 5997 * we will be able to find a 'live' procinfo. 5998 */ 5999 6000ptid_t 6001procfs_first_available (void) 6002{ 6003 return pid_to_ptid (procinfo_list ? procinfo_list->pid : -1); 6004} 6005 6006/* =================== GCORE .NOTE "MODULE" =================== */ 6007#if defined (UNIXWARE) || defined (PIOCOPENLWP) || defined (PCAGENT) 6008/* gcore only implemented on solaris and unixware (so far) */ 6009 6010static char * 6011procfs_do_thread_registers (bfd *obfd, ptid_t ptid, 6012 char *note_data, int *note_size) 6013{ 6014 struct regcache *regcache = get_thread_regcache (ptid); 6015 gdb_gregset_t gregs; 6016 gdb_fpregset_t fpregs; 6017 unsigned long merged_pid; 6018 6019 merged_pid = TIDGET (ptid) << 16 | PIDGET (ptid); 6020 6021 fill_gregset (regcache, &gregs, -1); 6022#if defined (UNIXWARE) 6023 note_data = (char *) elfcore_write_lwpstatus (obfd, 6024 note_data, 6025 note_size, 6026 merged_pid, 6027 stop_signal, 6028 &gregs); 6029#else 6030 note_data = (char *) elfcore_write_prstatus (obfd, 6031 note_data, 6032 note_size, 6033 merged_pid, 6034 stop_signal, 6035 &gregs); 6036#endif 6037 fill_fpregset (regcache, &fpregs, -1); 6038 note_data = (char *) elfcore_write_prfpreg (obfd, 6039 note_data, 6040 note_size, 6041 &fpregs, 6042 sizeof (fpregs)); 6043 return note_data; 6044} 6045 6046struct procfs_corefile_thread_data { 6047 bfd *obfd; 6048 char *note_data; 6049 int *note_size; 6050}; 6051 6052static int 6053procfs_corefile_thread_callback (procinfo *pi, procinfo *thread, void *data) 6054{ 6055 struct procfs_corefile_thread_data *args = data; 6056 6057 if (pi != NULL && thread->tid != 0) 6058 { 6059 ptid_t saved_ptid = inferior_ptid; 6060 inferior_ptid = MERGEPID (pi->pid, thread->tid); 6061 args->note_data = procfs_do_thread_registers (args->obfd, inferior_ptid, 6062 args->note_data, 6063 args->note_size); 6064 inferior_ptid = saved_ptid; 6065 } 6066 return 0; 6067} 6068 6069static char * 6070procfs_make_note_section (bfd *obfd, int *note_size) 6071{ 6072 struct cleanup *old_chain; 6073 gdb_gregset_t gregs; 6074 gdb_fpregset_t fpregs; 6075 char fname[16] = {'\0'}; 6076 char psargs[80] = {'\0'}; 6077 procinfo *pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); 6078 char *note_data = NULL; 6079 char *inf_args; 6080 struct procfs_corefile_thread_data thread_args; 6081 char *auxv; 6082 int auxv_len; 6083 6084 if (get_exec_file (0)) 6085 { 6086 strncpy (fname, strrchr (get_exec_file (0), '/') + 1, sizeof (fname)); 6087 strncpy (psargs, get_exec_file (0), 6088 sizeof (psargs)); 6089 6090 inf_args = get_inferior_args (); 6091 if (inf_args && *inf_args && 6092 strlen (inf_args) < ((int) sizeof (psargs) - (int) strlen (psargs))) 6093 { 6094 strncat (psargs, " ", 6095 sizeof (psargs) - strlen (psargs)); 6096 strncat (psargs, inf_args, 6097 sizeof (psargs) - strlen (psargs)); 6098 } 6099 } 6100 6101 note_data = (char *) elfcore_write_prpsinfo (obfd, 6102 note_data, 6103 note_size, 6104 fname, 6105 psargs); 6106 6107#ifdef UNIXWARE 6108 fill_gregset (get_current_regcache (), &gregs, -1); 6109 note_data = elfcore_write_pstatus (obfd, note_data, note_size, 6110 PIDGET (inferior_ptid), 6111 stop_signal, &gregs); 6112#endif 6113 6114 thread_args.obfd = obfd; 6115 thread_args.note_data = note_data; 6116 thread_args.note_size = note_size; 6117 proc_iterate_over_threads (pi, procfs_corefile_thread_callback, &thread_args); 6118 6119 if (thread_args.note_data == note_data) 6120 { 6121 /* iterate_over_threads didn't come up with any threads; 6122 just use inferior_ptid. */ 6123 note_data = procfs_do_thread_registers (obfd, inferior_ptid, 6124 note_data, note_size); 6125 } 6126 else 6127 { 6128 note_data = thread_args.note_data; 6129 } 6130 6131 auxv_len = target_read_alloc (¤t_target, TARGET_OBJECT_AUXV, 6132 NULL, &auxv); 6133 if (auxv_len > 0) 6134 { 6135 note_data = elfcore_write_note (obfd, note_data, note_size, 6136 "CORE", NT_AUXV, auxv, auxv_len); 6137 xfree (auxv); 6138 } 6139 6140 make_cleanup (xfree, note_data); 6141 return note_data; 6142} 6143#else /* !(Solaris or Unixware) */ 6144static char * 6145procfs_make_note_section (bfd *obfd, int *note_size) 6146{ 6147 error (_("gcore not implemented for this host.")); 6148 return NULL; /* lint */ 6149} 6150#endif /* Solaris or Unixware */ 6151/* =================== END GCORE .NOTE "MODULE" =================== */ 6152