1 /* Machine independent support for SVR4 /proc (process file system) for GDB. 2 3 Copyright 1999, 2000, 2001, 2002, 2003 Free Software Foundation, 4 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 2 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, write to the Free Software Foundation, 23 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 24 25 #include "defs.h" 26 #include "inferior.h" 27 #include "target.h" 28 #include "gdbcore.h" 29 #include "elf-bfd.h" /* for elfcore_write_* */ 30 #include "gdbcmd.h" 31 #include "gdbthread.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 114 static void procfs_open (char *, int); 115 static void procfs_attach (char *, int); 116 static void procfs_detach (char *, int); 117 static void procfs_resume (ptid_t, int, enum target_signal); 118 static int procfs_can_run (void); 119 static void procfs_stop (void); 120 static void procfs_files_info (struct target_ops *); 121 static void procfs_fetch_registers (int); 122 static void procfs_store_registers (int); 123 static void procfs_notice_signals (ptid_t); 124 static void procfs_prepare_to_store (void); 125 static void procfs_kill_inferior (void); 126 static void procfs_mourn_inferior (void); 127 static void procfs_create_inferior (char *, char *, char **, int); 128 static ptid_t procfs_wait (ptid_t, struct target_waitstatus *); 129 static int procfs_xfer_memory (CORE_ADDR, char *, int, int, 130 struct mem_attrib *attrib, 131 struct target_ops *); 132 static 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 138 static int procfs_thread_alive (ptid_t); 139 140 void procfs_find_new_threads (void); 141 char *procfs_pid_to_str (ptid_t); 142 143 static int proc_find_memory_regions (int (*) (CORE_ADDR, 144 unsigned long, 145 int, int, int, 146 void *), 147 void *); 148 149 static char * procfs_make_note_section (bfd *, int *); 150 151 static int procfs_can_use_hw_breakpoint (int, int, int); 152 153 struct target_ops procfs_ops; /* the target vector */ 154 155 static void 156 init_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 233 typedef pr_sigset_t gdb_sigset_t; 234 #else 235 typedef sigset_t gdb_sigset_t; 236 #endif 237 238 /* sigaction */ 239 #ifdef HAVE_PR_SIGACTION64_T 240 typedef pr_sigaction64_t gdb_sigaction_t; 241 #else 242 typedef struct sigaction gdb_sigaction_t; 243 #endif 244 245 /* siginfo */ 246 #ifdef HAVE_PR_SIGINFO64_T 247 typedef pr_siginfo64_t gdb_siginfo_t; 248 #else 249 typedef 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 */ 329 typedef pstatus_t gdb_prstatus_t; 330 typedef 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 */ 342 typedef prstatus_t gdb_prstatus_t; 343 typedef prstatus_t gdb_lwpstatus_t; 344 #endif /* NEW_PROC_API */ 345 346 typedef 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 397 static char errmsg[128]; /* shared error msg buffer */ 398 399 /* Function prototypes for procinfo module: */ 400 401 static procinfo *find_procinfo_or_die (int pid, int tid); 402 static procinfo *find_procinfo (int pid, int tid); 403 static procinfo *create_procinfo (int pid, int tid); 404 static void destroy_procinfo (procinfo * p); 405 static void do_destroy_procinfo_cleanup (void *); 406 static void dead_procinfo (procinfo * p, char *msg, int killp); 407 static int open_procinfo_files (procinfo * p, int which); 408 static void close_procinfo_files (procinfo * p); 409 static int sysset_t_size (procinfo *p); 410 static sysset_t *sysset_t_alloc (procinfo * pi); 411 #ifdef DYNAMIC_SYSCALLS 412 static void load_syscalls (procinfo *pi); 413 static void free_syscalls (procinfo *pi); 414 static int find_syscall (procinfo *pi, char *name); 415 #endif /* DYNAMIC_SYSCALLS */ 416 417 /* The head of the procinfo list: */ 418 static 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 428 static procinfo * 429 find_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 461 static procinfo * 462 find_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 488 static int 489 open_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 524 enum { FD_CTL, FD_STATUS, FD_AS }; 525 526 static int 527 open_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 682 static procinfo * 683 create_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 734 static void 735 close_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 754 static void 755 destroy_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 782 static void 783 destroy_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 802 static void 803 do_destroy_procinfo_cleanup (void *pi) 804 { 805 destroy_procinfo (pi); 806 } 807 808 enum { 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 818 static void 819 dead_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 847 static int 848 sysset_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 863 static sysset_t * 864 sysset_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 888 static void 889 load_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 989 static void 990 free_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 1010 static int 1011 find_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 1039 int proc_get_status (procinfo * pi); 1040 long proc_flags (procinfo * pi); 1041 int proc_why (procinfo * pi); 1042 int proc_what (procinfo * pi); 1043 int proc_set_run_on_last_close (procinfo * pi); 1044 int proc_unset_run_on_last_close (procinfo * pi); 1045 int proc_set_inherit_on_fork (procinfo * pi); 1046 int proc_unset_inherit_on_fork (procinfo * pi); 1047 int proc_set_async (procinfo * pi); 1048 int proc_unset_async (procinfo * pi); 1049 int proc_stop_process (procinfo * pi); 1050 int proc_trace_signal (procinfo * pi, int signo); 1051 int proc_ignore_signal (procinfo * pi, int signo); 1052 int proc_clear_current_fault (procinfo * pi); 1053 int proc_set_current_signal (procinfo * pi, int signo); 1054 int proc_clear_current_signal (procinfo * pi); 1055 int proc_set_gregs (procinfo * pi); 1056 int proc_set_fpregs (procinfo * pi); 1057 int proc_wait_for_stop (procinfo * pi); 1058 int proc_run_process (procinfo * pi, int step, int signo); 1059 int proc_kill (procinfo * pi, int signo); 1060 int proc_parent_pid (procinfo * pi); 1061 int proc_get_nthreads (procinfo * pi); 1062 int proc_get_current_thread (procinfo * pi); 1063 int proc_set_held_signals (procinfo * pi, gdb_sigset_t * sighold); 1064 int proc_set_traced_sysexit (procinfo * pi, sysset_t * sysset); 1065 int proc_set_traced_sysentry (procinfo * pi, sysset_t * sysset); 1066 int proc_set_traced_faults (procinfo * pi, fltset_t * fltset); 1067 int proc_set_traced_signals (procinfo * pi, gdb_sigset_t * sigset); 1068 1069 int proc_update_threads (procinfo * pi); 1070 int proc_iterate_over_threads (procinfo * pi, 1071 int (*func) (procinfo *, procinfo *, void *), 1072 void *ptr); 1073 1074 gdb_gregset_t *proc_get_gregs (procinfo * pi); 1075 gdb_fpregset_t *proc_get_fpregs (procinfo * pi); 1076 sysset_t *proc_get_traced_sysexit (procinfo * pi, sysset_t * save); 1077 sysset_t *proc_get_traced_sysentry (procinfo * pi, sysset_t * save); 1078 fltset_t *proc_get_traced_faults (procinfo * pi, fltset_t * save); 1079 gdb_sigset_t *proc_get_traced_signals (procinfo * pi, gdb_sigset_t * save); 1080 gdb_sigset_t *proc_get_held_signals (procinfo * pi, gdb_sigset_t * save); 1081 gdb_sigset_t *proc_get_pending_signals (procinfo * pi, gdb_sigset_t * save); 1082 gdb_sigaction_t *proc_get_signal_actions (procinfo * pi, gdb_sigaction_t *save); 1083 1084 void proc_warn (procinfo * pi, char *func, int line); 1085 void proc_error (procinfo * pi, char *func, int line); 1086 1087 void 1088 proc_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 1094 void 1095 proc_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 1113 int 1114 proc_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 1211 long 1212 proc_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 1238 int 1239 proc_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 1258 int 1259 proc_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 1279 int 1280 proc_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 1299 long * 1300 proc_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 1319 int 1320 proc_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 1340 long 1341 proc_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 1387 enum { FLAG_RESET, FLAG_SET }; 1388 1389 static int 1390 proc_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 1499 int 1500 proc_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 1515 int 1516 proc_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 1532 int 1533 proc_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 1548 int 1549 proc_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 1565 int 1566 proc_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 1581 int 1582 proc_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 1598 int 1599 proc_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 1614 int 1615 proc_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 1628 int 1629 proc_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 1670 int 1671 proc_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 1734 int 1735 proc_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 1787 int 1788 proc_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 1833 int 1834 proc_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 1877 int 1878 proc_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 1927 int 1928 proc_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 1977 int 1978 proc_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 2020 gdb_sigset_t * 2021 proc_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 2057 gdb_sigaction_t * 2058 proc_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 2094 gdb_sigset_t * 2095 proc_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 2140 gdb_sigset_t * 2141 proc_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 2182 int 2183 proc_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 2216 int 2217 proc_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 2250 fltset_t * 2251 proc_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 2292 sysset_t * 2293 proc_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 2365 sysset_t * 2366 proc_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 2438 int 2439 proc_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 2478 int 2479 proc_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 2534 int 2535 proc_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 /* 2577 * Function: proc_get_gregs 2578 * 2579 * Get the general registers for the process or LWP. 2580 * Returns non-zero for success, zero for failure. 2581 */ 2582 2583 gdb_gregset_t * 2584 proc_get_gregs (procinfo *pi) 2585 { 2586 if (!pi->status_valid || !pi->gregs_valid) 2587 if (!proc_get_status (pi)) 2588 return NULL; 2589 2590 /* 2591 * OK, sorry about the ifdef's. 2592 * There's three cases instead of two, because 2593 * in this instance Unixware and Solaris/RW differ. 2594 */ 2595 2596 #ifdef NEW_PROC_API 2597 #ifdef UNIXWARE /* ugh, a true architecture dependency */ 2598 return &pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs; 2599 #else /* not Unixware */ 2600 return &pi->prstatus.pr_lwp.pr_reg; 2601 #endif /* Unixware */ 2602 #else /* not NEW_PROC_API */ 2603 return &pi->prstatus.pr_reg; 2604 #endif /* NEW_PROC_API */ 2605 } 2606 2607 /* 2608 * Function: proc_get_fpregs 2609 * 2610 * Get the floating point registers for the process or LWP. 2611 * Returns non-zero for success, zero for failure. 2612 */ 2613 2614 gdb_fpregset_t * 2615 proc_get_fpregs (procinfo *pi) 2616 { 2617 #ifdef NEW_PROC_API 2618 if (!pi->status_valid || !pi->fpregs_valid) 2619 if (!proc_get_status (pi)) 2620 return NULL; 2621 2622 #ifdef UNIXWARE /* a true architecture dependency */ 2623 return &pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs; 2624 #else 2625 return &pi->prstatus.pr_lwp.pr_fpreg; 2626 #endif /* Unixware */ 2627 2628 #else /* not NEW_PROC_API */ 2629 if (pi->fpregs_valid) 2630 return &pi->fpregset; /* already got 'em */ 2631 else 2632 { 2633 if (pi->ctl_fd == 0 && 2634 open_procinfo_files (pi, FD_CTL) == 0) 2635 { 2636 return NULL; 2637 } 2638 else 2639 { 2640 #ifdef PIOCTGFPREG 2641 struct { 2642 long pr_count; 2643 tid_t pr_error_thread; 2644 tfpregset_t thread_1; 2645 } thread_fpregs; 2646 2647 thread_fpregs.pr_count = 1; 2648 thread_fpregs.thread_1.tid = pi->tid; 2649 2650 if (pi->tid == 0 && 2651 ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset) >= 0) 2652 { 2653 pi->fpregs_valid = 1; 2654 return &pi->fpregset; /* got 'em now! */ 2655 } 2656 else if (pi->tid != 0 && 2657 ioctl (pi->ctl_fd, PIOCTGFPREG, &thread_fpregs) >= 0) 2658 { 2659 memcpy (&pi->fpregset, &thread_fpregs.thread_1.pr_fpregs, 2660 sizeof (pi->fpregset)); 2661 pi->fpregs_valid = 1; 2662 return &pi->fpregset; /* got 'em now! */ 2663 } 2664 else 2665 { 2666 return NULL; 2667 } 2668 #else 2669 if (ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset) >= 0) 2670 { 2671 pi->fpregs_valid = 1; 2672 return &pi->fpregset; /* got 'em now! */ 2673 } 2674 else 2675 { 2676 return NULL; 2677 } 2678 #endif 2679 } 2680 } 2681 #endif 2682 } 2683 2684 /* 2685 * Function: proc_set_gregs 2686 * 2687 * Write the general registers back to the process or LWP. 2688 * Returns non-zero for success, zero for failure. 2689 */ 2690 2691 int 2692 proc_set_gregs (procinfo *pi) 2693 { 2694 gdb_gregset_t *gregs; 2695 int win; 2696 2697 if ((gregs = proc_get_gregs (pi)) == NULL) 2698 return 0; /* get_regs has already warned */ 2699 2700 if (pi->ctl_fd == 0 && 2701 open_procinfo_files (pi, FD_CTL) == 0) 2702 { 2703 return 0; 2704 } 2705 else 2706 { 2707 #ifdef NEW_PROC_API 2708 struct { 2709 procfs_ctl_t cmd; 2710 /* Use char array to avoid alignment issues. */ 2711 char gregs[sizeof (gdb_gregset_t)]; 2712 } arg; 2713 2714 arg.cmd = PCSREG; 2715 memcpy (&arg.gregs, gregs, sizeof (arg.gregs)); 2716 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg)); 2717 #else 2718 win = (ioctl (pi->ctl_fd, PIOCSREG, gregs) >= 0); 2719 #endif 2720 } 2721 2722 /* Policy: writing the regs invalidates our cache. */ 2723 pi->gregs_valid = 0; 2724 return win; 2725 } 2726 2727 /* 2728 * Function: proc_set_fpregs 2729 * 2730 * Modify the floating point register set of the process or LWP. 2731 * Returns non-zero for success, zero for failure. 2732 */ 2733 2734 int 2735 proc_set_fpregs (procinfo *pi) 2736 { 2737 gdb_fpregset_t *fpregs; 2738 int win; 2739 2740 if ((fpregs = proc_get_fpregs (pi)) == NULL) 2741 return 0; /* get_fpregs has already warned */ 2742 2743 if (pi->ctl_fd == 0 && 2744 open_procinfo_files (pi, FD_CTL) == 0) 2745 { 2746 return 0; 2747 } 2748 else 2749 { 2750 #ifdef NEW_PROC_API 2751 struct { 2752 procfs_ctl_t cmd; 2753 /* Use char array to avoid alignment issues. */ 2754 char fpregs[sizeof (gdb_fpregset_t)]; 2755 } arg; 2756 2757 arg.cmd = PCSFPREG; 2758 memcpy (&arg.fpregs, fpregs, sizeof (arg.fpregs)); 2759 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg)); 2760 #else 2761 #ifdef PIOCTSFPREG 2762 if (pi->tid == 0) 2763 win = (ioctl (pi->ctl_fd, PIOCSFPREG, fpregs) >= 0); 2764 else 2765 { 2766 struct { 2767 long pr_count; 2768 tid_t pr_error_thread; 2769 tfpregset_t thread_1; 2770 } thread_fpregs; 2771 2772 thread_fpregs.pr_count = 1; 2773 thread_fpregs.thread_1.tid = pi->tid; 2774 memcpy (&thread_fpregs.thread_1.pr_fpregs, fpregs, 2775 sizeof (*fpregs)); 2776 win = (ioctl (pi->ctl_fd, PIOCTSFPREG, &thread_fpregs) >= 0); 2777 } 2778 #else 2779 win = (ioctl (pi->ctl_fd, PIOCSFPREG, fpregs) >= 0); 2780 #endif /* osf PIOCTSFPREG */ 2781 #endif /* NEW_PROC_API */ 2782 } 2783 2784 /* Policy: writing the regs invalidates our cache. */ 2785 pi->fpregs_valid = 0; 2786 return win; 2787 } 2788 2789 /* 2790 * Function: proc_kill 2791 * 2792 * Send a signal to the proc or lwp with the semantics of "kill()". 2793 * Returns non-zero for success, zero for failure. 2794 */ 2795 2796 int 2797 proc_kill (procinfo *pi, int signo) 2798 { 2799 int win; 2800 2801 /* 2802 * We might conceivably apply this operation to an LWP, and 2803 * the LWP's ctl file descriptor might not be open. 2804 */ 2805 2806 if (pi->ctl_fd == 0 && 2807 open_procinfo_files (pi, FD_CTL) == 0) 2808 { 2809 return 0; 2810 } 2811 else 2812 { 2813 #ifdef NEW_PROC_API 2814 procfs_ctl_t cmd[2]; 2815 2816 cmd[0] = PCKILL; 2817 cmd[1] = signo; 2818 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd)); 2819 #else /* ioctl method */ 2820 /* FIXME: do I need the Alpha OSF fixups present in 2821 procfs.c/unconditionally_kill_inferior? Perhaps only for SIGKILL? */ 2822 win = (ioctl (pi->ctl_fd, PIOCKILL, &signo) >= 0); 2823 #endif 2824 } 2825 2826 return win; 2827 } 2828 2829 /* 2830 * Function: proc_parent_pid 2831 * 2832 * Find the pid of the process that started this one. 2833 * Returns the parent process pid, or zero. 2834 */ 2835 2836 int 2837 proc_parent_pid (procinfo *pi) 2838 { 2839 /* 2840 * We should never have to apply this operation to any procinfo 2841 * except the one for the main process. If that ever changes 2842 * for any reason, then take out the following clause and 2843 * replace it with one that makes sure the ctl_fd is open. 2844 */ 2845 2846 if (pi->tid != 0) 2847 pi = find_procinfo_or_die (pi->pid, 0); 2848 2849 if (!pi->status_valid) 2850 if (!proc_get_status (pi)) 2851 return 0; 2852 2853 return pi->prstatus.pr_ppid; 2854 } 2855 2856 2857 /* Convert a target address (a.k.a. CORE_ADDR) into a host address 2858 (a.k.a void pointer)! */ 2859 2860 static void * 2861 procfs_address_to_host_pointer (CORE_ADDR addr) 2862 { 2863 void *ptr; 2864 2865 gdb_assert (sizeof (ptr) == TYPE_LENGTH (builtin_type_void_data_ptr)); 2866 ADDRESS_TO_POINTER (builtin_type_void_data_ptr, &ptr, addr); 2867 return ptr; 2868 } 2869 2870 /* 2871 * Function: proc_set_watchpoint 2872 * 2873 */ 2874 2875 int 2876 proc_set_watchpoint (procinfo *pi, CORE_ADDR addr, int len, int wflags) 2877 { 2878 #if !defined (TARGET_HAS_HARDWARE_WATCHPOINTS) 2879 return 0; 2880 #else 2881 /* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5 */ 2882 #if defined (PIOCOPENLWP) || defined (UNIXWARE) /* Solaris 2.5: bail out */ 2883 return 0; 2884 #else 2885 struct { 2886 procfs_ctl_t cmd; 2887 char watch[sizeof (prwatch_t)]; 2888 } arg; 2889 prwatch_t *pwatch; 2890 2891 pwatch = (prwatch_t *) &arg.watch; 2892 /* NOTE: cagney/2003-02-01: Even more horrible hack. Need to 2893 convert a target address into something that can be stored in a 2894 native data structure. */ 2895 #ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */ 2896 pwatch->pr_vaddr = (uintptr_t) procfs_address_to_host_pointer (addr); 2897 #else 2898 pwatch->pr_vaddr = (caddr_t) procfs_address_to_host_pointer (addr); 2899 #endif 2900 pwatch->pr_size = len; 2901 pwatch->pr_wflags = wflags; 2902 #if defined(NEW_PROC_API) && defined (PCWATCH) 2903 arg.cmd = PCWATCH; 2904 return (write (pi->ctl_fd, &arg, sizeof (arg)) == sizeof (arg)); 2905 #else 2906 #if defined (PIOCSWATCH) 2907 return (ioctl (pi->ctl_fd, PIOCSWATCH, pwatch) >= 0); 2908 #else 2909 return 0; /* Fail */ 2910 #endif 2911 #endif 2912 #endif 2913 #endif 2914 } 2915 2916 #ifdef TM_I386SOL2_H /* Is it hokey to use this? */ 2917 2918 #include <sys/sysi86.h> 2919 2920 /* 2921 * Function: proc_get_LDT_entry 2922 * 2923 * Inputs: 2924 * procinfo *pi; 2925 * int key; 2926 * 2927 * The 'key' is actually the value of the lower 16 bits of 2928 * the GS register for the LWP that we're interested in. 2929 * 2930 * Return: matching ssh struct (LDT entry). 2931 */ 2932 2933 struct ssd * 2934 proc_get_LDT_entry (procinfo *pi, int key) 2935 { 2936 static struct ssd *ldt_entry = NULL; 2937 #ifdef NEW_PROC_API 2938 char pathname[MAX_PROC_NAME_SIZE]; 2939 struct cleanup *old_chain = NULL; 2940 int fd; 2941 2942 /* Allocate space for one LDT entry. 2943 This alloc must persist, because we return a pointer to it. */ 2944 if (ldt_entry == NULL) 2945 ldt_entry = (struct ssd *) xmalloc (sizeof (struct ssd)); 2946 2947 /* Open the file descriptor for the LDT table. */ 2948 sprintf (pathname, "/proc/%d/ldt", pi->pid); 2949 if ((fd = open_with_retry (pathname, O_RDONLY)) < 0) 2950 { 2951 proc_warn (pi, "proc_get_LDT_entry (open)", __LINE__); 2952 return NULL; 2953 } 2954 /* Make sure it gets closed again! */ 2955 old_chain = make_cleanup_close (fd); 2956 2957 /* Now 'read' thru the table, find a match and return it. */ 2958 while (read (fd, ldt_entry, sizeof (struct ssd)) == sizeof (struct ssd)) 2959 { 2960 if (ldt_entry->sel == 0 && 2961 ldt_entry->bo == 0 && 2962 ldt_entry->acc1 == 0 && 2963 ldt_entry->acc2 == 0) 2964 break; /* end of table */ 2965 /* If key matches, return this entry. */ 2966 if (ldt_entry->sel == key) 2967 return ldt_entry; 2968 } 2969 /* Loop ended, match not found. */ 2970 return NULL; 2971 #else 2972 int nldt, i; 2973 static int nalloc = 0; 2974 2975 /* Get the number of LDT entries. */ 2976 if (ioctl (pi->ctl_fd, PIOCNLDT, &nldt) < 0) 2977 { 2978 proc_warn (pi, "proc_get_LDT_entry (PIOCNLDT)", __LINE__); 2979 return NULL; 2980 } 2981 2982 /* Allocate space for the number of LDT entries. */ 2983 /* This alloc has to persist, 'cause we return a pointer to it. */ 2984 if (nldt > nalloc) 2985 { 2986 ldt_entry = (struct ssd *) 2987 xrealloc (ldt_entry, (nldt + 1) * sizeof (struct ssd)); 2988 nalloc = nldt; 2989 } 2990 2991 /* Read the whole table in one gulp. */ 2992 if (ioctl (pi->ctl_fd, PIOCLDT, ldt_entry) < 0) 2993 { 2994 proc_warn (pi, "proc_get_LDT_entry (PIOCLDT)", __LINE__); 2995 return NULL; 2996 } 2997 2998 /* Search the table and return the (first) entry matching 'key'. */ 2999 for (i = 0; i < nldt; i++) 3000 if (ldt_entry[i].sel == key) 3001 return &ldt_entry[i]; 3002 3003 /* Loop ended, match not found. */ 3004 return NULL; 3005 #endif 3006 } 3007 3008 #endif /* TM_I386SOL2_H */ 3009 3010 /* =============== END, non-thread part of /proc "MODULE" =============== */ 3011 3012 /* =================== Thread "MODULE" =================== */ 3013 3014 /* NOTE: you'll see more ifdefs and duplication of functions here, 3015 since there is a different way to do threads on every OS. */ 3016 3017 /* 3018 * Function: proc_get_nthreads 3019 * 3020 * Return the number of threads for the process 3021 */ 3022 3023 #if defined (PIOCNTHR) && defined (PIOCTLIST) 3024 /* 3025 * OSF version 3026 */ 3027 int 3028 proc_get_nthreads (procinfo *pi) 3029 { 3030 int nthreads = 0; 3031 3032 if (ioctl (pi->ctl_fd, PIOCNTHR, &nthreads) < 0) 3033 proc_warn (pi, "procfs: PIOCNTHR failed", __LINE__); 3034 3035 return nthreads; 3036 } 3037 3038 #else 3039 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */ 3040 /* 3041 * Solaris and Unixware version 3042 */ 3043 int 3044 proc_get_nthreads (procinfo *pi) 3045 { 3046 if (!pi->status_valid) 3047 if (!proc_get_status (pi)) 3048 return 0; 3049 3050 /* 3051 * NEW_PROC_API: only works for the process procinfo, 3052 * because the LWP procinfos do not get prstatus filled in. 3053 */ 3054 #ifdef NEW_PROC_API 3055 if (pi->tid != 0) /* find the parent process procinfo */ 3056 pi = find_procinfo_or_die (pi->pid, 0); 3057 #endif 3058 return pi->prstatus.pr_nlwp; 3059 } 3060 3061 #else 3062 /* 3063 * Default version 3064 */ 3065 int 3066 proc_get_nthreads (procinfo *pi) 3067 { 3068 return 0; 3069 } 3070 #endif 3071 #endif 3072 3073 /* 3074 * Function: proc_get_current_thread (LWP version) 3075 * 3076 * Return the ID of the thread that had an event of interest. 3077 * (ie. the one that hit a breakpoint or other traced event). 3078 * All other things being equal, this should be the ID of a 3079 * thread that is currently executing. 3080 */ 3081 3082 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */ 3083 /* 3084 * Solaris and Unixware version 3085 */ 3086 int 3087 proc_get_current_thread (procinfo *pi) 3088 { 3089 /* 3090 * Note: this should be applied to the root procinfo for the process, 3091 * not to the procinfo for an LWP. If applied to the procinfo for 3092 * an LWP, it will simply return that LWP's ID. In that case, 3093 * find the parent process procinfo. 3094 */ 3095 3096 if (pi->tid != 0) 3097 pi = find_procinfo_or_die (pi->pid, 0); 3098 3099 if (!pi->status_valid) 3100 if (!proc_get_status (pi)) 3101 return 0; 3102 3103 #ifdef NEW_PROC_API 3104 return pi->prstatus.pr_lwp.pr_lwpid; 3105 #else 3106 return pi->prstatus.pr_who; 3107 #endif 3108 } 3109 3110 #else 3111 #if defined (PIOCNTHR) && defined (PIOCTLIST) 3112 /* 3113 * OSF version 3114 */ 3115 int 3116 proc_get_current_thread (procinfo *pi) 3117 { 3118 #if 0 /* FIXME: not ready for prime time? */ 3119 return pi->prstatus.pr_tid; 3120 #else 3121 return 0; 3122 #endif 3123 } 3124 3125 #else 3126 /* 3127 * Default version 3128 */ 3129 int 3130 proc_get_current_thread (procinfo *pi) 3131 { 3132 return 0; 3133 } 3134 3135 #endif 3136 #endif 3137 3138 /* 3139 * Function: proc_update_threads 3140 * 3141 * Discover the IDs of all the threads within the process, and 3142 * create a procinfo for each of them (chained to the parent). 3143 * 3144 * This unfortunately requires a different method on every OS. 3145 * 3146 * Return: non-zero for success, zero for failure. 3147 */ 3148 3149 int 3150 proc_delete_dead_threads (procinfo *parent, procinfo *thread, void *ignore) 3151 { 3152 if (thread && parent) /* sanity */ 3153 { 3154 thread->status_valid = 0; 3155 if (!proc_get_status (thread)) 3156 destroy_one_procinfo (&parent->thread_list, thread); 3157 } 3158 return 0; /* keep iterating */ 3159 } 3160 3161 #if defined (PIOCLSTATUS) 3162 /* 3163 * Solaris 2.5 (ioctl) version 3164 */ 3165 int 3166 proc_update_threads (procinfo *pi) 3167 { 3168 gdb_prstatus_t *prstatus; 3169 struct cleanup *old_chain = NULL; 3170 procinfo *thread; 3171 int nlwp, i; 3172 3173 /* 3174 * We should never have to apply this operation to any procinfo 3175 * except the one for the main process. If that ever changes 3176 * for any reason, then take out the following clause and 3177 * replace it with one that makes sure the ctl_fd is open. 3178 */ 3179 3180 if (pi->tid != 0) 3181 pi = find_procinfo_or_die (pi->pid, 0); 3182 3183 proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL); 3184 3185 if ((nlwp = proc_get_nthreads (pi)) <= 1) 3186 return 1; /* Process is not multi-threaded; nothing to do. */ 3187 3188 prstatus = xmalloc (sizeof (gdb_prstatus_t) * (nlwp + 1)); 3189 3190 old_chain = make_cleanup (xfree, prstatus); 3191 if (ioctl (pi->ctl_fd, PIOCLSTATUS, prstatus) < 0) 3192 proc_error (pi, "update_threads (PIOCLSTATUS)", __LINE__); 3193 3194 /* Skip element zero, which represents the process as a whole. */ 3195 for (i = 1; i < nlwp + 1; i++) 3196 { 3197 if ((thread = create_procinfo (pi->pid, prstatus[i].pr_who)) == NULL) 3198 proc_error (pi, "update_threads, create_procinfo", __LINE__); 3199 3200 memcpy (&thread->prstatus, &prstatus[i], sizeof (*prstatus)); 3201 thread->status_valid = 1; 3202 } 3203 pi->threads_valid = 1; 3204 do_cleanups (old_chain); 3205 return 1; 3206 } 3207 #else 3208 #ifdef NEW_PROC_API 3209 /* 3210 * Unixware and Solaris 6 (and later) version 3211 */ 3212 static void 3213 do_closedir_cleanup (void *dir) 3214 { 3215 closedir (dir); 3216 } 3217 3218 int 3219 proc_update_threads (procinfo *pi) 3220 { 3221 char pathname[MAX_PROC_NAME_SIZE + 16]; 3222 struct dirent *direntry; 3223 struct cleanup *old_chain = NULL; 3224 procinfo *thread; 3225 DIR *dirp; 3226 int lwpid; 3227 3228 /* 3229 * We should never have to apply this operation to any procinfo 3230 * except the one for the main process. If that ever changes 3231 * for any reason, then take out the following clause and 3232 * replace it with one that makes sure the ctl_fd is open. 3233 */ 3234 3235 if (pi->tid != 0) 3236 pi = find_procinfo_or_die (pi->pid, 0); 3237 3238 proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL); 3239 3240 /* 3241 * Unixware 3242 * 3243 * Note: this brute-force method is the only way I know of 3244 * to accomplish this task on Unixware. This method will 3245 * also work on Solaris 2.6 and 2.7. There is a much simpler 3246 * and more elegant way to do this on Solaris, but the margins 3247 * of this manuscript are too small to write it here... ;-) 3248 */ 3249 3250 strcpy (pathname, pi->pathname); 3251 strcat (pathname, "/lwp"); 3252 if ((dirp = opendir (pathname)) == NULL) 3253 proc_error (pi, "update_threads, opendir", __LINE__); 3254 3255 old_chain = make_cleanup (do_closedir_cleanup, dirp); 3256 while ((direntry = readdir (dirp)) != NULL) 3257 if (direntry->d_name[0] != '.') /* skip '.' and '..' */ 3258 { 3259 lwpid = atoi (&direntry->d_name[0]); 3260 if ((thread = create_procinfo (pi->pid, lwpid)) == NULL) 3261 proc_error (pi, "update_threads, create_procinfo", __LINE__); 3262 } 3263 pi->threads_valid = 1; 3264 do_cleanups (old_chain); 3265 return 1; 3266 } 3267 #else 3268 #ifdef PIOCTLIST 3269 /* 3270 * OSF version 3271 */ 3272 int 3273 proc_update_threads (procinfo *pi) 3274 { 3275 int nthreads, i; 3276 tid_t *threads; 3277 3278 /* 3279 * We should never have to apply this operation to any procinfo 3280 * except the one for the main process. If that ever changes 3281 * for any reason, then take out the following clause and 3282 * replace it with one that makes sure the ctl_fd is open. 3283 */ 3284 3285 if (pi->tid != 0) 3286 pi = find_procinfo_or_die (pi->pid, 0); 3287 3288 proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL); 3289 3290 nthreads = proc_get_nthreads (pi); 3291 if (nthreads < 2) 3292 return 0; /* nothing to do for 1 or fewer threads */ 3293 3294 threads = xmalloc (nthreads * sizeof (tid_t)); 3295 3296 if (ioctl (pi->ctl_fd, PIOCTLIST, threads) < 0) 3297 proc_error (pi, "procfs: update_threads (PIOCTLIST)", __LINE__); 3298 3299 for (i = 0; i < nthreads; i++) 3300 { 3301 if (!find_procinfo (pi->pid, threads[i])) 3302 if (!create_procinfo (pi->pid, threads[i])) 3303 proc_error (pi, "update_threads, create_procinfo", __LINE__); 3304 } 3305 pi->threads_valid = 1; 3306 return 1; 3307 } 3308 #else 3309 /* 3310 * Default version 3311 */ 3312 int 3313 proc_update_threads (procinfo *pi) 3314 { 3315 return 0; 3316 } 3317 #endif /* OSF PIOCTLIST */ 3318 #endif /* NEW_PROC_API */ 3319 #endif /* SOL 2.5 PIOCLSTATUS */ 3320 3321 /* 3322 * Function: proc_iterate_over_threads 3323 * 3324 * Description: 3325 * Given a pointer to a function, call that function once 3326 * for each lwp in the procinfo list, until the function 3327 * returns non-zero, in which event return the value 3328 * returned by the function. 3329 * 3330 * Note: this function does NOT call update_threads. 3331 * If you want to discover new threads first, you must 3332 * call that function explicitly. This function just makes 3333 * a quick pass over the currently-known procinfos. 3334 * 3335 * Arguments: 3336 * pi - parent process procinfo 3337 * func - per-thread function 3338 * ptr - opaque parameter for function. 3339 * 3340 * Return: 3341 * First non-zero return value from the callee, or zero. 3342 */ 3343 3344 int 3345 proc_iterate_over_threads (procinfo *pi, 3346 int (*func) (procinfo *, procinfo *, void *), 3347 void *ptr) 3348 { 3349 procinfo *thread, *next; 3350 int retval = 0; 3351 3352 /* 3353 * We should never have to apply this operation to any procinfo 3354 * except the one for the main process. If that ever changes 3355 * for any reason, then take out the following clause and 3356 * replace it with one that makes sure the ctl_fd is open. 3357 */ 3358 3359 if (pi->tid != 0) 3360 pi = find_procinfo_or_die (pi->pid, 0); 3361 3362 for (thread = pi->thread_list; thread != NULL; thread = next) 3363 { 3364 next = thread->next; /* in case thread is destroyed */ 3365 if ((retval = (*func) (pi, thread, ptr)) != 0) 3366 break; 3367 } 3368 3369 return retval; 3370 } 3371 3372 /* =================== END, Thread "MODULE" =================== */ 3373 3374 /* =================== END, /proc "MODULE" =================== */ 3375 3376 /* =================== GDB "MODULE" =================== */ 3377 3378 /* 3379 * Here are all of the gdb target vector functions and their friends. 3380 */ 3381 3382 static ptid_t do_attach (ptid_t ptid); 3383 static void do_detach (int signo); 3384 static int register_gdb_signals (procinfo *, gdb_sigset_t *); 3385 static void proc_trace_syscalls_1 (procinfo *pi, int syscallnum, 3386 int entry_or_exit, int mode, int from_tty); 3387 static int insert_dbx_link_breakpoint (procinfo *pi); 3388 static void remove_dbx_link_breakpoint (void); 3389 3390 /* On mips-irix, we need to insert a breakpoint at __dbx_link during 3391 the startup phase. The following two variables are used to record 3392 the address of the breakpoint, and the code that was replaced by 3393 a breakpoint. */ 3394 static int dbx_link_bpt_addr = 0; 3395 static char dbx_link_shadow_contents[BREAKPOINT_MAX]; 3396 3397 /* 3398 * Function: procfs_debug_inferior 3399 * 3400 * Sets up the inferior to be debugged. 3401 * Registers to trace signals, hardware faults, and syscalls. 3402 * Note: does not set RLC flag: caller may want to customize that. 3403 * 3404 * Returns: zero for success (note! unlike most functions in this module) 3405 * On failure, returns the LINE NUMBER where it failed! 3406 */ 3407 3408 static int 3409 procfs_debug_inferior (procinfo *pi) 3410 { 3411 fltset_t traced_faults; 3412 gdb_sigset_t traced_signals; 3413 sysset_t *traced_syscall_entries; 3414 sysset_t *traced_syscall_exits; 3415 int status; 3416 3417 #ifdef PROCFS_DONT_TRACE_FAULTS 3418 /* On some systems (OSF), we don't trace hardware faults. 3419 Apparently it's enough that we catch them as signals. 3420 Wonder why we don't just do that in general? */ 3421 premptyset (&traced_faults); /* don't trace faults. */ 3422 #else 3423 /* Register to trace hardware faults in the child. */ 3424 prfillset (&traced_faults); /* trace all faults... */ 3425 prdelset (&traced_faults, FLTPAGE); /* except page fault. */ 3426 #endif 3427 if (!proc_set_traced_faults (pi, &traced_faults)) 3428 return __LINE__; 3429 3430 /* Register to trace selected signals in the child. */ 3431 premptyset (&traced_signals); 3432 if (!register_gdb_signals (pi, &traced_signals)) 3433 return __LINE__; 3434 3435 3436 /* Register to trace the 'exit' system call (on entry). */ 3437 traced_syscall_entries = sysset_t_alloc (pi); 3438 gdb_premptysysset (traced_syscall_entries); 3439 #ifdef SYS_exit 3440 gdb_praddsysset (traced_syscall_entries, SYS_exit); 3441 #endif 3442 #ifdef SYS_lwpexit 3443 gdb_praddsysset (traced_syscall_entries, SYS_lwpexit); /* And _lwp_exit... */ 3444 #endif 3445 #ifdef SYS_lwp_exit 3446 gdb_praddsysset (traced_syscall_entries, SYS_lwp_exit); 3447 #endif 3448 #ifdef DYNAMIC_SYSCALLS 3449 { 3450 int callnum = find_syscall (pi, "_exit"); 3451 if (callnum >= 0) 3452 gdb_praddsysset (traced_syscall_entries, callnum); 3453 } 3454 #endif 3455 3456 status = proc_set_traced_sysentry (pi, traced_syscall_entries); 3457 xfree (traced_syscall_entries); 3458 if (!status) 3459 return __LINE__; 3460 3461 #ifdef PRFS_STOPEXEC /* defined on OSF */ 3462 /* OSF method for tracing exec syscalls. Quoting: 3463 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace 3464 exits from exec system calls because of the user level loader. */ 3465 /* FIXME: make nice and maybe move into an access function. */ 3466 { 3467 int prfs_flags; 3468 3469 if (ioctl (pi->ctl_fd, PIOCGSPCACT, &prfs_flags) < 0) 3470 return __LINE__; 3471 3472 prfs_flags |= PRFS_STOPEXEC; 3473 3474 if (ioctl (pi->ctl_fd, PIOCSSPCACT, &prfs_flags) < 0) 3475 return __LINE__; 3476 } 3477 #else /* not PRFS_STOPEXEC */ 3478 /* Everyone else's (except OSF) method for tracing exec syscalls */ 3479 /* GW: Rationale... 3480 Not all systems with /proc have all the exec* syscalls with the same 3481 names. On the SGI, for example, there is no SYS_exec, but there 3482 *is* a SYS_execv. So, we try to account for that. */ 3483 3484 traced_syscall_exits = sysset_t_alloc (pi); 3485 gdb_premptysysset (traced_syscall_exits); 3486 #ifdef SYS_exec 3487 gdb_praddsysset (traced_syscall_exits, SYS_exec); 3488 #endif 3489 #ifdef SYS_execve 3490 gdb_praddsysset (traced_syscall_exits, SYS_execve); 3491 #endif 3492 #ifdef SYS_execv 3493 gdb_praddsysset (traced_syscall_exits, SYS_execv); 3494 #endif 3495 3496 #ifdef SYS_lwpcreate 3497 gdb_praddsysset (traced_syscall_exits, SYS_lwpcreate); 3498 gdb_praddsysset (traced_syscall_exits, SYS_lwpexit); 3499 #endif 3500 3501 #ifdef SYS_lwp_create /* FIXME: once only, please */ 3502 gdb_praddsysset (traced_syscall_exits, SYS_lwp_create); 3503 gdb_praddsysset (traced_syscall_exits, SYS_lwp_exit); 3504 #endif 3505 3506 #ifdef DYNAMIC_SYSCALLS 3507 { 3508 int callnum = find_syscall (pi, "execve"); 3509 if (callnum >= 0) 3510 gdb_praddsysset (traced_syscall_exits, callnum); 3511 callnum = find_syscall (pi, "ra_execve"); 3512 if (callnum >= 0) 3513 gdb_praddsysset (traced_syscall_exits, callnum); 3514 } 3515 #endif 3516 3517 status = proc_set_traced_sysexit (pi, traced_syscall_exits); 3518 xfree (traced_syscall_exits); 3519 if (!status) 3520 return __LINE__; 3521 3522 #endif /* PRFS_STOPEXEC */ 3523 return 0; 3524 } 3525 3526 static void 3527 procfs_attach (char *args, int from_tty) 3528 { 3529 char *exec_file; 3530 int pid; 3531 3532 if (!args) 3533 error_no_arg ("process-id to attach"); 3534 3535 pid = atoi (args); 3536 if (pid == getpid ()) 3537 error ("Attaching GDB to itself is not a good idea..."); 3538 3539 if (from_tty) 3540 { 3541 exec_file = get_exec_file (0); 3542 3543 if (exec_file) 3544 printf_filtered ("Attaching to program `%s', %s\n", 3545 exec_file, target_pid_to_str (pid_to_ptid (pid))); 3546 else 3547 printf_filtered ("Attaching to %s\n", 3548 target_pid_to_str (pid_to_ptid (pid))); 3549 3550 fflush (stdout); 3551 } 3552 inferior_ptid = do_attach (pid_to_ptid (pid)); 3553 push_target (&procfs_ops); 3554 } 3555 3556 static void 3557 procfs_detach (char *args, int from_tty) 3558 { 3559 int sig = 0; 3560 3561 if (args) 3562 sig = atoi (args); 3563 3564 if (from_tty) 3565 { 3566 int pid = PIDGET (inferior_ptid); 3567 char *exec_file; 3568 3569 exec_file = get_exec_file (0); 3570 if (exec_file == NULL) 3571 exec_file = ""; 3572 3573 printf_filtered ("Detaching from program: %s, %s\n", exec_file, 3574 target_pid_to_str (pid_to_ptid (pid))); 3575 gdb_flush (gdb_stdout); 3576 } 3577 3578 do_detach (sig); 3579 3580 inferior_ptid = null_ptid; 3581 unpush_target (&procfs_ops); 3582 } 3583 3584 static ptid_t 3585 do_attach (ptid_t ptid) 3586 { 3587 procinfo *pi; 3588 int fail; 3589 3590 if ((pi = create_procinfo (PIDGET (ptid), 0)) == NULL) 3591 perror ("procfs: out of memory in 'attach'"); 3592 3593 if (!open_procinfo_files (pi, FD_CTL)) 3594 { 3595 fprintf_filtered (gdb_stderr, "procfs:%d -- ", __LINE__); 3596 sprintf (errmsg, "do_attach: couldn't open /proc file for process %d", 3597 PIDGET (ptid)); 3598 dead_procinfo (pi, errmsg, NOKILL); 3599 } 3600 3601 /* Stop the process (if it isn't already stopped). */ 3602 if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) 3603 { 3604 pi->was_stopped = 1; 3605 proc_prettyprint_why (proc_why (pi), proc_what (pi), 1); 3606 } 3607 else 3608 { 3609 pi->was_stopped = 0; 3610 /* Set the process to run again when we close it. */ 3611 if (!proc_set_run_on_last_close (pi)) 3612 dead_procinfo (pi, "do_attach: couldn't set RLC.", NOKILL); 3613 3614 /* Now stop the process. */ 3615 if (!proc_stop_process (pi)) 3616 dead_procinfo (pi, "do_attach: couldn't stop the process.", NOKILL); 3617 pi->ignore_next_sigstop = 1; 3618 } 3619 /* Save some of the /proc state to be restored if we detach. */ 3620 if (!proc_get_traced_faults (pi, &pi->saved_fltset)) 3621 dead_procinfo (pi, "do_attach: couldn't save traced faults.", NOKILL); 3622 if (!proc_get_traced_signals (pi, &pi->saved_sigset)) 3623 dead_procinfo (pi, "do_attach: couldn't save traced signals.", NOKILL); 3624 if (!proc_get_traced_sysentry (pi, pi->saved_entryset)) 3625 dead_procinfo (pi, "do_attach: couldn't save traced syscall entries.", 3626 NOKILL); 3627 if (!proc_get_traced_sysexit (pi, pi->saved_exitset)) 3628 dead_procinfo (pi, "do_attach: couldn't save traced syscall exits.", 3629 NOKILL); 3630 if (!proc_get_held_signals (pi, &pi->saved_sighold)) 3631 dead_procinfo (pi, "do_attach: couldn't save held signals.", NOKILL); 3632 3633 if ((fail = procfs_debug_inferior (pi)) != 0) 3634 dead_procinfo (pi, "do_attach: failed in procfs_debug_inferior", NOKILL); 3635 3636 /* Let GDB know that the inferior was attached. */ 3637 attach_flag = 1; 3638 return MERGEPID (pi->pid, proc_get_current_thread (pi)); 3639 } 3640 3641 static void 3642 do_detach (int signo) 3643 { 3644 procinfo *pi; 3645 3646 /* Find procinfo for the main process */ 3647 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); /* FIXME: threads */ 3648 if (signo) 3649 if (!proc_set_current_signal (pi, signo)) 3650 proc_warn (pi, "do_detach, set_current_signal", __LINE__); 3651 3652 if (!proc_set_traced_signals (pi, &pi->saved_sigset)) 3653 proc_warn (pi, "do_detach, set_traced_signal", __LINE__); 3654 3655 if (!proc_set_traced_faults (pi, &pi->saved_fltset)) 3656 proc_warn (pi, "do_detach, set_traced_faults", __LINE__); 3657 3658 if (!proc_set_traced_sysentry (pi, pi->saved_entryset)) 3659 proc_warn (pi, "do_detach, set_traced_sysentry", __LINE__); 3660 3661 if (!proc_set_traced_sysexit (pi, pi->saved_exitset)) 3662 proc_warn (pi, "do_detach, set_traced_sysexit", __LINE__); 3663 3664 if (!proc_set_held_signals (pi, &pi->saved_sighold)) 3665 proc_warn (pi, "do_detach, set_held_signals", __LINE__); 3666 3667 if (signo || (proc_flags (pi) & (PR_STOPPED | PR_ISTOP))) 3668 if (signo || !(pi->was_stopped) || 3669 query ("Was stopped when attached, make it runnable again? ")) 3670 { 3671 /* Clear any pending signal. */ 3672 if (!proc_clear_current_fault (pi)) 3673 proc_warn (pi, "do_detach, clear_current_fault", __LINE__); 3674 3675 if (signo == 0 && !proc_clear_current_signal (pi)) 3676 proc_warn (pi, "do_detach, clear_current_signal", __LINE__); 3677 3678 if (!proc_set_run_on_last_close (pi)) 3679 proc_warn (pi, "do_detach, set_rlc", __LINE__); 3680 } 3681 3682 attach_flag = 0; 3683 destroy_procinfo (pi); 3684 } 3685 3686 /* 3687 * fetch_registers 3688 * 3689 * Since the /proc interface cannot give us individual registers, 3690 * we pay no attention to the (regno) argument, and just fetch them all. 3691 * This results in the possibility that we will do unnecessarily many 3692 * fetches, since we may be called repeatedly for individual registers. 3693 * So we cache the results, and mark the cache invalid when the process 3694 * is resumed. 3695 */ 3696 3697 static void 3698 procfs_fetch_registers (int regno) 3699 { 3700 gdb_fpregset_t *fpregs; 3701 gdb_gregset_t *gregs; 3702 procinfo *pi; 3703 int pid; 3704 int tid; 3705 3706 pid = PIDGET (inferior_ptid); 3707 tid = TIDGET (inferior_ptid); 3708 3709 /* First look up procinfo for the main process. */ 3710 pi = find_procinfo_or_die (pid, 0); 3711 3712 /* If the event thread is not the same as GDB's requested thread 3713 (ie. inferior_ptid), then look up procinfo for the requested 3714 thread. */ 3715 if ((tid != 0) && 3716 (tid != proc_get_current_thread (pi))) 3717 pi = find_procinfo_or_die (pid, tid); 3718 3719 if (pi == NULL) 3720 error ("procfs: fetch_registers failed to find procinfo for %s", 3721 target_pid_to_str (inferior_ptid)); 3722 3723 if ((gregs = proc_get_gregs (pi)) == NULL) 3724 proc_error (pi, "fetch_registers, get_gregs", __LINE__); 3725 3726 supply_gregset (gregs); 3727 3728 if (FP0_REGNUM >= 0) /* need floating point? */ 3729 { 3730 if ((regno >= 0 && regno < FP0_REGNUM) 3731 || regno == PC_REGNUM 3732 || regno == DEPRECATED_FP_REGNUM 3733 || regno == SP_REGNUM) 3734 return; /* not a floating point register */ 3735 3736 if ((fpregs = proc_get_fpregs (pi)) == NULL) 3737 proc_error (pi, "fetch_registers, get_fpregs", __LINE__); 3738 3739 supply_fpregset (fpregs); 3740 } 3741 } 3742 3743 /* Get ready to modify the registers array. On machines which store 3744 individual registers, this doesn't need to do anything. On 3745 machines which store all the registers in one fell swoop, such as 3746 /proc, this makes sure that registers contains all the registers 3747 from the program being debugged. */ 3748 3749 static void 3750 procfs_prepare_to_store (void) 3751 { 3752 #ifdef CHILD_PREPARE_TO_STORE 3753 CHILD_PREPARE_TO_STORE (); 3754 #endif 3755 } 3756 3757 /* 3758 * store_registers 3759 * 3760 * Since the /proc interface will not read individual registers, 3761 * we will cache these requests until the process is resumed, and 3762 * only then write them back to the inferior process. 3763 * 3764 * FIXME: is that a really bad idea? Have to think about cases 3765 * where writing one register might affect the value of others, etc. 3766 */ 3767 3768 static void 3769 procfs_store_registers (int regno) 3770 { 3771 gdb_fpregset_t *fpregs; 3772 gdb_gregset_t *gregs; 3773 procinfo *pi; 3774 int pid; 3775 int tid; 3776 3777 pid = PIDGET (inferior_ptid); 3778 tid = TIDGET (inferior_ptid); 3779 3780 /* First find procinfo for main process */ 3781 pi = find_procinfo_or_die (pid, 0); 3782 3783 /* If current lwp for process is not the same as requested thread 3784 (ie. inferior_ptid), then find procinfo for the requested thread. */ 3785 3786 if ((tid != 0) && 3787 (tid != proc_get_current_thread (pi))) 3788 pi = find_procinfo_or_die (pid, tid); 3789 3790 if (pi == NULL) 3791 error ("procfs: store_registers: failed to find procinfo for %s", 3792 target_pid_to_str (inferior_ptid)); 3793 3794 if ((gregs = proc_get_gregs (pi)) == NULL) 3795 proc_error (pi, "store_registers, get_gregs", __LINE__); 3796 3797 fill_gregset (gregs, regno); 3798 if (!proc_set_gregs (pi)) 3799 proc_error (pi, "store_registers, set_gregs", __LINE__); 3800 3801 if (FP0_REGNUM >= 0) /* need floating point? */ 3802 { 3803 if ((regno >= 0 && regno < FP0_REGNUM) 3804 || regno == PC_REGNUM 3805 || regno == DEPRECATED_FP_REGNUM 3806 || regno == SP_REGNUM) 3807 return; /* not a floating point register */ 3808 3809 if ((fpregs = proc_get_fpregs (pi)) == NULL) 3810 proc_error (pi, "store_registers, get_fpregs", __LINE__); 3811 3812 fill_fpregset (fpregs, regno); 3813 if (!proc_set_fpregs (pi)) 3814 proc_error (pi, "store_registers, set_fpregs", __LINE__); 3815 } 3816 } 3817 3818 static int 3819 syscall_is_lwp_exit (procinfo *pi, int scall) 3820 { 3821 3822 #ifdef SYS_lwp_exit 3823 if (scall == SYS_lwp_exit) 3824 return 1; 3825 #endif 3826 #ifdef SYS_lwpexit 3827 if (scall == SYS_lwpexit) 3828 return 1; 3829 #endif 3830 return 0; 3831 } 3832 3833 static int 3834 syscall_is_exit (procinfo *pi, int scall) 3835 { 3836 #ifdef SYS_exit 3837 if (scall == SYS_exit) 3838 return 1; 3839 #endif 3840 #ifdef DYNAMIC_SYSCALLS 3841 if (find_syscall (pi, "_exit") == scall) 3842 return 1; 3843 #endif 3844 return 0; 3845 } 3846 3847 static int 3848 syscall_is_exec (procinfo *pi, int scall) 3849 { 3850 #ifdef SYS_exec 3851 if (scall == SYS_exec) 3852 return 1; 3853 #endif 3854 #ifdef SYS_execv 3855 if (scall == SYS_execv) 3856 return 1; 3857 #endif 3858 #ifdef SYS_execve 3859 if (scall == SYS_execve) 3860 return 1; 3861 #endif 3862 #ifdef DYNAMIC_SYSCALLS 3863 if (find_syscall (pi, "_execve")) 3864 return 1; 3865 if (find_syscall (pi, "ra_execve")) 3866 return 1; 3867 #endif 3868 return 0; 3869 } 3870 3871 static int 3872 syscall_is_lwp_create (procinfo *pi, int scall) 3873 { 3874 #ifdef SYS_lwp_create 3875 if (scall == SYS_lwp_create) 3876 return 1; 3877 #endif 3878 #ifdef SYS_lwpcreate 3879 if (scall == SYS_lwpcreate) 3880 return 1; 3881 #endif 3882 return 0; 3883 } 3884 3885 /* 3886 * Function: target_wait 3887 * 3888 * Retrieve the next stop event from the child process. 3889 * If child has not stopped yet, wait for it to stop. 3890 * Translate /proc eventcodes (or possibly wait eventcodes) 3891 * into gdb internal event codes. 3892 * 3893 * Return: id of process (and possibly thread) that incurred the event. 3894 * event codes are returned thru a pointer parameter. 3895 */ 3896 3897 static ptid_t 3898 procfs_wait (ptid_t ptid, struct target_waitstatus *status) 3899 { 3900 /* First cut: loosely based on original version 2.1 */ 3901 procinfo *pi; 3902 int wstat; 3903 int temp_tid; 3904 ptid_t retval, temp_ptid; 3905 int why, what, flags; 3906 int retry = 0; 3907 3908 wait_again: 3909 3910 retry++; 3911 wstat = 0; 3912 retval = pid_to_ptid (-1); 3913 3914 /* Find procinfo for main process */ 3915 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); 3916 if (pi) 3917 { 3918 /* We must assume that the status is stale now... */ 3919 pi->status_valid = 0; 3920 pi->gregs_valid = 0; 3921 pi->fpregs_valid = 0; 3922 3923 #if 0 /* just try this out... */ 3924 flags = proc_flags (pi); 3925 why = proc_why (pi); 3926 if ((flags & PR_STOPPED) && (why == PR_REQUESTED)) 3927 pi->status_valid = 0; /* re-read again, IMMEDIATELY... */ 3928 #endif 3929 /* If child is not stopped, wait for it to stop. */ 3930 if (!(proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) && 3931 !proc_wait_for_stop (pi)) 3932 { 3933 /* wait_for_stop failed: has the child terminated? */ 3934 if (errno == ENOENT) 3935 { 3936 int wait_retval; 3937 3938 /* /proc file not found; presumably child has terminated. */ 3939 wait_retval = wait (&wstat); /* "wait" for the child's exit */ 3940 3941 if (wait_retval != PIDGET (inferior_ptid)) /* wrong child? */ 3942 error ("procfs: couldn't stop process %d: wait returned %d\n", 3943 PIDGET (inferior_ptid), wait_retval); 3944 /* FIXME: might I not just use waitpid? 3945 Or try find_procinfo to see if I know about this child? */ 3946 retval = pid_to_ptid (wait_retval); 3947 } 3948 else if (errno == EINTR) 3949 goto wait_again; 3950 else 3951 { 3952 /* Unknown error from wait_for_stop. */ 3953 proc_error (pi, "target_wait (wait_for_stop)", __LINE__); 3954 } 3955 } 3956 else 3957 { 3958 /* This long block is reached if either: 3959 a) the child was already stopped, or 3960 b) we successfully waited for the child with wait_for_stop. 3961 This block will analyze the /proc status, and translate it 3962 into a waitstatus for GDB. 3963 3964 If we actually had to call wait because the /proc file 3965 is gone (child terminated), then we skip this block, 3966 because we already have a waitstatus. */ 3967 3968 flags = proc_flags (pi); 3969 why = proc_why (pi); 3970 what = proc_what (pi); 3971 3972 if (flags & (PR_STOPPED | PR_ISTOP)) 3973 { 3974 #ifdef PR_ASYNC 3975 /* If it's running async (for single_thread control), 3976 set it back to normal again. */ 3977 if (flags & PR_ASYNC) 3978 if (!proc_unset_async (pi)) 3979 proc_error (pi, "target_wait, unset_async", __LINE__); 3980 #endif 3981 3982 if (info_verbose) 3983 proc_prettyprint_why (why, what, 1); 3984 3985 /* The 'pid' we will return to GDB is composed of 3986 the process ID plus the lwp ID. */ 3987 retval = MERGEPID (pi->pid, proc_get_current_thread (pi)); 3988 3989 switch (why) { 3990 case PR_SIGNALLED: 3991 wstat = (what << 8) | 0177; 3992 break; 3993 case PR_SYSENTRY: 3994 if (syscall_is_lwp_exit (pi, what)) 3995 { 3996 printf_filtered ("[%s exited]\n", 3997 target_pid_to_str (retval)); 3998 delete_thread (retval); 3999 status->kind = TARGET_WAITKIND_SPURIOUS; 4000 return retval; 4001 } 4002 else if (syscall_is_exit (pi, what)) 4003 { 4004 /* Handle SYS_exit call only */ 4005 /* Stopped at entry to SYS_exit. 4006 Make it runnable, resume it, then use 4007 the wait system call to get its exit code. 4008 Proc_run_process always clears the current 4009 fault and signal. 4010 Then return its exit status. */ 4011 pi->status_valid = 0; 4012 wstat = 0; 4013 /* FIXME: what we should do is return 4014 TARGET_WAITKIND_SPURIOUS. */ 4015 if (!proc_run_process (pi, 0, 0)) 4016 proc_error (pi, "target_wait, run_process", __LINE__); 4017 if (attach_flag) 4018 { 4019 /* Don't call wait: simulate waiting for exit, 4020 return a "success" exit code. Bogus: what if 4021 it returns something else? */ 4022 wstat = 0; 4023 retval = inferior_ptid; /* ? ? ? */ 4024 } 4025 else 4026 { 4027 int temp = wait (&wstat); 4028 4029 /* FIXME: shouldn't I make sure I get the right 4030 event from the right process? If (for 4031 instance) I have killed an earlier inferior 4032 process but failed to clean up after it 4033 somehow, I could get its termination event 4034 here. */ 4035 4036 /* If wait returns -1, that's what we return to GDB. */ 4037 if (temp < 0) 4038 retval = pid_to_ptid (temp); 4039 } 4040 } 4041 else 4042 { 4043 printf_filtered ("procfs: trapped on entry to "); 4044 proc_prettyprint_syscall (proc_what (pi), 0); 4045 printf_filtered ("\n"); 4046 #ifndef PIOCSSPCACT 4047 { 4048 long i, nsysargs, *sysargs; 4049 4050 if ((nsysargs = proc_nsysarg (pi)) > 0 && 4051 (sysargs = proc_sysargs (pi)) != NULL) 4052 { 4053 printf_filtered ("%ld syscall arguments:\n", nsysargs); 4054 for (i = 0; i < nsysargs; i++) 4055 printf_filtered ("#%ld: 0x%08lx\n", 4056 i, sysargs[i]); 4057 } 4058 4059 } 4060 #endif 4061 if (status) 4062 { 4063 /* How to exit gracefully, returning "unknown event" */ 4064 status->kind = TARGET_WAITKIND_SPURIOUS; 4065 return inferior_ptid; 4066 } 4067 else 4068 { 4069 /* How to keep going without returning to wfi: */ 4070 target_resume (ptid, 0, TARGET_SIGNAL_0); 4071 goto wait_again; 4072 } 4073 } 4074 break; 4075 case PR_SYSEXIT: 4076 if (syscall_is_exec (pi, what)) 4077 { 4078 /* Hopefully this is our own "fork-child" execing 4079 the real child. Hoax this event into a trap, and 4080 GDB will see the child about to execute its start 4081 address. */ 4082 wstat = (SIGTRAP << 8) | 0177; 4083 } 4084 #ifdef SYS_syssgi 4085 else if (what == SYS_syssgi) 4086 { 4087 /* see if we can break on dbx_link(). If yes, then 4088 we no longer need the SYS_syssgi notifications. */ 4089 if (insert_dbx_link_breakpoint (pi)) 4090 proc_trace_syscalls_1 (pi, SYS_syssgi, PR_SYSEXIT, 4091 FLAG_RESET, 0); 4092 4093 /* This is an internal event and should be transparent 4094 to wfi, so resume the execution and wait again. See 4095 comment in procfs_init_inferior() for more details. */ 4096 target_resume (ptid, 0, TARGET_SIGNAL_0); 4097 goto wait_again; 4098 } 4099 #endif 4100 else if (syscall_is_lwp_create (pi, what)) 4101 { 4102 /* 4103 * This syscall is somewhat like fork/exec. 4104 * We will get the event twice: once for the parent LWP, 4105 * and once for the child. We should already know about 4106 * the parent LWP, but the child will be new to us. So, 4107 * whenever we get this event, if it represents a new 4108 * thread, simply add the thread to the list. 4109 */ 4110 4111 /* If not in procinfo list, add it. */ 4112 temp_tid = proc_get_current_thread (pi); 4113 if (!find_procinfo (pi->pid, temp_tid)) 4114 create_procinfo (pi->pid, temp_tid); 4115 4116 temp_ptid = MERGEPID (pi->pid, temp_tid); 4117 /* If not in GDB's thread list, add it. */ 4118 if (!in_thread_list (temp_ptid)) 4119 { 4120 printf_filtered ("[New %s]\n", 4121 target_pid_to_str (temp_ptid)); 4122 add_thread (temp_ptid); 4123 } 4124 /* Return to WFI, but tell it to immediately resume. */ 4125 status->kind = TARGET_WAITKIND_SPURIOUS; 4126 return inferior_ptid; 4127 } 4128 else if (syscall_is_lwp_exit (pi, what)) 4129 { 4130 printf_filtered ("[%s exited]\n", 4131 target_pid_to_str (retval)); 4132 delete_thread (retval); 4133 status->kind = TARGET_WAITKIND_SPURIOUS; 4134 return retval; 4135 } 4136 else if (0) 4137 { 4138 /* FIXME: Do we need to handle SYS_sproc, 4139 SYS_fork, or SYS_vfork here? The old procfs 4140 seemed to use this event to handle threads on 4141 older (non-LWP) systems, where I'm assuming 4142 that threads were actually separate processes. 4143 Irix, maybe? Anyway, low priority for now. */ 4144 } 4145 else 4146 { 4147 printf_filtered ("procfs: trapped on exit from "); 4148 proc_prettyprint_syscall (proc_what (pi), 0); 4149 printf_filtered ("\n"); 4150 #ifndef PIOCSSPCACT 4151 { 4152 long i, nsysargs, *sysargs; 4153 4154 if ((nsysargs = proc_nsysarg (pi)) > 0 && 4155 (sysargs = proc_sysargs (pi)) != NULL) 4156 { 4157 printf_filtered ("%ld syscall arguments:\n", nsysargs); 4158 for (i = 0; i < nsysargs; i++) 4159 printf_filtered ("#%ld: 0x%08lx\n", 4160 i, sysargs[i]); 4161 } 4162 } 4163 #endif 4164 status->kind = TARGET_WAITKIND_SPURIOUS; 4165 return inferior_ptid; 4166 } 4167 break; 4168 case PR_REQUESTED: 4169 #if 0 /* FIXME */ 4170 wstat = (SIGSTOP << 8) | 0177; 4171 break; 4172 #else 4173 if (retry < 5) 4174 { 4175 printf_filtered ("Retry #%d:\n", retry); 4176 pi->status_valid = 0; 4177 goto wait_again; 4178 } 4179 else 4180 { 4181 /* If not in procinfo list, add it. */ 4182 temp_tid = proc_get_current_thread (pi); 4183 if (!find_procinfo (pi->pid, temp_tid)) 4184 create_procinfo (pi->pid, temp_tid); 4185 4186 /* If not in GDB's thread list, add it. */ 4187 temp_ptid = MERGEPID (pi->pid, temp_tid); 4188 if (!in_thread_list (temp_ptid)) 4189 { 4190 printf_filtered ("[New %s]\n", 4191 target_pid_to_str (temp_ptid)); 4192 add_thread (temp_ptid); 4193 } 4194 4195 status->kind = TARGET_WAITKIND_STOPPED; 4196 status->value.sig = 0; 4197 return retval; 4198 } 4199 #endif 4200 case PR_JOBCONTROL: 4201 wstat = (what << 8) | 0177; 4202 break; 4203 case PR_FAULTED: 4204 switch (what) { 4205 #ifdef FLTWATCH 4206 case FLTWATCH: 4207 wstat = (SIGTRAP << 8) | 0177; 4208 break; 4209 #endif 4210 #ifdef FLTKWATCH 4211 case FLTKWATCH: 4212 wstat = (SIGTRAP << 8) | 0177; 4213 break; 4214 #endif 4215 /* FIXME: use si_signo where possible. */ 4216 case FLTPRIV: 4217 #if (FLTILL != FLTPRIV) /* avoid "duplicate case" error */ 4218 case FLTILL: 4219 #endif 4220 wstat = (SIGILL << 8) | 0177; 4221 break; 4222 case FLTBPT: 4223 #if (FLTTRACE != FLTBPT) /* avoid "duplicate case" error */ 4224 case FLTTRACE: 4225 #endif 4226 /* If we hit our __dbx_link() internal breakpoint, 4227 then remove it. See comments in procfs_init_inferior() 4228 for more details. */ 4229 if (dbx_link_bpt_addr != 0 4230 && dbx_link_bpt_addr == read_pc ()) 4231 remove_dbx_link_breakpoint (); 4232 4233 wstat = (SIGTRAP << 8) | 0177; 4234 break; 4235 case FLTSTACK: 4236 case FLTACCESS: 4237 #if (FLTBOUNDS != FLTSTACK) /* avoid "duplicate case" error */ 4238 case FLTBOUNDS: 4239 #endif 4240 wstat = (SIGSEGV << 8) | 0177; 4241 break; 4242 case FLTIOVF: 4243 case FLTIZDIV: 4244 #if (FLTFPE != FLTIOVF) /* avoid "duplicate case" error */ 4245 case FLTFPE: 4246 #endif 4247 wstat = (SIGFPE << 8) | 0177; 4248 break; 4249 case FLTPAGE: /* Recoverable page fault */ 4250 default: /* FIXME: use si_signo if possible for fault */ 4251 retval = pid_to_ptid (-1); 4252 printf_filtered ("procfs:%d -- ", __LINE__); 4253 printf_filtered ("child stopped for unknown reason:\n"); 4254 proc_prettyprint_why (why, what, 1); 4255 error ("... giving up..."); 4256 break; 4257 } 4258 break; /* case PR_FAULTED: */ 4259 default: /* switch (why) unmatched */ 4260 printf_filtered ("procfs:%d -- ", __LINE__); 4261 printf_filtered ("child stopped for unknown reason:\n"); 4262 proc_prettyprint_why (why, what, 1); 4263 error ("... giving up..."); 4264 break; 4265 } 4266 /* 4267 * Got this far without error: 4268 * If retval isn't in the threads database, add it. 4269 */ 4270 if (PIDGET (retval) > 0 && 4271 !ptid_equal (retval, inferior_ptid) && 4272 !in_thread_list (retval)) 4273 { 4274 /* 4275 * We have a new thread. 4276 * We need to add it both to GDB's list and to our own. 4277 * If we don't create a procinfo, resume may be unhappy 4278 * later. 4279 */ 4280 printf_filtered ("[New %s]\n", target_pid_to_str (retval)); 4281 add_thread (retval); 4282 if (find_procinfo (PIDGET (retval), TIDGET (retval)) == NULL) 4283 create_procinfo (PIDGET (retval), TIDGET (retval)); 4284 4285 /* In addition, it's possible that this is the first 4286 * new thread we've seen, in which case we may not 4287 * have created entries for inferior_ptid yet. 4288 */ 4289 if (TIDGET (inferior_ptid) != 0) 4290 { 4291 if (!in_thread_list (inferior_ptid)) 4292 add_thread (inferior_ptid); 4293 if (find_procinfo (PIDGET (inferior_ptid), 4294 TIDGET (inferior_ptid)) == NULL) 4295 create_procinfo (PIDGET (inferior_ptid), 4296 TIDGET (inferior_ptid)); 4297 } 4298 } 4299 } 4300 else /* flags do not indicate STOPPED */ 4301 { 4302 /* surely this can't happen... */ 4303 printf_filtered ("procfs:%d -- process not stopped.\n", 4304 __LINE__); 4305 proc_prettyprint_flags (flags, 1); 4306 error ("procfs: ...giving up..."); 4307 } 4308 } 4309 4310 if (status) 4311 store_waitstatus (status, wstat); 4312 } 4313 4314 return retval; 4315 } 4316 4317 /* Perform a partial transfer to/from the specified object. For 4318 memory transfers, fall back to the old memory xfer functions. */ 4319 4320 static LONGEST 4321 procfs_xfer_partial (struct target_ops *ops, enum target_object object, 4322 const char *annex, void *readbuf, 4323 const void *writebuf, ULONGEST offset, LONGEST len) 4324 { 4325 switch (object) 4326 { 4327 case TARGET_OBJECT_MEMORY: 4328 if (readbuf) 4329 return (*ops->deprecated_xfer_memory) (offset, readbuf, len, 4330 0/*write*/, NULL, ops); 4331 if (writebuf) 4332 return (*ops->deprecated_xfer_memory) (offset, writebuf, len, 4333 1/*write*/, NULL, ops); 4334 return -1; 4335 4336 #ifdef NEW_PROC_API 4337 case TARGET_OBJECT_AUXV: 4338 return procfs_xfer_auxv (ops, object, annex, readbuf, writebuf, 4339 offset, len); 4340 #endif 4341 4342 default: 4343 if (ops->beneath != NULL) 4344 return ops->beneath->to_xfer_partial (ops->beneath, object, annex, 4345 readbuf, writebuf, offset, len); 4346 return -1; 4347 } 4348 } 4349 4350 4351 /* Transfer LEN bytes between GDB address MYADDR and target address 4352 MEMADDR. If DOWRITE is non-zero, transfer them to the target, 4353 otherwise transfer them from the target. TARGET is unused. 4354 4355 The return value is 0 if an error occurred or no bytes were 4356 transferred. Otherwise, it will be a positive value which 4357 indicates the number of bytes transferred between gdb and the 4358 target. (Note that the interface also makes provisions for 4359 negative values, but this capability isn't implemented here.) */ 4360 4361 static int 4362 procfs_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int dowrite, 4363 struct mem_attrib *attrib, struct target_ops *target) 4364 { 4365 procinfo *pi; 4366 int nbytes = 0; 4367 4368 /* Find procinfo for main process */ 4369 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); 4370 if (pi->as_fd == 0 && 4371 open_procinfo_files (pi, FD_AS) == 0) 4372 { 4373 proc_warn (pi, "xfer_memory, open_proc_files", __LINE__); 4374 return 0; 4375 } 4376 4377 if (lseek (pi->as_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr) 4378 { 4379 if (dowrite) 4380 { 4381 #ifdef NEW_PROC_API 4382 PROCFS_NOTE ("write memory: "); 4383 #else 4384 PROCFS_NOTE ("write memory: \n"); 4385 #endif 4386 nbytes = write (pi->as_fd, myaddr, len); 4387 } 4388 else 4389 { 4390 PROCFS_NOTE ("read memory: \n"); 4391 nbytes = read (pi->as_fd, myaddr, len); 4392 } 4393 if (nbytes < 0) 4394 { 4395 nbytes = 0; 4396 } 4397 } 4398 return nbytes; 4399 } 4400 4401 /* 4402 * Function: invalidate_cache 4403 * 4404 * Called by target_resume before making child runnable. 4405 * Mark cached registers and status's invalid. 4406 * If there are "dirty" caches that need to be written back 4407 * to the child process, do that. 4408 * 4409 * File descriptors are also cached. 4410 * As they are a limited resource, we cannot hold onto them indefinitely. 4411 * However, as they are expensive to open, we don't want to throw them 4412 * away indescriminately either. As a compromise, we will keep the 4413 * file descriptors for the parent process, but discard any file 4414 * descriptors we may have accumulated for the threads. 4415 * 4416 * Return value: 4417 * As this function is called by iterate_over_threads, it always 4418 * returns zero (so that iterate_over_threads will keep iterating). 4419 */ 4420 4421 4422 static int 4423 invalidate_cache (procinfo *parent, procinfo *pi, void *ptr) 4424 { 4425 /* 4426 * About to run the child; invalidate caches and do any other cleanup. 4427 */ 4428 4429 #if 0 4430 if (pi->gregs_dirty) 4431 if (parent == NULL || 4432 proc_get_current_thread (parent) != pi->tid) 4433 if (!proc_set_gregs (pi)) /* flush gregs cache */ 4434 proc_warn (pi, "target_resume, set_gregs", 4435 __LINE__); 4436 if (FP0_REGNUM >= 0) 4437 if (pi->fpregs_dirty) 4438 if (parent == NULL || 4439 proc_get_current_thread (parent) != pi->tid) 4440 if (!proc_set_fpregs (pi)) /* flush fpregs cache */ 4441 proc_warn (pi, "target_resume, set_fpregs", 4442 __LINE__); 4443 #endif 4444 4445 if (parent != NULL) 4446 { 4447 /* The presence of a parent indicates that this is an LWP. 4448 Close any file descriptors that it might have open. 4449 We don't do this to the master (parent) procinfo. */ 4450 4451 close_procinfo_files (pi); 4452 } 4453 pi->gregs_valid = 0; 4454 pi->fpregs_valid = 0; 4455 #if 0 4456 pi->gregs_dirty = 0; 4457 pi->fpregs_dirty = 0; 4458 #endif 4459 pi->status_valid = 0; 4460 pi->threads_valid = 0; 4461 4462 return 0; 4463 } 4464 4465 #if 0 4466 /* 4467 * Function: make_signal_thread_runnable 4468 * 4469 * A callback function for iterate_over_threads. 4470 * Find the asynchronous signal thread, and make it runnable. 4471 * See if that helps matters any. 4472 */ 4473 4474 static int 4475 make_signal_thread_runnable (procinfo *process, procinfo *pi, void *ptr) 4476 { 4477 #ifdef PR_ASLWP 4478 if (proc_flags (pi) & PR_ASLWP) 4479 { 4480 if (!proc_run_process (pi, 0, -1)) 4481 proc_error (pi, "make_signal_thread_runnable", __LINE__); 4482 return 1; 4483 } 4484 #endif 4485 return 0; 4486 } 4487 #endif 4488 4489 /* 4490 * Function: target_resume 4491 * 4492 * Make the child process runnable. Normally we will then call 4493 * procfs_wait and wait for it to stop again (unles gdb is async). 4494 * 4495 * Arguments: 4496 * step: if true, then arrange for the child to stop again 4497 * after executing a single instruction. 4498 * signo: if zero, then cancel any pending signal. 4499 * If non-zero, then arrange for the indicated signal 4500 * to be delivered to the child when it runs. 4501 * pid: if -1, then allow any child thread to run. 4502 * if non-zero, then allow only the indicated thread to run. 4503 ******* (not implemented yet) 4504 */ 4505 4506 static void 4507 procfs_resume (ptid_t ptid, int step, enum target_signal signo) 4508 { 4509 procinfo *pi, *thread; 4510 int native_signo; 4511 4512 /* 2.1: 4513 prrun.prflags |= PRSVADDR; 4514 prrun.pr_vaddr = $PC; set resume address 4515 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all) 4516 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE) 4517 prrun.prflags |= PRCFAULT; clear current fault. 4518 4519 PRSTRACE and PRSFAULT can be done by other means 4520 (proc_trace_signals, proc_trace_faults) 4521 PRSVADDR is unnecessary. 4522 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault) 4523 This basically leaves PRSTEP and PRCSIG. 4524 PRCSIG is like PIOCSSIG (proc_clear_current_signal). 4525 So basically PR_STEP is the sole argument that must be passed 4526 to proc_run_process (for use in the prrun struct by ioctl). */ 4527 4528 /* Find procinfo for main process */ 4529 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); 4530 4531 /* First cut: ignore pid argument */ 4532 errno = 0; 4533 4534 /* Convert signal to host numbering. */ 4535 if (signo == 0 || 4536 (signo == TARGET_SIGNAL_STOP && pi->ignore_next_sigstop)) 4537 native_signo = 0; 4538 else 4539 native_signo = target_signal_to_host (signo); 4540 4541 pi->ignore_next_sigstop = 0; 4542 4543 /* Running the process voids all cached registers and status. */ 4544 /* Void the threads' caches first */ 4545 proc_iterate_over_threads (pi, invalidate_cache, NULL); 4546 /* Void the process procinfo's caches. */ 4547 invalidate_cache (NULL, pi, NULL); 4548 4549 if (PIDGET (ptid) != -1) 4550 { 4551 /* Resume a specific thread, presumably suppressing the others. */ 4552 thread = find_procinfo (PIDGET (ptid), TIDGET (ptid)); 4553 if (thread != NULL) 4554 { 4555 if (thread->tid != 0) 4556 { 4557 /* We're to resume a specific thread, and not the others. 4558 * Set the child process's PR_ASYNC flag. 4559 */ 4560 #ifdef PR_ASYNC 4561 if (!proc_set_async (pi)) 4562 proc_error (pi, "target_resume, set_async", __LINE__); 4563 #endif 4564 #if 0 4565 proc_iterate_over_threads (pi, 4566 make_signal_thread_runnable, 4567 NULL); 4568 #endif 4569 pi = thread; /* substitute the thread's procinfo for run */ 4570 } 4571 } 4572 } 4573 4574 if (!proc_run_process (pi, step, native_signo)) 4575 { 4576 if (errno == EBUSY) 4577 warning ("resume: target already running. Pretend to resume, and hope for the best!\n"); 4578 else 4579 proc_error (pi, "target_resume", __LINE__); 4580 } 4581 } 4582 4583 /* 4584 * Function: register_gdb_signals 4585 * 4586 * Traverse the list of signals that GDB knows about 4587 * (see "handle" command), and arrange for the target 4588 * to be stopped or not, according to these settings. 4589 * 4590 * Returns non-zero for success, zero for failure. 4591 */ 4592 4593 static int 4594 register_gdb_signals (procinfo *pi, gdb_sigset_t *signals) 4595 { 4596 int signo; 4597 4598 for (signo = 0; signo < NSIG; signo ++) 4599 if (signal_stop_state (target_signal_from_host (signo)) == 0 && 4600 signal_print_state (target_signal_from_host (signo)) == 0 && 4601 signal_pass_state (target_signal_from_host (signo)) == 1) 4602 prdelset (signals, signo); 4603 else 4604 praddset (signals, signo); 4605 4606 return proc_set_traced_signals (pi, signals); 4607 } 4608 4609 /* 4610 * Function: target_notice_signals 4611 * 4612 * Set up to trace signals in the child process. 4613 */ 4614 4615 static void 4616 procfs_notice_signals (ptid_t ptid) 4617 { 4618 gdb_sigset_t signals; 4619 procinfo *pi = find_procinfo_or_die (PIDGET (ptid), 0); 4620 4621 if (proc_get_traced_signals (pi, &signals) && 4622 register_gdb_signals (pi, &signals)) 4623 return; 4624 else 4625 proc_error (pi, "notice_signals", __LINE__); 4626 } 4627 4628 /* 4629 * Function: target_files_info 4630 * 4631 * Print status information about the child process. 4632 */ 4633 4634 static void 4635 procfs_files_info (struct target_ops *ignore) 4636 { 4637 printf_filtered ("\tUsing the running image of %s %s via /proc.\n", 4638 attach_flag? "attached": "child", 4639 target_pid_to_str (inferior_ptid)); 4640 } 4641 4642 /* 4643 * Function: target_open 4644 * 4645 * A dummy: you don't open procfs. 4646 */ 4647 4648 static void 4649 procfs_open (char *args, int from_tty) 4650 { 4651 error ("Use the \"run\" command to start a Unix child process."); 4652 } 4653 4654 /* 4655 * Function: target_can_run 4656 * 4657 * This tells GDB that this target vector can be invoked 4658 * for "run" or "attach". 4659 */ 4660 4661 int procfs_suppress_run = 0; /* Non-zero if procfs should pretend not to 4662 be a runnable target. Used by targets 4663 that can sit atop procfs, such as solaris 4664 thread support. */ 4665 4666 4667 static int 4668 procfs_can_run (void) 4669 { 4670 /* This variable is controlled by modules that sit atop procfs that 4671 may layer their own process structure atop that provided here. 4672 sol-thread.c does this because of the Solaris two-level thread 4673 model. */ 4674 4675 /* NOTE: possibly obsolete -- use the thread_stratum approach instead. */ 4676 4677 return !procfs_suppress_run; 4678 } 4679 4680 /* 4681 * Function: target_stop 4682 * 4683 * Stop the child process asynchronously, as when the 4684 * gdb user types control-c or presses a "stop" button. 4685 * 4686 * Works by sending kill(SIGINT) to the child's process group. 4687 */ 4688 4689 static void 4690 procfs_stop (void) 4691 { 4692 kill (-inferior_process_group, SIGINT); 4693 } 4694 4695 /* 4696 * Function: unconditionally_kill_inferior 4697 * 4698 * Make it die. Wait for it to die. Clean up after it. 4699 * Note: this should only be applied to the real process, 4700 * not to an LWP, because of the check for parent-process. 4701 * If we need this to work for an LWP, it needs some more logic. 4702 */ 4703 4704 static void 4705 unconditionally_kill_inferior (procinfo *pi) 4706 { 4707 int parent_pid; 4708 4709 parent_pid = proc_parent_pid (pi); 4710 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL 4711 /* FIXME: use access functions */ 4712 /* Alpha OSF/1-3.x procfs needs a clear of the current signal 4713 before the PIOCKILL, otherwise it might generate a corrupted core 4714 file for the inferior. */ 4715 if (ioctl (pi->ctl_fd, PIOCSSIG, NULL) < 0) 4716 { 4717 printf_filtered ("unconditionally_kill: SSIG failed!\n"); 4718 } 4719 #endif 4720 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL 4721 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal 4722 to kill the inferior, otherwise it might remain stopped with a 4723 pending SIGKILL. 4724 We do not check the result of the PIOCSSIG, the inferior might have 4725 died already. */ 4726 { 4727 gdb_siginfo_t newsiginfo; 4728 4729 memset ((char *) &newsiginfo, 0, sizeof (newsiginfo)); 4730 newsiginfo.si_signo = SIGKILL; 4731 newsiginfo.si_code = 0; 4732 newsiginfo.si_errno = 0; 4733 newsiginfo.si_pid = getpid (); 4734 newsiginfo.si_uid = getuid (); 4735 /* FIXME: use proc_set_current_signal */ 4736 ioctl (pi->ctl_fd, PIOCSSIG, &newsiginfo); 4737 } 4738 #else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */ 4739 if (!proc_kill (pi, SIGKILL)) 4740 proc_error (pi, "unconditionally_kill, proc_kill", __LINE__); 4741 #endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */ 4742 destroy_procinfo (pi); 4743 4744 /* If pi is GDB's child, wait for it to die. */ 4745 if (parent_pid == getpid ()) 4746 /* FIXME: should we use waitpid to make sure we get the right event? 4747 Should we check the returned event? */ 4748 { 4749 #if 0 4750 int status, ret; 4751 4752 ret = waitpid (pi->pid, &status, 0); 4753 #else 4754 wait (NULL); 4755 #endif 4756 } 4757 } 4758 4759 /* 4760 * Function: target_kill_inferior 4761 * 4762 * We're done debugging it, and we want it to go away. 4763 * Then we want GDB to forget all about it. 4764 */ 4765 4766 static void 4767 procfs_kill_inferior (void) 4768 { 4769 if (!ptid_equal (inferior_ptid, null_ptid)) /* ? */ 4770 { 4771 /* Find procinfo for main process */ 4772 procinfo *pi = find_procinfo (PIDGET (inferior_ptid), 0); 4773 4774 if (pi) 4775 unconditionally_kill_inferior (pi); 4776 target_mourn_inferior (); 4777 } 4778 } 4779 4780 /* 4781 * Function: target_mourn_inferior 4782 * 4783 * Forget we ever debugged this thing! 4784 */ 4785 4786 static void 4787 procfs_mourn_inferior (void) 4788 { 4789 procinfo *pi; 4790 4791 if (!ptid_equal (inferior_ptid, null_ptid)) 4792 { 4793 /* Find procinfo for main process */ 4794 pi = find_procinfo (PIDGET (inferior_ptid), 0); 4795 if (pi) 4796 destroy_procinfo (pi); 4797 } 4798 unpush_target (&procfs_ops); 4799 generic_mourn_inferior (); 4800 } 4801 4802 /* 4803 * Function: init_inferior 4804 * 4805 * When GDB forks to create a runnable inferior process, 4806 * this function is called on the parent side of the fork. 4807 * It's job is to do whatever is necessary to make the child 4808 * ready to be debugged, and then wait for the child to synchronize. 4809 */ 4810 4811 static void 4812 procfs_init_inferior (int pid) 4813 { 4814 procinfo *pi; 4815 gdb_sigset_t signals; 4816 int fail; 4817 4818 /* This routine called on the parent side (GDB side) 4819 after GDB forks the inferior. */ 4820 4821 push_target (&procfs_ops); 4822 4823 if ((pi = create_procinfo (pid, 0)) == NULL) 4824 perror ("procfs: out of memory in 'init_inferior'"); 4825 4826 if (!open_procinfo_files (pi, FD_CTL)) 4827 proc_error (pi, "init_inferior, open_proc_files", __LINE__); 4828 4829 /* 4830 xmalloc // done 4831 open_procinfo_files // done 4832 link list // done 4833 prfillset (trace) 4834 procfs_notice_signals 4835 prfillset (fault) 4836 prdelset (FLTPAGE) 4837 PIOCWSTOP 4838 PIOCSFAULT 4839 */ 4840 4841 /* If not stopped yet, wait for it to stop. */ 4842 if (!(proc_flags (pi) & PR_STOPPED) && 4843 !(proc_wait_for_stop (pi))) 4844 dead_procinfo (pi, "init_inferior: wait_for_stop failed", KILL); 4845 4846 /* Save some of the /proc state to be restored if we detach. */ 4847 /* FIXME: Why? In case another debugger was debugging it? 4848 We're it's parent, for Ghu's sake! */ 4849 if (!proc_get_traced_signals (pi, &pi->saved_sigset)) 4850 proc_error (pi, "init_inferior, get_traced_signals", __LINE__); 4851 if (!proc_get_held_signals (pi, &pi->saved_sighold)) 4852 proc_error (pi, "init_inferior, get_held_signals", __LINE__); 4853 if (!proc_get_traced_faults (pi, &pi->saved_fltset)) 4854 proc_error (pi, "init_inferior, get_traced_faults", __LINE__); 4855 if (!proc_get_traced_sysentry (pi, pi->saved_entryset)) 4856 proc_error (pi, "init_inferior, get_traced_sysentry", __LINE__); 4857 if (!proc_get_traced_sysexit (pi, pi->saved_exitset)) 4858 proc_error (pi, "init_inferior, get_traced_sysexit", __LINE__); 4859 4860 /* Register to trace selected signals in the child. */ 4861 prfillset (&signals); 4862 if (!register_gdb_signals (pi, &signals)) 4863 proc_error (pi, "init_inferior, register_signals", __LINE__); 4864 4865 if ((fail = procfs_debug_inferior (pi)) != 0) 4866 proc_error (pi, "init_inferior (procfs_debug_inferior)", fail); 4867 4868 /* FIXME: logically, we should really be turning OFF run-on-last-close, 4869 and possibly even turning ON kill-on-last-close at this point. But 4870 I can't make that change without careful testing which I don't have 4871 time to do right now... */ 4872 /* Turn on run-on-last-close flag so that the child 4873 will die if GDB goes away for some reason. */ 4874 if (!proc_set_run_on_last_close (pi)) 4875 proc_error (pi, "init_inferior, set_RLC", __LINE__); 4876 4877 /* The 'process ID' we return to GDB is composed of 4878 the actual process ID plus the lwp ID. */ 4879 inferior_ptid = MERGEPID (pi->pid, proc_get_current_thread (pi)); 4880 4881 /* Typically two, one trap to exec the shell, one to exec the 4882 program being debugged. Defined by "inferior.h". */ 4883 startup_inferior (START_INFERIOR_TRAPS_EXPECTED); 4884 4885 #ifdef SYS_syssgi 4886 /* On mips-irix, we need to stop the inferior early enough during 4887 the startup phase in order to be able to load the shared library 4888 symbols and insert the breakpoints that are located in these shared 4889 libraries. Stopping at the program entry point is not good enough 4890 because the -init code is executed before the execution reaches 4891 that point. 4892 4893 So what we need to do is to insert a breakpoint in the runtime 4894 loader (rld), more precisely in __dbx_link(). This procedure is 4895 called by rld once all shared libraries have been mapped, but before 4896 the -init code is executed. Unfortuantely, this is not straightforward, 4897 as rld is not part of the executable we are running, and thus we need 4898 the inferior to run until rld itself has been mapped in memory. 4899 4900 For this, we trace all syssgi() syscall exit events. Each time 4901 we detect such an event, we iterate over each text memory maps, 4902 get its associated fd, and scan the symbol table for __dbx_link(). 4903 When found, we know that rld has been mapped, and that we can insert 4904 the breakpoint at the symbol address. Once the dbx_link() breakpoint 4905 has been inserted, the syssgi() notifications are no longer necessary, 4906 so they should be canceled. */ 4907 proc_trace_syscalls_1 (pi, SYS_syssgi, PR_SYSEXIT, FLAG_SET, 0); 4908 dbx_link_bpt_addr = 0; 4909 #endif 4910 } 4911 4912 /* 4913 * Function: set_exec_trap 4914 * 4915 * When GDB forks to create a new process, this function is called 4916 * on the child side of the fork before GDB exec's the user program. 4917 * Its job is to make the child minimally debuggable, so that the 4918 * parent GDB process can connect to the child and take over. 4919 * This function should do only the minimum to make that possible, 4920 * and to synchronize with the parent process. The parent process 4921 * should take care of the details. 4922 */ 4923 4924 static void 4925 procfs_set_exec_trap (void) 4926 { 4927 /* This routine called on the child side (inferior side) 4928 after GDB forks the inferior. It must use only local variables, 4929 because it may be sharing data space with its parent. */ 4930 4931 procinfo *pi; 4932 sysset_t *exitset; 4933 4934 if ((pi = create_procinfo (getpid (), 0)) == NULL) 4935 perror_with_name ("procfs: create_procinfo failed in child."); 4936 4937 if (open_procinfo_files (pi, FD_CTL) == 0) 4938 { 4939 proc_warn (pi, "set_exec_trap, open_proc_files", __LINE__); 4940 gdb_flush (gdb_stderr); 4941 /* no need to call "dead_procinfo", because we're going to exit. */ 4942 _exit (127); 4943 } 4944 4945 #ifdef PRFS_STOPEXEC /* defined on OSF */ 4946 /* OSF method for tracing exec syscalls. Quoting: 4947 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace 4948 exits from exec system calls because of the user level loader. */ 4949 /* FIXME: make nice and maybe move into an access function. */ 4950 { 4951 int prfs_flags; 4952 4953 if (ioctl (pi->ctl_fd, PIOCGSPCACT, &prfs_flags) < 0) 4954 { 4955 proc_warn (pi, "set_exec_trap (PIOCGSPCACT)", __LINE__); 4956 gdb_flush (gdb_stderr); 4957 _exit (127); 4958 } 4959 prfs_flags |= PRFS_STOPEXEC; 4960 4961 if (ioctl (pi->ctl_fd, PIOCSSPCACT, &prfs_flags) < 0) 4962 { 4963 proc_warn (pi, "set_exec_trap (PIOCSSPCACT)", __LINE__); 4964 gdb_flush (gdb_stderr); 4965 _exit (127); 4966 } 4967 } 4968 #else /* not PRFS_STOPEXEC */ 4969 /* Everyone else's (except OSF) method for tracing exec syscalls */ 4970 /* GW: Rationale... 4971 Not all systems with /proc have all the exec* syscalls with the same 4972 names. On the SGI, for example, there is no SYS_exec, but there 4973 *is* a SYS_execv. So, we try to account for that. */ 4974 4975 exitset = sysset_t_alloc (pi); 4976 gdb_premptysysset (exitset); 4977 #ifdef SYS_exec 4978 gdb_praddsysset (exitset, SYS_exec); 4979 #endif 4980 #ifdef SYS_execve 4981 gdb_praddsysset (exitset, SYS_execve); 4982 #endif 4983 #ifdef SYS_execv 4984 gdb_praddsysset (exitset, SYS_execv); 4985 #endif 4986 #ifdef DYNAMIC_SYSCALLS 4987 { 4988 int callnum = find_syscall (pi, "execve"); 4989 4990 if (callnum >= 0) 4991 gdb_praddsysset (exitset, callnum); 4992 4993 callnum = find_syscall (pi, "ra_execve"); 4994 if (callnum >= 0) 4995 gdb_praddsysset (exitset, callnum); 4996 } 4997 #endif /* DYNAMIC_SYSCALLS */ 4998 4999 if (!proc_set_traced_sysexit (pi, exitset)) 5000 { 5001 proc_warn (pi, "set_exec_trap, set_traced_sysexit", __LINE__); 5002 gdb_flush (gdb_stderr); 5003 _exit (127); 5004 } 5005 #endif /* PRFS_STOPEXEC */ 5006 5007 /* FIXME: should this be done in the parent instead? */ 5008 /* Turn off inherit on fork flag so that all grand-children 5009 of gdb start with tracing flags cleared. */ 5010 if (!proc_unset_inherit_on_fork (pi)) 5011 proc_warn (pi, "set_exec_trap, unset_inherit", __LINE__); 5012 5013 /* Turn off run on last close flag, so that the child process 5014 cannot run away just because we close our handle on it. 5015 We want it to wait for the parent to attach. */ 5016 if (!proc_unset_run_on_last_close (pi)) 5017 proc_warn (pi, "set_exec_trap, unset_RLC", __LINE__); 5018 5019 /* FIXME: No need to destroy the procinfo -- 5020 we have our own address space, and we're about to do an exec! */ 5021 /*destroy_procinfo (pi);*/ 5022 } 5023 5024 /* 5025 * Function: create_inferior 5026 * 5027 * This function is called BEFORE gdb forks the inferior process. 5028 * Its only real responsibility is to set things up for the fork, 5029 * and tell GDB which two functions to call after the fork (one 5030 * for the parent, and one for the child). 5031 * 5032 * This function does a complicated search for a unix shell program, 5033 * which it then uses to parse arguments and environment variables 5034 * to be sent to the child. I wonder whether this code could not 5035 * be abstracted out and shared with other unix targets such as 5036 * infptrace? 5037 */ 5038 5039 static void 5040 procfs_create_inferior (char *exec_file, char *allargs, char **env, 5041 int from_tty) 5042 { 5043 char *shell_file = getenv ("SHELL"); 5044 char *tryname; 5045 if (shell_file != NULL && strchr (shell_file, '/') == NULL) 5046 { 5047 5048 /* We will be looking down the PATH to find shell_file. If we 5049 just do this the normal way (via execlp, which operates by 5050 attempting an exec for each element of the PATH until it 5051 finds one which succeeds), then there will be an exec for 5052 each failed attempt, each of which will cause a PR_SYSEXIT 5053 stop, and we won't know how to distinguish the PR_SYSEXIT's 5054 for these failed execs with the ones for successful execs 5055 (whether the exec has succeeded is stored at that time in the 5056 carry bit or some such architecture-specific and 5057 non-ABI-specified place). 5058 5059 So I can't think of anything better than to search the PATH 5060 now. This has several disadvantages: (1) There is a race 5061 condition; if we find a file now and it is deleted before we 5062 exec it, we lose, even if the deletion leaves a valid file 5063 further down in the PATH, (2) there is no way to know exactly 5064 what an executable (in the sense of "capable of being 5065 exec'd") file is. Using access() loses because it may lose 5066 if the caller is the superuser; failing to use it loses if 5067 there are ACLs or some such. */ 5068 5069 char *p; 5070 char *p1; 5071 /* FIXME-maybe: might want "set path" command so user can change what 5072 path is used from within GDB. */ 5073 char *path = getenv ("PATH"); 5074 int len; 5075 struct stat statbuf; 5076 5077 if (path == NULL) 5078 path = "/bin:/usr/bin"; 5079 5080 tryname = alloca (strlen (path) + strlen (shell_file) + 2); 5081 for (p = path; p != NULL; p = p1 ? p1 + 1: NULL) 5082 { 5083 p1 = strchr (p, ':'); 5084 if (p1 != NULL) 5085 len = p1 - p; 5086 else 5087 len = strlen (p); 5088 strncpy (tryname, p, len); 5089 tryname[len] = '\0'; 5090 strcat (tryname, "/"); 5091 strcat (tryname, shell_file); 5092 if (access (tryname, X_OK) < 0) 5093 continue; 5094 if (stat (tryname, &statbuf) < 0) 5095 continue; 5096 if (!S_ISREG (statbuf.st_mode)) 5097 /* We certainly need to reject directories. I'm not quite 5098 as sure about FIFOs, sockets, etc., but I kind of doubt 5099 that people want to exec() these things. */ 5100 continue; 5101 break; 5102 } 5103 if (p == NULL) 5104 /* Not found. This must be an error rather than merely passing 5105 the file to execlp(), because execlp() would try all the 5106 exec()s, causing GDB to get confused. */ 5107 error ("procfs:%d -- Can't find shell %s in PATH", 5108 __LINE__, shell_file); 5109 5110 shell_file = tryname; 5111 } 5112 5113 fork_inferior (exec_file, allargs, env, procfs_set_exec_trap, 5114 procfs_init_inferior, NULL, shell_file); 5115 5116 #ifdef SYS_syssgi 5117 /* Make sure to cancel the syssgi() syscall-exit notifications. 5118 They should normally have been removed by now, but they may still 5119 be activated if the inferior doesn't use shared libraries, or if 5120 we didn't locate __dbx_link, or if we never stopped in __dbx_link. 5121 See procfs_init_inferior() for more details. */ 5122 proc_trace_syscalls_1 (find_procinfo_or_die (PIDGET (inferior_ptid), 0), 5123 SYS_syssgi, PR_SYSEXIT, FLAG_RESET, 0); 5124 #endif 5125 5126 /* We are at the first instruction we care about. */ 5127 /* Pedal to the metal... */ 5128 5129 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0); 5130 } 5131 5132 /* 5133 * Function: notice_thread 5134 * 5135 * Callback for find_new_threads. 5136 * Calls "add_thread". 5137 */ 5138 5139 static int 5140 procfs_notice_thread (procinfo *pi, procinfo *thread, void *ptr) 5141 { 5142 ptid_t gdb_threadid = MERGEPID (pi->pid, thread->tid); 5143 5144 if (!in_thread_list (gdb_threadid)) 5145 add_thread (gdb_threadid); 5146 5147 return 0; 5148 } 5149 5150 /* 5151 * Function: target_find_new_threads 5152 * 5153 * Query all the threads that the target knows about, 5154 * and give them back to GDB to add to its list. 5155 */ 5156 5157 void 5158 procfs_find_new_threads (void) 5159 { 5160 procinfo *pi; 5161 5162 /* Find procinfo for main process */ 5163 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); 5164 proc_update_threads (pi); 5165 proc_iterate_over_threads (pi, procfs_notice_thread, NULL); 5166 } 5167 5168 /* 5169 * Function: target_thread_alive 5170 * 5171 * Return true if the thread is still 'alive'. 5172 * 5173 * This guy doesn't really seem to be doing his job. 5174 * Got to investigate how to tell when a thread is really gone. 5175 */ 5176 5177 static int 5178 procfs_thread_alive (ptid_t ptid) 5179 { 5180 int proc, thread; 5181 procinfo *pi; 5182 5183 proc = PIDGET (ptid); 5184 thread = TIDGET (ptid); 5185 /* If I don't know it, it ain't alive! */ 5186 if ((pi = find_procinfo (proc, thread)) == NULL) 5187 return 0; 5188 5189 /* If I can't get its status, it ain't alive! 5190 What's more, I need to forget about it! */ 5191 if (!proc_get_status (pi)) 5192 { 5193 destroy_procinfo (pi); 5194 return 0; 5195 } 5196 /* I couldn't have got its status if it weren't alive, so it's alive. */ 5197 return 1; 5198 } 5199 5200 /* Convert PTID to a string. Returns the string in a static buffer. */ 5201 5202 char * 5203 procfs_pid_to_str (ptid_t ptid) 5204 { 5205 static char buf[80]; 5206 5207 if (TIDGET (ptid) == 0) 5208 sprintf (buf, "process %d", PIDGET (ptid)); 5209 else 5210 sprintf (buf, "LWP %ld", TIDGET (ptid)); 5211 5212 return buf; 5213 } 5214 5215 /* 5216 * Function: procfs_set_watchpoint 5217 * Insert a watchpoint 5218 */ 5219 5220 int 5221 procfs_set_watchpoint (ptid_t ptid, CORE_ADDR addr, int len, int rwflag, 5222 int after) 5223 { 5224 #ifndef UNIXWARE 5225 #ifndef AIX5 5226 int pflags = 0; 5227 procinfo *pi; 5228 5229 pi = find_procinfo_or_die (PIDGET (ptid) == -1 ? 5230 PIDGET (inferior_ptid) : PIDGET (ptid), 0); 5231 5232 /* Translate from GDB's flags to /proc's */ 5233 if (len > 0) /* len == 0 means delete watchpoint */ 5234 { 5235 switch (rwflag) { /* FIXME: need an enum! */ 5236 case hw_write: /* default watchpoint (write) */ 5237 pflags = WRITE_WATCHFLAG; 5238 break; 5239 case hw_read: /* read watchpoint */ 5240 pflags = READ_WATCHFLAG; 5241 break; 5242 case hw_access: /* access watchpoint */ 5243 pflags = READ_WATCHFLAG | WRITE_WATCHFLAG; 5244 break; 5245 case hw_execute: /* execution HW breakpoint */ 5246 pflags = EXEC_WATCHFLAG; 5247 break; 5248 default: /* Something weird. Return error. */ 5249 return -1; 5250 } 5251 if (after) /* Stop after r/w access is completed. */ 5252 pflags |= AFTER_WATCHFLAG; 5253 } 5254 5255 if (!proc_set_watchpoint (pi, addr, len, pflags)) 5256 { 5257 if (errno == E2BIG) /* Typical error for no resources */ 5258 return -1; /* fail */ 5259 /* GDB may try to remove the same watchpoint twice. 5260 If a remove request returns no match, don't error. */ 5261 if (errno == ESRCH && len == 0) 5262 return 0; /* ignore */ 5263 proc_error (pi, "set_watchpoint", __LINE__); 5264 } 5265 #endif /* AIX5 */ 5266 #endif /* UNIXWARE */ 5267 return 0; 5268 } 5269 5270 /* Return non-zero if we can set a hardware watchpoint of type TYPE. TYPE 5271 is one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint, 5272 or bp_hardware_watchpoint. CNT is the number of watchpoints used so 5273 far. 5274 5275 Note: procfs_can_use_hw_breakpoint() is not yet used by all 5276 procfs.c targets due to the fact that some of them still define 5277 TARGET_CAN_USE_HARDWARE_WATCHPOINT. */ 5278 5279 static int 5280 procfs_can_use_hw_breakpoint (int type, int cnt, int othertype) 5281 { 5282 #ifndef TARGET_HAS_HARDWARE_WATCHPOINTS 5283 return 0; 5284 #else 5285 /* Due to the way that proc_set_watchpoint() is implemented, host 5286 and target pointers must be of the same size. If they are not, 5287 we can't use hardware watchpoints. This limitation is due to the 5288 fact that proc_set_watchpoint() calls 5289 procfs_address_to_host_pointer(); a close inspection of 5290 procfs_address_to_host_pointer will reveal that an internal error 5291 will be generated when the host and target pointer sizes are 5292 different. */ 5293 if (sizeof (void *) != TYPE_LENGTH (builtin_type_void_data_ptr)) 5294 return 0; 5295 5296 /* Other tests here??? */ 5297 5298 return 1; 5299 #endif 5300 } 5301 5302 /* 5303 * Function: stopped_by_watchpoint 5304 * 5305 * Returns non-zero if process is stopped on a hardware watchpoint fault, 5306 * else returns zero. 5307 */ 5308 5309 int 5310 procfs_stopped_by_watchpoint (ptid_t ptid) 5311 { 5312 procinfo *pi; 5313 5314 pi = find_procinfo_or_die (PIDGET (ptid) == -1 ? 5315 PIDGET (inferior_ptid) : PIDGET (ptid), 0); 5316 5317 if (!pi) /* If no process, then not stopped by watchpoint! */ 5318 return 0; 5319 5320 if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) 5321 { 5322 if (proc_why (pi) == PR_FAULTED) 5323 { 5324 #ifdef FLTWATCH 5325 if (proc_what (pi) == FLTWATCH) 5326 return 1; 5327 #endif 5328 #ifdef FLTKWATCH 5329 if (proc_what (pi) == FLTKWATCH) 5330 return 1; 5331 #endif 5332 } 5333 } 5334 return 0; 5335 } 5336 5337 #ifdef TM_I386SOL2_H 5338 /* 5339 * Function: procfs_find_LDT_entry 5340 * 5341 * Input: 5342 * ptid_t ptid; // The GDB-style pid-plus-LWP. 5343 * 5344 * Return: 5345 * pointer to the corresponding LDT entry. 5346 */ 5347 5348 struct ssd * 5349 procfs_find_LDT_entry (ptid_t ptid) 5350 { 5351 gdb_gregset_t *gregs; 5352 int key; 5353 procinfo *pi; 5354 5355 /* Find procinfo for the lwp. */ 5356 if ((pi = find_procinfo (PIDGET (ptid), TIDGET (ptid))) == NULL) 5357 { 5358 warning ("procfs_find_LDT_entry: could not find procinfo for %d:%d.", 5359 PIDGET (ptid), TIDGET (ptid)); 5360 return NULL; 5361 } 5362 /* get its general registers. */ 5363 if ((gregs = proc_get_gregs (pi)) == NULL) 5364 { 5365 warning ("procfs_find_LDT_entry: could not read gregs for %d:%d.", 5366 PIDGET (ptid), TIDGET (ptid)); 5367 return NULL; 5368 } 5369 /* Now extract the GS register's lower 16 bits. */ 5370 key = (*gregs)[GS] & 0xffff; 5371 5372 /* Find the matching entry and return it. */ 5373 return proc_get_LDT_entry (pi, key); 5374 } 5375 #endif /* TM_I386SOL2_H */ 5376 5377 /* 5378 * Memory Mappings Functions: 5379 */ 5380 5381 /* 5382 * Function: iterate_over_mappings 5383 * 5384 * Call a callback function once for each mapping, passing it the mapping, 5385 * an optional secondary callback function, and some optional opaque data. 5386 * Quit and return the first non-zero value returned from the callback. 5387 * 5388 * Arguments: 5389 * pi -- procinfo struct for the process to be mapped. 5390 * func -- callback function to be called by this iterator. 5391 * data -- optional opaque data to be passed to the callback function. 5392 * child_func -- optional secondary function pointer to be passed 5393 * to the child function. 5394 * 5395 * Return: First non-zero return value from the callback function, 5396 * or zero. 5397 */ 5398 5399 static int 5400 iterate_over_mappings (procinfo *pi, int (*child_func) (), void *data, 5401 int (*func) (struct prmap *map, 5402 int (*child_func) (), 5403 void *data)) 5404 { 5405 char pathname[MAX_PROC_NAME_SIZE]; 5406 struct prmap *prmaps; 5407 struct prmap *prmap; 5408 int funcstat; 5409 int map_fd; 5410 int nmap; 5411 #ifdef NEW_PROC_API 5412 struct stat sbuf; 5413 #endif 5414 5415 /* Get the number of mappings, allocate space, 5416 and read the mappings into prmaps. */ 5417 #ifdef NEW_PROC_API 5418 /* Open map fd. */ 5419 sprintf (pathname, "/proc/%d/map", pi->pid); 5420 if ((map_fd = open (pathname, O_RDONLY)) < 0) 5421 proc_error (pi, "iterate_over_mappings (open)", __LINE__); 5422 5423 /* Make sure it gets closed again. */ 5424 make_cleanup_close (map_fd); 5425 5426 /* Use stat to determine the file size, and compute 5427 the number of prmap_t objects it contains. */ 5428 if (fstat (map_fd, &sbuf) != 0) 5429 proc_error (pi, "iterate_over_mappings (fstat)", __LINE__); 5430 5431 nmap = sbuf.st_size / sizeof (prmap_t); 5432 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps)); 5433 if (read (map_fd, (char *) prmaps, nmap * sizeof (*prmaps)) 5434 != (nmap * sizeof (*prmaps))) 5435 proc_error (pi, "iterate_over_mappings (read)", __LINE__); 5436 #else 5437 /* Use ioctl command PIOCNMAP to get number of mappings. */ 5438 if (ioctl (pi->ctl_fd, PIOCNMAP, &nmap) != 0) 5439 proc_error (pi, "iterate_over_mappings (PIOCNMAP)", __LINE__); 5440 5441 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps)); 5442 if (ioctl (pi->ctl_fd, PIOCMAP, prmaps) != 0) 5443 proc_error (pi, "iterate_over_mappings (PIOCMAP)", __LINE__); 5444 #endif 5445 5446 for (prmap = prmaps; nmap > 0; prmap++, nmap--) 5447 if ((funcstat = (*func) (prmap, child_func, data)) != 0) 5448 return funcstat; 5449 5450 return 0; 5451 } 5452 5453 /* 5454 * Function: solib_mappings_callback 5455 * 5456 * Calls the supplied callback function once for each mapped address 5457 * space in the process. The callback function receives an open 5458 * file descriptor for the file corresponding to that mapped 5459 * address space (if there is one), and the base address of the 5460 * mapped space. Quit when the callback function returns a 5461 * nonzero value, or at teh end of the mappings. 5462 * 5463 * Returns: the first non-zero return value of the callback function, 5464 * or zero. 5465 */ 5466 5467 int solib_mappings_callback (struct prmap *map, 5468 int (*func) (int, CORE_ADDR), 5469 void *data) 5470 { 5471 procinfo *pi = data; 5472 int fd; 5473 5474 #ifdef NEW_PROC_API 5475 char name[MAX_PROC_NAME_SIZE + sizeof (map->pr_mapname)]; 5476 5477 if (map->pr_vaddr == 0 && map->pr_size == 0) 5478 return -1; /* sanity */ 5479 5480 if (map->pr_mapname[0] == 0) 5481 { 5482 fd = -1; /* no map file */ 5483 } 5484 else 5485 { 5486 sprintf (name, "/proc/%d/object/%s", pi->pid, map->pr_mapname); 5487 /* Note: caller's responsibility to close this fd! */ 5488 fd = open_with_retry (name, O_RDONLY); 5489 /* Note: we don't test the above call for failure; 5490 we just pass the FD on as given. Sometimes there is 5491 no file, so the open may return failure, but that's 5492 not a problem. */ 5493 } 5494 #else 5495 fd = ioctl (pi->ctl_fd, PIOCOPENM, &map->pr_vaddr); 5496 /* Note: we don't test the above call for failure; 5497 we just pass the FD on as given. Sometimes there is 5498 no file, so the ioctl may return failure, but that's 5499 not a problem. */ 5500 #endif 5501 return (*func) (fd, (CORE_ADDR) map->pr_vaddr); 5502 } 5503 5504 /* 5505 * Function: proc_iterate_over_mappings 5506 * 5507 * Uses the unified "iterate_over_mappings" function 5508 * to implement the exported interface to solib-svr4.c. 5509 * 5510 * Given a pointer to a function, call that function once for every 5511 * mapped address space in the process. The callback function 5512 * receives an open file descriptor for the file corresponding to 5513 * that mapped address space (if there is one), and the base address 5514 * of the mapped space. Quit when the callback function returns a 5515 * nonzero value, or at teh end of the mappings. 5516 * 5517 * Returns: the first non-zero return value of the callback function, 5518 * or zero. 5519 */ 5520 5521 int 5522 proc_iterate_over_mappings (int (*func) (int, CORE_ADDR)) 5523 { 5524 procinfo *pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); 5525 5526 return iterate_over_mappings (pi, func, pi, solib_mappings_callback); 5527 } 5528 5529 /* 5530 * Function: find_memory_regions_callback 5531 * 5532 * Implements the to_find_memory_regions method. 5533 * Calls an external function for each memory region. 5534 * External function will have the signiture: 5535 * 5536 * int callback (CORE_ADDR vaddr, 5537 * unsigned long size, 5538 * int read, int write, int execute, 5539 * void *data); 5540 * 5541 * Returns the integer value returned by the callback. 5542 */ 5543 5544 static int 5545 find_memory_regions_callback (struct prmap *map, 5546 int (*func) (CORE_ADDR, 5547 unsigned long, 5548 int, int, int, 5549 void *), 5550 void *data) 5551 { 5552 return (*func) ((CORE_ADDR) map->pr_vaddr, 5553 map->pr_size, 5554 (map->pr_mflags & MA_READ) != 0, 5555 (map->pr_mflags & MA_WRITE) != 0, 5556 (map->pr_mflags & MA_EXEC) != 0, 5557 data); 5558 } 5559 5560 /* 5561 * Function: proc_find_memory_regions 5562 * 5563 * External interface. Calls a callback function once for each 5564 * mapped memory region in the child process, passing as arguments 5565 * CORE_ADDR virtual_address, 5566 * unsigned long size, 5567 * int read, TRUE if region is readable by the child 5568 * int write, TRUE if region is writable by the child 5569 * int execute TRUE if region is executable by the child. 5570 * 5571 * Stops iterating and returns the first non-zero value 5572 * returned by the callback. 5573 */ 5574 5575 static int 5576 proc_find_memory_regions (int (*func) (CORE_ADDR, 5577 unsigned long, 5578 int, int, int, 5579 void *), 5580 void *data) 5581 { 5582 procinfo *pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); 5583 5584 return iterate_over_mappings (pi, func, data, 5585 find_memory_regions_callback); 5586 } 5587 5588 /* Remove the breakpoint that we inserted in __dbx_link(). 5589 Does nothing if the breakpoint hasn't been inserted or has already 5590 been removed. */ 5591 5592 static void 5593 remove_dbx_link_breakpoint (void) 5594 { 5595 if (dbx_link_bpt_addr == 0) 5596 return; 5597 5598 if (memory_remove_breakpoint (dbx_link_bpt_addr, 5599 dbx_link_shadow_contents) != 0) 5600 warning ("Unable to remove __dbx_link breakpoint."); 5601 5602 dbx_link_bpt_addr = 0; 5603 } 5604 5605 /* Return the address of the __dbx_link() function in the file 5606 refernced by ABFD by scanning its symbol table. Return 0 if 5607 the symbol was not found. */ 5608 5609 static CORE_ADDR 5610 dbx_link_addr (bfd *abfd) 5611 { 5612 long storage_needed; 5613 asymbol **symbol_table; 5614 long number_of_symbols; 5615 long i; 5616 5617 storage_needed = bfd_get_symtab_upper_bound (abfd); 5618 if (storage_needed <= 0) 5619 return 0; 5620 5621 symbol_table = (asymbol **) xmalloc (storage_needed); 5622 make_cleanup (xfree, symbol_table); 5623 5624 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); 5625 5626 for (i = 0; i < number_of_symbols; i++) 5627 { 5628 asymbol *sym = symbol_table[i]; 5629 5630 if ((sym->flags & BSF_GLOBAL) 5631 && sym->name != NULL && strcmp (sym->name, "__dbx_link") == 0) 5632 return (sym->value + sym->section->vma); 5633 } 5634 5635 /* Symbol not found, return NULL. */ 5636 return 0; 5637 } 5638 5639 /* Search the symbol table of the file referenced by FD for a symbol 5640 named __dbx_link(). If found, then insert a breakpoint at this location, 5641 and return nonzero. Return zero otherwise. */ 5642 5643 static int 5644 insert_dbx_link_bpt_in_file (int fd, CORE_ADDR ignored) 5645 { 5646 bfd *abfd; 5647 long storage_needed; 5648 CORE_ADDR sym_addr; 5649 5650 abfd = bfd_fdopenr ("unamed", 0, fd); 5651 if (abfd == NULL) 5652 { 5653 warning ("Failed to create a bfd: %s.\n", bfd_errmsg (bfd_get_error ())); 5654 return 0; 5655 } 5656 5657 if (!bfd_check_format (abfd, bfd_object)) 5658 { 5659 /* Not the correct format, so we can not possibly find the dbx_link 5660 symbol in it. */ 5661 bfd_close (abfd); 5662 return 0; 5663 } 5664 5665 sym_addr = dbx_link_addr (abfd); 5666 if (sym_addr != 0) 5667 { 5668 /* Insert the breakpoint. */ 5669 dbx_link_bpt_addr = sym_addr; 5670 if (target_insert_breakpoint (sym_addr, dbx_link_shadow_contents) != 0) 5671 { 5672 warning ("Failed to insert dbx_link breakpoint."); 5673 bfd_close (abfd); 5674 return 0; 5675 } 5676 bfd_close (abfd); 5677 return 1; 5678 } 5679 5680 bfd_close (abfd); 5681 return 0; 5682 } 5683 5684 /* If the given memory region MAP contains a symbol named __dbx_link, 5685 insert a breakpoint at this location and return nonzero. Return 5686 zero otherwise. */ 5687 5688 static int 5689 insert_dbx_link_bpt_in_region (struct prmap *map, 5690 int (*child_func) (), 5691 void *data) 5692 { 5693 procinfo *pi = (procinfo *) data; 5694 5695 /* We know the symbol we're looking for is in a text region, so 5696 only look for it if the region is a text one. */ 5697 if (map->pr_mflags & MA_EXEC) 5698 return solib_mappings_callback (map, insert_dbx_link_bpt_in_file, pi); 5699 5700 return 0; 5701 } 5702 5703 /* Search all memory regions for a symbol named __dbx_link. If found, 5704 insert a breakpoint at its location, and return nonzero. Return zero 5705 otherwise. */ 5706 5707 static int 5708 insert_dbx_link_breakpoint (procinfo *pi) 5709 { 5710 return iterate_over_mappings (pi, NULL, pi, insert_dbx_link_bpt_in_region); 5711 } 5712 5713 /* 5714 * Function: mappingflags 5715 * 5716 * Returns an ascii representation of a memory mapping's flags. 5717 */ 5718 5719 static char * 5720 mappingflags (long flags) 5721 { 5722 static char asciiflags[8]; 5723 5724 strcpy (asciiflags, "-------"); 5725 #if defined (MA_PHYS) 5726 if (flags & MA_PHYS) 5727 asciiflags[0] = 'd'; 5728 #endif 5729 if (flags & MA_STACK) 5730 asciiflags[1] = 's'; 5731 if (flags & MA_BREAK) 5732 asciiflags[2] = 'b'; 5733 if (flags & MA_SHARED) 5734 asciiflags[3] = 's'; 5735 if (flags & MA_READ) 5736 asciiflags[4] = 'r'; 5737 if (flags & MA_WRITE) 5738 asciiflags[5] = 'w'; 5739 if (flags & MA_EXEC) 5740 asciiflags[6] = 'x'; 5741 return (asciiflags); 5742 } 5743 5744 /* 5745 * Function: info_mappings_callback 5746 * 5747 * Callback function, does the actual work for 'info proc mappings'. 5748 */ 5749 5750 static int 5751 info_mappings_callback (struct prmap *map, int (*ignore) (), void *unused) 5752 { 5753 char *data_fmt_string; 5754 5755 if (TARGET_ADDR_BIT == 32) 5756 data_fmt_string = "\t%#10lx %#10lx %#10x %#10x %7s\n"; 5757 else 5758 data_fmt_string = " %#18lx %#18lx %#10x %#10x %7s\n"; 5759 5760 printf_filtered (data_fmt_string, 5761 (unsigned long) map->pr_vaddr, 5762 (unsigned long) map->pr_vaddr + map->pr_size - 1, 5763 map->pr_size, 5764 #ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */ 5765 (unsigned int) map->pr_offset, 5766 #else 5767 map->pr_off, 5768 #endif 5769 mappingflags (map->pr_mflags)); 5770 5771 return 0; 5772 } 5773 5774 /* 5775 * Function: info_proc_mappings 5776 * 5777 * Implement the "info proc mappings" subcommand. 5778 */ 5779 5780 static void 5781 info_proc_mappings (procinfo *pi, int summary) 5782 { 5783 char *header_fmt_string; 5784 5785 if (TARGET_PTR_BIT == 32) 5786 header_fmt_string = "\t%10s %10s %10s %10s %7s\n"; 5787 else 5788 header_fmt_string = " %18s %18s %10s %10s %7s\n"; 5789 5790 if (summary) 5791 return; /* No output for summary mode. */ 5792 5793 printf_filtered ("Mapped address spaces:\n\n"); 5794 printf_filtered (header_fmt_string, 5795 "Start Addr", 5796 " End Addr", 5797 " Size", 5798 " Offset", 5799 "Flags"); 5800 5801 iterate_over_mappings (pi, NULL, NULL, info_mappings_callback); 5802 printf_filtered ("\n"); 5803 } 5804 5805 /* 5806 * Function: info_proc_cmd 5807 * 5808 * Implement the "info proc" command. 5809 */ 5810 5811 static void 5812 info_proc_cmd (char *args, int from_tty) 5813 { 5814 struct cleanup *old_chain; 5815 procinfo *process = NULL; 5816 procinfo *thread = NULL; 5817 char **argv = NULL; 5818 char *tmp = NULL; 5819 int pid = 0; 5820 int tid = 0; 5821 int mappings = 0; 5822 5823 old_chain = make_cleanup (null_cleanup, 0); 5824 if (args) 5825 { 5826 if ((argv = buildargv (args)) == NULL) 5827 nomem (0); 5828 else 5829 make_cleanup_freeargv (argv); 5830 } 5831 while (argv != NULL && *argv != NULL) 5832 { 5833 if (isdigit (argv[0][0])) 5834 { 5835 pid = strtoul (argv[0], &tmp, 10); 5836 if (*tmp == '/') 5837 tid = strtoul (++tmp, NULL, 10); 5838 } 5839 else if (argv[0][0] == '/') 5840 { 5841 tid = strtoul (argv[0] + 1, NULL, 10); 5842 } 5843 else if (strncmp (argv[0], "mappings", strlen (argv[0])) == 0) 5844 { 5845 mappings = 1; 5846 } 5847 else 5848 { 5849 /* [...] */ 5850 } 5851 argv++; 5852 } 5853 if (pid == 0) 5854 pid = PIDGET (inferior_ptid); 5855 if (pid == 0) 5856 error ("No current process: you must name one."); 5857 else 5858 { 5859 /* Have pid, will travel. 5860 First see if it's a process we're already debugging. */ 5861 process = find_procinfo (pid, 0); 5862 if (process == NULL) 5863 { 5864 /* No. So open a procinfo for it, but 5865 remember to close it again when finished. */ 5866 process = create_procinfo (pid, 0); 5867 make_cleanup (do_destroy_procinfo_cleanup, process); 5868 if (!open_procinfo_files (process, FD_CTL)) 5869 proc_error (process, "info proc, open_procinfo_files", __LINE__); 5870 } 5871 } 5872 if (tid != 0) 5873 thread = create_procinfo (pid, tid); 5874 5875 if (process) 5876 { 5877 printf_filtered ("process %d flags:\n", process->pid); 5878 proc_prettyprint_flags (proc_flags (process), 1); 5879 if (proc_flags (process) & (PR_STOPPED | PR_ISTOP)) 5880 proc_prettyprint_why (proc_why (process), proc_what (process), 1); 5881 if (proc_get_nthreads (process) > 1) 5882 printf_filtered ("Process has %d threads.\n", 5883 proc_get_nthreads (process)); 5884 } 5885 if (thread) 5886 { 5887 printf_filtered ("thread %d flags:\n", thread->tid); 5888 proc_prettyprint_flags (proc_flags (thread), 1); 5889 if (proc_flags (thread) & (PR_STOPPED | PR_ISTOP)) 5890 proc_prettyprint_why (proc_why (thread), proc_what (thread), 1); 5891 } 5892 5893 if (mappings) 5894 { 5895 info_proc_mappings (process, 0); 5896 } 5897 5898 do_cleanups (old_chain); 5899 } 5900 5901 /* Modify the status of the system call identified by SYSCALLNUM in 5902 the set of syscalls that are currently traced/debugged. 5903 5904 If ENTRY_OR_EXIT is set to PR_SYSENTRY, then the entry syscalls set 5905 will be updated. Otherwise, the exit syscalls set will be updated. 5906 5907 If MODE is FLAG_SET, then traces will be enabled. Otherwise, they 5908 will be disabled. */ 5909 5910 static void 5911 proc_trace_syscalls_1 (procinfo *pi, int syscallnum, int entry_or_exit, 5912 int mode, int from_tty) 5913 { 5914 sysset_t *sysset; 5915 5916 if (entry_or_exit == PR_SYSENTRY) 5917 sysset = proc_get_traced_sysentry (pi, NULL); 5918 else 5919 sysset = proc_get_traced_sysexit (pi, NULL); 5920 5921 if (sysset == NULL) 5922 proc_error (pi, "proc-trace, get_traced_sysset", __LINE__); 5923 5924 if (mode == FLAG_SET) 5925 gdb_praddsysset (sysset, syscallnum); 5926 else 5927 gdb_prdelsysset (sysset, syscallnum); 5928 5929 if (entry_or_exit == PR_SYSENTRY) 5930 { 5931 if (!proc_set_traced_sysentry (pi, sysset)) 5932 proc_error (pi, "proc-trace, set_traced_sysentry", __LINE__); 5933 } 5934 else 5935 { 5936 if (!proc_set_traced_sysexit (pi, sysset)) 5937 proc_error (pi, "proc-trace, set_traced_sysexit", __LINE__); 5938 } 5939 } 5940 5941 static void 5942 proc_trace_syscalls (char *args, int from_tty, int entry_or_exit, int mode) 5943 { 5944 procinfo *pi; 5945 5946 if (PIDGET (inferior_ptid) <= 0) 5947 error ("you must be debugging a process to use this command."); 5948 5949 if (args == NULL || args[0] == 0) 5950 error_no_arg ("system call to trace"); 5951 5952 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); 5953 if (isdigit (args[0])) 5954 { 5955 const int syscallnum = atoi (args); 5956 5957 proc_trace_syscalls_1 (pi, syscallnum, entry_or_exit, mode, from_tty); 5958 } 5959 } 5960 5961 static void 5962 proc_trace_sysentry_cmd (char *args, int from_tty) 5963 { 5964 proc_trace_syscalls (args, from_tty, PR_SYSENTRY, FLAG_SET); 5965 } 5966 5967 static void 5968 proc_trace_sysexit_cmd (char *args, int from_tty) 5969 { 5970 proc_trace_syscalls (args, from_tty, PR_SYSEXIT, FLAG_SET); 5971 } 5972 5973 static void 5974 proc_untrace_sysentry_cmd (char *args, int from_tty) 5975 { 5976 proc_trace_syscalls (args, from_tty, PR_SYSENTRY, FLAG_RESET); 5977 } 5978 5979 static void 5980 proc_untrace_sysexit_cmd (char *args, int from_tty) 5981 { 5982 proc_trace_syscalls (args, from_tty, PR_SYSEXIT, FLAG_RESET); 5983 } 5984 5985 5986 void 5987 _initialize_procfs (void) 5988 { 5989 init_procfs_ops (); 5990 add_target (&procfs_ops); 5991 add_info ("proc", info_proc_cmd, 5992 "Show /proc process information about any running process.\n\ 5993 Specify process id, or use the program being debugged by default.\n\ 5994 Specify keyword 'mappings' for detailed info on memory mappings."); 5995 add_com ("proc-trace-entry", no_class, proc_trace_sysentry_cmd, 5996 "Give a trace of entries into the syscall."); 5997 add_com ("proc-trace-exit", no_class, proc_trace_sysexit_cmd, 5998 "Give a trace of exits from the syscall."); 5999 add_com ("proc-untrace-entry", no_class, proc_untrace_sysentry_cmd, 6000 "Cancel a trace of entries into the syscall."); 6001 add_com ("proc-untrace-exit", no_class, proc_untrace_sysexit_cmd, 6002 "Cancel a trace of exits from the syscall."); 6003 } 6004 6005 /* =================== END, GDB "MODULE" =================== */ 6006 6007 6008 6009 /* miscellaneous stubs: */ 6010 /* The following satisfy a few random symbols mostly created by */ 6011 /* the solaris threads implementation, which I will chase down */ 6012 /* later. */ 6013 6014 /* 6015 * Return a pid for which we guarantee 6016 * we will be able to find a 'live' procinfo. 6017 */ 6018 6019 ptid_t 6020 procfs_first_available (void) 6021 { 6022 return pid_to_ptid (procinfo_list ? procinfo_list->pid : -1); 6023 } 6024 6025 /* =================== GCORE .NOTE "MODULE" =================== */ 6026 #if defined (UNIXWARE) || defined (PIOCOPENLWP) || defined (PCAGENT) 6027 /* gcore only implemented on solaris and unixware (so far) */ 6028 6029 static char * 6030 procfs_do_thread_registers (bfd *obfd, ptid_t ptid, 6031 char *note_data, int *note_size) 6032 { 6033 gdb_gregset_t gregs; 6034 gdb_fpregset_t fpregs; 6035 unsigned long merged_pid; 6036 6037 merged_pid = TIDGET (ptid) << 16 | PIDGET (ptid); 6038 6039 fill_gregset (&gregs, -1); 6040 #if defined (UNIXWARE) 6041 note_data = (char *) elfcore_write_lwpstatus (obfd, 6042 note_data, 6043 note_size, 6044 merged_pid, 6045 stop_signal, 6046 &gregs); 6047 #else 6048 note_data = (char *) elfcore_write_prstatus (obfd, 6049 note_data, 6050 note_size, 6051 merged_pid, 6052 stop_signal, 6053 &gregs); 6054 #endif 6055 fill_fpregset (&fpregs, -1); 6056 note_data = (char *) elfcore_write_prfpreg (obfd, 6057 note_data, 6058 note_size, 6059 &fpregs, 6060 sizeof (fpregs)); 6061 return note_data; 6062 } 6063 6064 struct procfs_corefile_thread_data { 6065 bfd *obfd; 6066 char *note_data; 6067 int *note_size; 6068 }; 6069 6070 static int 6071 procfs_corefile_thread_callback (procinfo *pi, procinfo *thread, void *data) 6072 { 6073 struct procfs_corefile_thread_data *args = data; 6074 6075 if (pi != NULL && thread->tid != 0) 6076 { 6077 ptid_t saved_ptid = inferior_ptid; 6078 inferior_ptid = MERGEPID (pi->pid, thread->tid); 6079 args->note_data = procfs_do_thread_registers (args->obfd, inferior_ptid, 6080 args->note_data, 6081 args->note_size); 6082 inferior_ptid = saved_ptid; 6083 } 6084 return 0; 6085 } 6086 6087 static char * 6088 procfs_make_note_section (bfd *obfd, int *note_size) 6089 { 6090 struct cleanup *old_chain; 6091 gdb_gregset_t gregs; 6092 gdb_fpregset_t fpregs; 6093 char fname[16] = {'\0'}; 6094 char psargs[80] = {'\0'}; 6095 procinfo *pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); 6096 char *note_data = NULL; 6097 char *inf_args; 6098 struct procfs_corefile_thread_data thread_args; 6099 char *auxv; 6100 int auxv_len; 6101 6102 if (get_exec_file (0)) 6103 { 6104 strncpy (fname, strrchr (get_exec_file (0), '/') + 1, sizeof (fname)); 6105 strncpy (psargs, get_exec_file (0), 6106 sizeof (psargs)); 6107 6108 inf_args = get_inferior_args (); 6109 if (inf_args && *inf_args && 6110 strlen (inf_args) < ((int) sizeof (psargs) - (int) strlen (psargs))) 6111 { 6112 strncat (psargs, " ", 6113 sizeof (psargs) - strlen (psargs)); 6114 strncat (psargs, inf_args, 6115 sizeof (psargs) - strlen (psargs)); 6116 } 6117 } 6118 6119 note_data = (char *) elfcore_write_prpsinfo (obfd, 6120 note_data, 6121 note_size, 6122 fname, 6123 psargs); 6124 6125 #ifdef UNIXWARE 6126 fill_gregset (&gregs, -1); 6127 note_data = elfcore_write_pstatus (obfd, note_data, note_size, 6128 PIDGET (inferior_ptid), 6129 stop_signal, &gregs); 6130 #endif 6131 6132 thread_args.obfd = obfd; 6133 thread_args.note_data = note_data; 6134 thread_args.note_size = note_size; 6135 proc_iterate_over_threads (pi, procfs_corefile_thread_callback, &thread_args); 6136 6137 if (thread_args.note_data == note_data) 6138 { 6139 /* iterate_over_threads didn't come up with any threads; 6140 just use inferior_ptid. */ 6141 note_data = procfs_do_thread_registers (obfd, inferior_ptid, 6142 note_data, note_size); 6143 } 6144 else 6145 { 6146 note_data = thread_args.note_data; 6147 } 6148 6149 auxv_len = target_auxv_read (¤t_target, &auxv); 6150 if (auxv_len > 0) 6151 { 6152 note_data = elfcore_write_note (obfd, note_data, note_size, 6153 "CORE", NT_AUXV, auxv, auxv_len); 6154 xfree (auxv); 6155 } 6156 6157 make_cleanup (xfree, note_data); 6158 return note_data; 6159 } 6160 #else /* !(Solaris or Unixware) */ 6161 static char * 6162 procfs_make_note_section (bfd *obfd, int *note_size) 6163 { 6164 error ("gcore not implemented for this host."); 6165 return NULL; /* lint */ 6166 } 6167 #endif /* Solaris or Unixware */ 6168 /* =================== END GCORE .NOTE "MODULE" =================== */ 6169