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