]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - gdb/procfs.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* procfs.c (proc_set_exec_trap, procfs_init_inferior, procfs_wait,
[thirdparty/binutils-gdb.git] / gdb / procfs.c
1 /* Machine independent support for SVR4 /proc (process file system) for GDB.
2 Copyright 1991, 1992-96, 1997 Free Software Foundation, Inc.
3 Written by Fred Fish at Cygnus Support. Changes for sysv4.2mp procfs
4 compatibility by Geoffrey Noer at Cygnus Solutions.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21
22
23 /* N O T E S
24
25 For information on the details of using /proc consult section proc(4)
26 in the UNIX System V Release 4 System Administrator's Reference Manual.
27
28 The general register and floating point register sets are manipulated
29 separately. This file makes the assumption that if FP0_REGNUM is
30 defined, then support for the floating point register set is desired,
31 regardless of whether or not the actual target has floating point hardware.
32
33 */
34
35
36 #include "defs.h"
37
38 #include <sys/types.h>
39 #include <time.h>
40 #include <sys/fault.h>
41 #include <sys/syscall.h>
42 #include <sys/procfs.h>
43 #include <fcntl.h>
44 #include <errno.h>
45 #include "gdb_string.h"
46 #include <stropts.h>
47 #include <poll.h>
48 #include <unistd.h>
49 #include "gdb_stat.h"
50
51 #include "inferior.h"
52 #include "target.h"
53 #include "command.h"
54 #include "gdbcore.h"
55 #include "gdbthread.h"
56
57 /* the name of the proc status struct depends on the implementation */
58 #ifdef HAVE_PSTATUS_T
59 typedef pstatus_t gdb_prstatus_t;
60 #else
61 typedef prstatus_t gdb_prstatus_t;
62 #endif
63
64 #define MAX_SYSCALLS 256 /* Maximum number of syscalls for table */
65
66 /* proc name formats may vary depending on the proc implementation */
67 #ifdef HAVE_MULTIPLE_PROC_FDS
68 # ifndef CTL_PROC_NAME_FMT
69 # define CTL_PROC_NAME_FMT "/proc/%d/ctl"
70 # define AS_PROC_NAME_FMT "/proc/%d/as"
71 # define MAP_PROC_NAME_FMT "/proc/%d/map"
72 # define STATUS_PROC_NAME_FMT "/proc/%d/status"
73 # endif
74 #else /* HAVE_MULTIPLE_PROC_FDS */
75 # ifndef CTL_PROC_NAME_FMT
76 # define CTL_PROC_NAME_FMT "/proc/%05d"
77 # define AS_PROC_NAME_FMT "/proc/%05d"
78 # define MAP_PROC_NAME_FMT "/proc/%05d"
79 # define STATUS_PROC_NAME_FMT "/proc/%05d"
80 # endif
81 #endif /* HAVE_MULTIPLE_PROC_FDS */
82
83 #define MAX_PROC_NAME_SIZE sizeof("/proc/1234567890/status")
84
85 extern struct target_ops procfs_ops; /* Forward declaration */
86
87 int procfs_suppress_run = 0; /* Non-zero if procfs should pretend not to
88 be a runnable target. Used by targets
89 that can sit atop procfs, such as solaris
90 thread support. */
91
92 #if 1 /* FIXME: Gross and ugly hack to resolve coredep.c global */
93 CORE_ADDR kernel_u_addr;
94 #endif
95
96 #ifdef BROKEN_SIGINFO_H /* Workaround broken SGS <sys/siginfo.h> */
97 #undef si_pid
98 #define si_pid _data._proc.pid
99 #undef si_uid
100 #define si_uid _data._proc._pdata._kill.uid
101 #endif /* BROKEN_SIGINFO_H */
102
103 /* Define structures for passing commands to /proc/pid/ctl file. Note that
104 while we create these for the PROCFS_USE_READ_WRITE world, we use them
105 and ignore the extra cmd int in other proc schemes.
106 */
107 /* generic ctl msg */
108 struct proc_ctl {
109 int cmd;
110 long data;
111 };
112
113 /* set general registers */
114 struct greg_ctl {
115 int cmd;
116 gregset_t gregset;
117 };
118
119 /* set fp registers */
120 struct fpreg_ctl {
121 int cmd;
122 fpregset_t fpregset;
123 };
124
125 /* set signals to be traced */
126 struct sig_ctl {
127 int cmd;
128 sigset_t sigset;
129 };
130
131 /* set faults to be traced */
132 struct flt_ctl {
133 int cmd;
134 fltset_t fltset;
135 };
136
137 /* set system calls to be traced */
138 struct sys_ctl {
139 int cmd;
140 sysset_t sysset;
141 };
142
143 /* set current signal to be traced */
144 struct sigi_ctl {
145 int cmd;
146 siginfo_t siginfo;
147 };
148
149 /* All access to the inferior, either one started by gdb or one that has
150 been attached to, is controlled by an instance of a procinfo structure,
151 defined below. Since gdb currently only handles one inferior at a time,
152 the procinfo structure for the inferior is statically allocated and
153 only one exists at any given time. There is a separate procinfo
154 structure for use by the "info proc" command, so that we can print
155 useful information about any random process without interfering with
156 the inferior's procinfo information. */
157
158 struct procinfo {
159 struct procinfo *next;
160 int pid; /* Process ID of inferior */
161 int ctl_fd; /* File descriptor for /proc ctl file */
162 int status_fd; /* File descriptor for /proc status file */
163 int as_fd; /* File descriptor for /proc as file */
164 int map_fd; /* File descriptor for /proc map file */
165 char *pathname; /* Pathname to /proc entry */
166 int had_event; /* poll/select says something happened */
167 int was_stopped; /* Nonzero if was stopped prior to attach */
168 int nopass_next_sigstop; /* Don't pass a sigstop on next resume */
169 #ifndef HAVE_NO_PRRUN_T
170 prrun_t prrun; /* Control state when it is run */
171 #endif
172 gdb_prstatus_t prstatus; /* Current process status info */
173 struct greg_ctl gregset; /* General register set */
174 struct fpreg_ctl fpregset; /* Floating point register set */
175 struct flt_ctl fltset; /* Current traced hardware fault set */
176 struct sig_ctl trace; /* Current traced signal set */
177 struct sys_ctl exitset; /* Current traced system call exit set */
178 struct sys_ctl entryset; /* Current traced system call entry set */
179 struct sig_ctl saved_sighold; /* Saved held signal set */
180 struct flt_ctl saved_fltset; /* Saved traced hardware fault set */
181 struct sig_ctl saved_trace; /* Saved traced signal set */
182 struct sys_ctl saved_exitset; /* Saved traced system call exit set */
183 struct sys_ctl saved_entryset;/* Saved traced system call entry set */
184 int num_syscall_handlers; /* Number of syscall trap handlers
185 currently installed */
186 /* Pointer to list of syscall trap handlers */
187 struct procfs_syscall_handler *syscall_handlers;
188 int new_child; /* Non-zero if it's a new thread */
189 };
190
191 /* List of inferior process information */
192 static struct procinfo *procinfo_list = NULL;
193 static struct pollfd *poll_list; /* pollfds used for waiting on /proc */
194
195 static int num_poll_list = 0; /* Number of entries in poll_list */
196
197 /* Much of the information used in the /proc interface, particularly for
198 printing status information, is kept as tables of structures of the
199 following form. These tables can be used to map numeric values to
200 their symbolic names and to a string that describes their specific use. */
201
202 struct trans {
203 int value; /* The numeric value */
204 char *name; /* The equivalent symbolic value */
205 char *desc; /* Short description of value */
206 };
207
208 /* Translate bits in the pr_flags member of the prstatus structure, into the
209 names and desc information. */
210
211 static struct trans pr_flag_table[] =
212 {
213 #if defined (PR_STOPPED)
214 { PR_STOPPED, "PR_STOPPED", "Process is stopped" },
215 #endif
216 #if defined (PR_ISTOP)
217 { PR_ISTOP, "PR_ISTOP", "Stopped on an event of interest" },
218 #endif
219 #if defined (PR_DSTOP)
220 { PR_DSTOP, "PR_DSTOP", "A stop directive is in effect" },
221 #endif
222 #if defined (PR_ASLEEP)
223 { PR_ASLEEP, "PR_ASLEEP", "Sleeping in an interruptible system call" },
224 #endif
225 #if defined (PR_FORK)
226 { PR_FORK, "PR_FORK", "Inherit-on-fork is in effect" },
227 #endif
228 #if defined (PR_RLC)
229 { PR_RLC, "PR_RLC", "Run-on-last-close is in effect" },
230 #endif
231 #if defined (PR_PTRACE)
232 { PR_PTRACE, "PR_PTRACE", "Process is being controlled by ptrace" },
233 #endif
234 #if defined (PR_PCINVAL)
235 { PR_PCINVAL, "PR_PCINVAL", "PC refers to an invalid virtual address" },
236 #endif
237 #if defined (PR_ISSYS)
238 { PR_ISSYS, "PR_ISSYS", "Is a system process" },
239 #endif
240 #if defined (PR_STEP)
241 { PR_STEP, "PR_STEP", "Process has single step pending" },
242 #endif
243 #if defined (PR_KLC)
244 { PR_KLC, "PR_KLC", "Kill-on-last-close is in effect" },
245 #endif
246 #if defined (PR_ASYNC)
247 { PR_ASYNC, "PR_ASYNC", "Asynchronous stop is in effect" },
248 #endif
249 #if defined (PR_PCOMPAT)
250 { PR_PCOMPAT, "PR_PCOMPAT", "Ptrace compatibility mode in effect" },
251 #endif
252 #if defined (PR_MSACCT)
253 { PR_MSACCT, "PR_MSACCT", "Microstate accounting enabled" },
254 #endif
255 #if defined (PR_BPTADJ)
256 { PR_BPTADJ, "PR_BPTADJ", "Breakpoint PC adjustment in effect" },
257 #endif
258 #if defined (PR_ASLWP)
259 { PR_ASLWP, "PR_ASLWP", "Asynchronus signal LWP" },
260 #endif
261 { 0, NULL, NULL }
262 };
263
264 /* Translate values in the pr_why field of the prstatus struct. */
265
266 static struct trans pr_why_table[] =
267 {
268 #if defined (PR_REQUESTED)
269 { PR_REQUESTED, "PR_REQUESTED", "Directed to stop via PIOCSTOP/PIOCWSTOP" },
270 #endif
271 #if defined (PR_SIGNALLED)
272 { PR_SIGNALLED, "PR_SIGNALLED", "Receipt of a traced signal" },
273 #endif
274 #if defined (PR_SYSENTRY)
275 { PR_SYSENTRY, "PR_SYSENTRY", "Entry to a traced system call" },
276 #endif
277 #if defined (PR_SYSEXIT)
278 { PR_SYSEXIT, "PR_SYSEXIT", "Exit from a traced system call" },
279 #endif
280 #if defined (PR_JOBCONTROL)
281 { PR_JOBCONTROL, "PR_JOBCONTROL", "Default job control stop signal action" },
282 #endif
283 #if defined (PR_FAULTED)
284 { PR_FAULTED, "PR_FAULTED", "Incurred a traced hardware fault" },
285 #endif
286 #if defined (PR_SUSPENDED)
287 { PR_SUSPENDED, "PR_SUSPENDED", "Process suspended" },
288 #endif
289 #if defined (PR_CHECKPOINT)
290 { PR_CHECKPOINT, "PR_CHECKPOINT", "(???)" },
291 #endif
292 { 0, NULL, NULL }
293 };
294
295 /* Hardware fault translation table. */
296
297 static struct trans faults_table[] =
298 {
299 #if defined (FLTILL)
300 { FLTILL, "FLTILL", "Illegal instruction" },
301 #endif
302 #if defined (FLTPRIV)
303 { FLTPRIV, "FLTPRIV", "Privileged instruction" },
304 #endif
305 #if defined (FLTBPT)
306 { FLTBPT, "FLTBPT", "Breakpoint trap" },
307 #endif
308 #if defined (FLTTRACE)
309 { FLTTRACE, "FLTTRACE", "Trace trap" },
310 #endif
311 #if defined (FLTACCESS)
312 { FLTACCESS, "FLTACCESS", "Memory access fault" },
313 #endif
314 #if defined (FLTBOUNDS)
315 { FLTBOUNDS, "FLTBOUNDS", "Memory bounds violation" },
316 #endif
317 #if defined (FLTIOVF)
318 { FLTIOVF, "FLTIOVF", "Integer overflow" },
319 #endif
320 #if defined (FLTIZDIV)
321 { FLTIZDIV, "FLTIZDIV", "Integer zero divide" },
322 #endif
323 #if defined (FLTFPE)
324 { FLTFPE, "FLTFPE", "Floating-point exception" },
325 #endif
326 #if defined (FLTSTACK)
327 { FLTSTACK, "FLTSTACK", "Unrecoverable stack fault" },
328 #endif
329 #if defined (FLTPAGE)
330 { FLTPAGE, "FLTPAGE", "Recoverable page fault" },
331 #endif
332 { 0, NULL, NULL }
333 };
334
335 /* Translation table for signal generation information. See UNIX System
336 V Release 4 Programmer's Reference Manual, siginfo(5). */
337
338 static struct sigcode {
339 int signo;
340 int code;
341 char *codename;
342 char *desc;
343 } siginfo_table[] = {
344 #if defined (SIGILL) && defined (ILL_ILLOPC)
345 { SIGILL, ILL_ILLOPC, "ILL_ILLOPC", "Illegal opcode" },
346 #endif
347 #if defined (SIGILL) && defined (ILL_ILLOPN)
348 { SIGILL, ILL_ILLOPN, "ILL_ILLOPN", "Illegal operand", },
349 #endif
350 #if defined (SIGILL) && defined (ILL_ILLADR)
351 { SIGILL, ILL_ILLADR, "ILL_ILLADR", "Illegal addressing mode" },
352 #endif
353 #if defined (SIGILL) && defined (ILL_ILLTRP)
354 { SIGILL, ILL_ILLTRP, "ILL_ILLTRP", "Illegal trap" },
355 #endif
356 #if defined (SIGILL) && defined (ILL_PRVOPC)
357 { SIGILL, ILL_PRVOPC, "ILL_PRVOPC", "Privileged opcode" },
358 #endif
359 #if defined (SIGILL) && defined (ILL_PRVREG)
360 { SIGILL, ILL_PRVREG, "ILL_PRVREG", "Privileged register" },
361 #endif
362 #if defined (SIGILL) && defined (ILL_COPROC)
363 { SIGILL, ILL_COPROC, "ILL_COPROC", "Coprocessor error" },
364 #endif
365 #if defined (SIGILL) && defined (ILL_BADSTK)
366 { SIGILL, ILL_BADSTK, "ILL_BADSTK", "Internal stack error" },
367 #endif
368 #if defined (SIGFPE) && defined (FPE_INTDIV)
369 { SIGFPE, FPE_INTDIV, "FPE_INTDIV", "Integer divide by zero" },
370 #endif
371 #if defined (SIGFPE) && defined (FPE_INTOVF)
372 { SIGFPE, FPE_INTOVF, "FPE_INTOVF", "Integer overflow" },
373 #endif
374 #if defined (SIGFPE) && defined (FPE_FLTDIV)
375 { SIGFPE, FPE_FLTDIV, "FPE_FLTDIV", "Floating point divide by zero" },
376 #endif
377 #if defined (SIGFPE) && defined (FPE_FLTOVF)
378 { SIGFPE, FPE_FLTOVF, "FPE_FLTOVF", "Floating point overflow" },
379 #endif
380 #if defined (SIGFPE) && defined (FPE_FLTUND)
381 { SIGFPE, FPE_FLTUND, "FPE_FLTUND", "Floating point underflow" },
382 #endif
383 #if defined (SIGFPE) && defined (FPE_FLTRES)
384 { SIGFPE, FPE_FLTRES, "FPE_FLTRES", "Floating point inexact result" },
385 #endif
386 #if defined (SIGFPE) && defined (FPE_FLTINV)
387 { SIGFPE, FPE_FLTINV, "FPE_FLTINV", "Invalid floating point operation" },
388 #endif
389 #if defined (SIGFPE) && defined (FPE_FLTSUB)
390 { SIGFPE, FPE_FLTSUB, "FPE_FLTSUB", "Subscript out of range" },
391 #endif
392 #if defined (SIGSEGV) && defined (SEGV_MAPERR)
393 { SIGSEGV, SEGV_MAPERR, "SEGV_MAPERR", "Address not mapped to object" },
394 #endif
395 #if defined (SIGSEGV) && defined (SEGV_ACCERR)
396 { SIGSEGV, SEGV_ACCERR, "SEGV_ACCERR", "Invalid permissions for object" },
397 #endif
398 #if defined (SIGBUS) && defined (BUS_ADRALN)
399 { SIGBUS, BUS_ADRALN, "BUS_ADRALN", "Invalid address alignment" },
400 #endif
401 #if defined (SIGBUS) && defined (BUS_ADRERR)
402 { SIGBUS, BUS_ADRERR, "BUS_ADRERR", "Non-existent physical address" },
403 #endif
404 #if defined (SIGBUS) && defined (BUS_OBJERR)
405 { SIGBUS, BUS_OBJERR, "BUS_OBJERR", "Object specific hardware error" },
406 #endif
407 #if defined (SIGTRAP) && defined (TRAP_BRKPT)
408 { SIGTRAP, TRAP_BRKPT, "TRAP_BRKPT", "Process breakpoint" },
409 #endif
410 #if defined (SIGTRAP) && defined (TRAP_TRACE)
411 { SIGTRAP, TRAP_TRACE, "TRAP_TRACE", "Process trace trap" },
412 #endif
413 #if defined (SIGCLD) && defined (CLD_EXITED)
414 { SIGCLD, CLD_EXITED, "CLD_EXITED", "Child has exited" },
415 #endif
416 #if defined (SIGCLD) && defined (CLD_KILLED)
417 { SIGCLD, CLD_KILLED, "CLD_KILLED", "Child was killed" },
418 #endif
419 #if defined (SIGCLD) && defined (CLD_DUMPED)
420 { SIGCLD, CLD_DUMPED, "CLD_DUMPED", "Child has terminated abnormally" },
421 #endif
422 #if defined (SIGCLD) && defined (CLD_TRAPPED)
423 { SIGCLD, CLD_TRAPPED, "CLD_TRAPPED", "Traced child has trapped" },
424 #endif
425 #if defined (SIGCLD) && defined (CLD_STOPPED)
426 { SIGCLD, CLD_STOPPED, "CLD_STOPPED", "Child has stopped" },
427 #endif
428 #if defined (SIGCLD) && defined (CLD_CONTINUED)
429 { SIGCLD, CLD_CONTINUED, "CLD_CONTINUED", "Stopped child had continued" },
430 #endif
431 #if defined (SIGPOLL) && defined (POLL_IN)
432 { SIGPOLL, POLL_IN, "POLL_IN", "Input input available" },
433 #endif
434 #if defined (SIGPOLL) && defined (POLL_OUT)
435 { SIGPOLL, POLL_OUT, "POLL_OUT", "Output buffers available" },
436 #endif
437 #if defined (SIGPOLL) && defined (POLL_MSG)
438 { SIGPOLL, POLL_MSG, "POLL_MSG", "Input message available" },
439 #endif
440 #if defined (SIGPOLL) && defined (POLL_ERR)
441 { SIGPOLL, POLL_ERR, "POLL_ERR", "I/O error" },
442 #endif
443 #if defined (SIGPOLL) && defined (POLL_PRI)
444 { SIGPOLL, POLL_PRI, "POLL_PRI", "High priority input available" },
445 #endif
446 #if defined (SIGPOLL) && defined (POLL_HUP)
447 { SIGPOLL, POLL_HUP, "POLL_HUP", "Device disconnected" },
448 #endif
449 { 0, 0, NULL, NULL }
450 };
451
452 static char *syscall_table[MAX_SYSCALLS];
453
454 /* Prototypes for local functions */
455
456 static void procfs_stop PARAMS ((void));
457
458 static int procfs_thread_alive PARAMS ((int));
459
460 static int procfs_can_run PARAMS ((void));
461
462 static void procfs_mourn_inferior PARAMS ((void));
463
464 static void procfs_fetch_registers PARAMS ((int));
465
466 static int procfs_wait PARAMS ((int, struct target_waitstatus *));
467
468 static void procfs_open PARAMS ((char *, int));
469
470 static void procfs_files_info PARAMS ((struct target_ops *));
471
472 static void procfs_prepare_to_store PARAMS ((void));
473
474 static void procfs_detach PARAMS ((char *, int));
475
476 static void procfs_attach PARAMS ((char *, int));
477
478 static void proc_set_exec_trap PARAMS ((void));
479
480 static int procfs_init_inferior PARAMS ((int));
481
482 static struct procinfo *create_procinfo PARAMS ((int));
483
484 static void procfs_store_registers PARAMS ((int));
485
486 static int procfs_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
487
488 static void procfs_kill_inferior PARAMS ((void));
489
490 static char *sigcodedesc PARAMS ((siginfo_t *));
491
492 static char *sigcodename PARAMS ((siginfo_t *));
493
494 static struct procinfo *wait_fd PARAMS ((void));
495
496 static void remove_fd PARAMS ((struct procinfo *));
497
498 static void add_fd PARAMS ((struct procinfo *));
499
500 static void set_proc_siginfo PARAMS ((struct procinfo *, int));
501
502 static void init_syscall_table PARAMS ((void));
503
504 static char *syscallname PARAMS ((int));
505
506 static char *signalname PARAMS ((int));
507
508 static char *errnoname PARAMS ((int));
509
510 static int proc_address_to_fd PARAMS ((struct procinfo *, CORE_ADDR, int));
511
512 static int open_proc_file PARAMS ((int, struct procinfo *, int, int));
513
514 static void close_proc_file PARAMS ((struct procinfo *));
515
516 static void unconditionally_kill_inferior PARAMS ((struct procinfo *));
517
518 static NORETURN void proc_init_failed PARAMS ((struct procinfo *, char *, int)) ATTR_NORETURN;
519
520 static void info_proc PARAMS ((char *, int));
521
522 static void info_proc_flags PARAMS ((struct procinfo *, int));
523
524 static void info_proc_stop PARAMS ((struct procinfo *, int));
525
526 static void info_proc_siginfo PARAMS ((struct procinfo *, int));
527
528 static void info_proc_syscalls PARAMS ((struct procinfo *, int));
529
530 static void info_proc_mappings PARAMS ((struct procinfo *, int));
531
532 static void info_proc_signals PARAMS ((struct procinfo *, int));
533
534 static void info_proc_faults PARAMS ((struct procinfo *, int));
535
536 static char *mappingflags PARAMS ((long));
537
538 static char *lookupname PARAMS ((struct trans *, unsigned int, char *));
539
540 static char *lookupdesc PARAMS ((struct trans *, unsigned int));
541
542 static int do_attach PARAMS ((int pid));
543
544 static void do_detach PARAMS ((int siggnal));
545
546 static void procfs_create_inferior PARAMS ((char *, char *, char **));
547
548 static void procfs_notice_signals PARAMS ((int pid));
549
550 static void notice_signals PARAMS ((struct procinfo *, struct sig_ctl *));
551
552 static struct procinfo *find_procinfo PARAMS ((pid_t pid, int okfail));
553
554 static int procfs_write_pcwstop PARAMS ((struct procinfo *));
555 static int procfs_read_status PARAMS ((struct procinfo *));
556 static void procfs_write_pckill PARAMS ((struct procinfo *));
557
558 typedef int syscall_func_t PARAMS ((struct procinfo *pi, int syscall_num,
559 int why, int *rtnval, int *statval));
560
561 static void procfs_set_syscall_trap PARAMS ((struct procinfo *pi,
562 int syscall_num, int flags,
563 syscall_func_t *func));
564
565 static void procfs_clear_syscall_trap PARAMS ((struct procinfo *pi,
566 int syscall_num, int errok));
567
568 #define PROCFS_SYSCALL_ENTRY 0x1 /* Trap on entry to sys call */
569 #define PROCFS_SYSCALL_EXIT 0x2 /* Trap on exit from sys call */
570
571 static syscall_func_t procfs_exit_handler;
572
573 static syscall_func_t procfs_exec_handler;
574
575 #ifdef SYS_sproc
576 static syscall_func_t procfs_sproc_handler;
577 static syscall_func_t procfs_fork_handler;
578 #endif
579
580 #ifdef SYS_lwp_create
581 static syscall_func_t procfs_lwp_creation_handler;
582 #endif
583
584 static void modify_inherit_on_fork_flag PARAMS ((int fd, int flag));
585 static void modify_run_on_last_close_flag PARAMS ((int fd, int flag));
586
587 /* */
588
589 struct procfs_syscall_handler
590 {
591 int syscall_num; /* The number of the system call being handled */
592 /* The function to be called */
593 syscall_func_t *func;
594 };
595
596 static void procfs_resume PARAMS ((int pid, int step,
597 enum target_signal signo));
598
599 /* External function prototypes that can't be easily included in any
600 header file because the args are typedefs in system include files. */
601
602 extern void supply_gregset PARAMS ((gregset_t *));
603
604 extern void fill_gregset PARAMS ((gregset_t *, int));
605
606 #ifdef FP0_REGNUM
607 extern void supply_fpregset PARAMS ((fpregset_t *));
608
609 extern void fill_fpregset PARAMS ((fpregset_t *, int));
610 #endif
611
612 /*
613
614 LOCAL FUNCTION
615
616 find_procinfo -- convert a process id to a struct procinfo
617
618 SYNOPSIS
619
620 static struct procinfo * find_procinfo (pid_t pid, int okfail);
621
622 DESCRIPTION
623
624 Given a process id, look it up in the procinfo chain. Returns
625 a struct procinfo *. If can't find pid, then call error(),
626 unless okfail is set, in which case, return NULL;
627 */
628
629 static struct procinfo *
630 find_procinfo (pid, okfail)
631 pid_t pid;
632 int okfail;
633 {
634 struct procinfo *procinfo;
635
636 for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
637 if (procinfo->pid == pid)
638 return procinfo;
639
640 if (okfail)
641 return NULL;
642
643 error ("procfs (find_procinfo): Couldn't locate pid %d", pid);
644 }
645
646 /*
647
648 LOCAL MACRO
649
650 current_procinfo -- convert inferior_pid to a struct procinfo
651
652 SYNOPSIS
653
654 static struct procinfo * current_procinfo;
655
656 DESCRIPTION
657
658 Looks up inferior_pid in the procinfo chain. Always returns a
659 struct procinfo *. If process can't be found, we error() out.
660 */
661
662 #define current_procinfo find_procinfo (inferior_pid, 0)
663
664 /*
665
666 LOCAL FUNCTION
667
668 add_fd -- Add the fd to the poll/select list
669
670 SYNOPSIS
671
672 static void add_fd (struct procinfo *);
673
674 DESCRIPTION
675
676 Add the fd of the supplied procinfo to the list of fds used for
677 poll/select operations.
678 */
679
680 static void
681 add_fd (pi)
682 struct procinfo *pi;
683 {
684 if (num_poll_list <= 0)
685 poll_list = (struct pollfd *) xmalloc (sizeof (struct pollfd));
686 else
687 poll_list = (struct pollfd *) xrealloc (poll_list,
688 (num_poll_list + 1)
689 * sizeof (struct pollfd));
690 poll_list[num_poll_list].fd = pi->ctl_fd;
691 #ifdef UNIXWARE
692 poll_list[num_poll_list].events = POLLWRNORM;
693 #else
694 poll_list[num_poll_list].events = POLLPRI;
695 #endif
696
697 num_poll_list++;
698 }
699
700 /*
701
702 LOCAL FUNCTION
703
704 remove_fd -- Remove the fd from the poll/select list
705
706 SYNOPSIS
707
708 static void remove_fd (struct procinfo *);
709
710 DESCRIPTION
711
712 Remove the fd of the supplied procinfo from the list of fds used
713 for poll/select operations.
714 */
715
716 static void
717 remove_fd (pi)
718 struct procinfo *pi;
719 {
720 int i;
721
722 for (i = 0; i < num_poll_list; i++)
723 {
724 if (poll_list[i].fd == pi->ctl_fd)
725 {
726 if (i != num_poll_list - 1)
727 memcpy (poll_list + i, poll_list + i + 1,
728 (num_poll_list - i - 1) * sizeof (struct pollfd));
729
730 num_poll_list--;
731
732 if (num_poll_list == 0)
733 free (poll_list);
734 else
735 poll_list = (struct pollfd *) xrealloc (poll_list,
736 num_poll_list
737 * sizeof (struct pollfd));
738 return;
739 }
740 }
741 }
742
743 /*
744
745 LOCAL FUNCTION
746
747 procfs_read_status - get procfs fd status
748
749 SYNOPSIS
750
751 static int procfs_read_status (pi) struct procinfo *pi;
752
753 DESCRIPTION
754
755 Given a pointer to a procinfo struct, get the status of
756 the status_fd in the appropriate way. Returns 0 on failure,
757 1 on success.
758 */
759
760 static int
761 procfs_read_status (pi)
762 struct procinfo *pi;
763 {
764 #ifdef PROCFS_USE_READ_WRITE
765 if ((lseek (pi->status_fd, 0, SEEK_SET) < 0) ||
766 (read (pi->status_fd, (char *) &pi->prstatus,
767 sizeof (gdb_prstatus_t)) != sizeof (gdb_prstatus_t)))
768 #else
769 if (ioctl (pi->status_fd, PIOCSTATUS, &pi->prstatus) < 0)
770 #endif
771 return 0;
772 else
773 return 1;
774 }
775
776 /*
777
778 LOCAL FUNCTION
779
780 procfs_write_pcwstop - send a PCWSTOP to procfs fd
781
782 SYNOPSIS
783
784 static int procfs_write_pcwstop (pi) struct procinfo *pi;
785
786 DESCRIPTION
787
788 Given a pointer to a procinfo struct, send a PCWSTOP to
789 the ctl_fd in the appropriate way. Returns 0 on failure,
790 1 on success.
791 */
792
793 static int
794 procfs_write_pcwstop (pi)
795 struct procinfo *pi;
796 {
797 #ifdef PROCFS_USE_READ_WRITE
798 long cmd = PCWSTOP;
799 if (write (pi->ctl_fd, (char *) &cmd, sizeof (long)) < 0)
800 #else
801 if (ioctl (pi->ctl_fd, PIOCWSTOP, &pi->prstatus) < 0)
802 #endif
803 return 0;
804 else
805 return 1;
806 }
807
808 /*
809
810 LOCAL FUNCTION
811
812 procfs_write_pckill - send a kill to procfs fd
813
814 SYNOPSIS
815
816 static void procfs_write_pckill (pi) struct procinfo *pi;
817
818 DESCRIPTION
819
820 Given a pointer to a procinfo struct, send a kill to
821 the ctl_fd in the appropriate way. Returns 0 on failure,
822 1 on success.
823 */
824
825 static void
826 procfs_write_pckill (pi)
827 struct procinfo *pi;
828 {
829 #ifdef PROCFS_USE_READ_WRITE
830 struct proc_ctl pctl;
831 pctl.cmd = PCKILL;
832 pctl.data = SIGKILL;
833 write (pi->ctl_fd, &pctl, sizeof (struct proc_ctl));
834 #else
835 int signo = SIGKILL;
836 ioctl (pi->ctl_fd, PIOCKILL, &signo);
837 #endif
838 }
839
840 static struct procinfo *
841 wait_fd ()
842 {
843 struct procinfo *pi;
844 #ifndef LOSING_POLL
845 int num_fds;
846 int i;
847 #endif
848
849 set_sigint_trap (); /* Causes SIGINT to be passed on to the
850 attached process. */
851 set_sigio_trap ();
852
853 #ifndef LOSING_POLL
854 while (1)
855 {
856 num_fds = poll (poll_list, num_poll_list, -1);
857 if (num_fds > 0)
858 break;
859 if (num_fds < 0 && errno == EINTR)
860 continue;
861 print_sys_errmsg ("poll failed", errno);
862 error ("Poll failed, returned %d", num_fds);
863 }
864 #else /* LOSING_POLL */
865 pi = current_procinfo;
866
867 while (!procfs_write_pcwstop (pi))
868 {
869 if (errno == ENOENT)
870 {
871 /* Process exited. */
872 pi->prstatus.pr_flags = 0;
873 break;
874 }
875 else if (errno != EINTR)
876 {
877 print_sys_errmsg (pi->pathname, errno);
878 error ("procfs_write_pcwstop failed");
879 }
880 }
881 pi->had_event = 1;
882 #endif /* LOSING_POLL */
883
884 clear_sigint_trap ();
885 clear_sigio_trap ();
886
887 #ifndef LOSING_POLL
888
889 for (i = 0; i < num_poll_list && num_fds > 0; i++)
890 {
891 if (0 == (poll_list[i].revents &
892 (POLLWRNORM | POLLPRI | POLLERR | POLLHUP | POLLNVAL)))
893 continue;
894 for (pi = procinfo_list; pi; pi = pi->next)
895 {
896 if (poll_list[i].fd == pi->ctl_fd)
897 {
898 if (!procfs_read_status(pi))
899 {
900 /* The LWP has apparently terminated. */
901 if (info_verbose)
902 printf_filtered ("LWP %d doesn't respond.\n",
903 (pi->pid >> 16) & 0xffff);
904 /* could call close_proc_file here, but I'm afraid to... */
905 }
906
907 num_fds--;
908 pi->had_event = 1;
909 break;
910 }
911 }
912 if (!pi)
913 error ("wait_fd: Couldn't find procinfo for fd %d\n",
914 poll_list[i].fd);
915 }
916 #endif /* LOSING_POLL */
917
918 return pi;
919 }
920
921 /*
922
923 LOCAL FUNCTION
924
925 lookupdesc -- translate a value to a summary desc string
926
927 SYNOPSIS
928
929 static char *lookupdesc (struct trans *transp, unsigned int val);
930
931 DESCRIPTION
932
933 Given a pointer to a translation table and a value to be translated,
934 lookup the desc string and return it.
935 */
936
937 static char *
938 lookupdesc (transp, val)
939 struct trans *transp;
940 unsigned int val;
941 {
942 char *desc;
943
944 for (desc = NULL; transp -> name != NULL; transp++)
945 {
946 if (transp -> value == val)
947 {
948 desc = transp -> desc;
949 break;
950 }
951 }
952
953 /* Didn't find a translation for the specified value, set a default one. */
954
955 if (desc == NULL)
956 {
957 desc = "Unknown";
958 }
959 return (desc);
960 }
961
962 /*
963
964 LOCAL FUNCTION
965
966 lookupname -- translate a value to symbolic name
967
968 SYNOPSIS
969
970 static char *lookupname (struct trans *transp, unsigned int val,
971 char *prefix);
972
973 DESCRIPTION
974
975 Given a pointer to a translation table, a value to be translated,
976 and a default prefix to return if the value can't be translated,
977 match the value with one of the translation table entries and
978 return a pointer to the symbolic name.
979
980 If no match is found it just returns the value as a printable string,
981 with the given prefix. The previous such value, if any, is freed
982 at this time.
983 */
984
985 static char *
986 lookupname (transp, val, prefix)
987 struct trans *transp;
988 unsigned int val;
989 char *prefix;
990 {
991 static char *locbuf;
992 char *name;
993
994 for (name = NULL; transp -> name != NULL; transp++)
995 {
996 if (transp -> value == val)
997 {
998 name = transp -> name;
999 break;
1000 }
1001 }
1002
1003 /* Didn't find a translation for the specified value, build a default
1004 one using the specified prefix and return it. The lifetime of
1005 the value is only until the next one is needed. */
1006
1007 if (name == NULL)
1008 {
1009 if (locbuf != NULL)
1010 {
1011 free (locbuf);
1012 }
1013 locbuf = xmalloc (strlen (prefix) + 16);
1014 sprintf (locbuf, "%s %u", prefix, val);
1015 name = locbuf;
1016 }
1017 return (name);
1018 }
1019
1020 static char *
1021 sigcodename (sip)
1022 siginfo_t *sip;
1023 {
1024 struct sigcode *scp;
1025 char *name = NULL;
1026 static char locbuf[32];
1027
1028 for (scp = siginfo_table; scp -> codename != NULL; scp++)
1029 {
1030 if ((scp -> signo == sip -> si_signo) &&
1031 (scp -> code == sip -> si_code))
1032 {
1033 name = scp -> codename;
1034 break;
1035 }
1036 }
1037 if (name == NULL)
1038 {
1039 sprintf (locbuf, "sigcode %u", sip -> si_signo);
1040 name = locbuf;
1041 }
1042 return (name);
1043 }
1044
1045 static char *
1046 sigcodedesc (sip)
1047 siginfo_t *sip;
1048 {
1049 struct sigcode *scp;
1050 char *desc = NULL;
1051
1052 for (scp = siginfo_table; scp -> codename != NULL; scp++)
1053 {
1054 if ((scp -> signo == sip -> si_signo) &&
1055 (scp -> code == sip -> si_code))
1056 {
1057 desc = scp -> desc;
1058 break;
1059 }
1060 }
1061 if (desc == NULL)
1062 {
1063 desc = "Unrecognized signal or trap use";
1064 }
1065 return (desc);
1066 }
1067
1068 /*
1069
1070 LOCAL FUNCTION
1071
1072 syscallname - translate a system call number into a system call name
1073
1074 SYNOPSIS
1075
1076 char *syscallname (int syscallnum)
1077
1078 DESCRIPTION
1079
1080 Given a system call number, translate it into the printable name
1081 of a system call, or into "syscall <num>" if it is an unknown
1082 number.
1083 */
1084
1085 static char *
1086 syscallname (syscallnum)
1087 int syscallnum;
1088 {
1089 static char locbuf[32];
1090
1091 if (syscallnum >= 0 && syscallnum < MAX_SYSCALLS
1092 && syscall_table[syscallnum] != NULL)
1093 return syscall_table[syscallnum];
1094 else
1095 {
1096 sprintf (locbuf, "syscall %u", syscallnum);
1097 return locbuf;
1098 }
1099 }
1100
1101 /*
1102
1103 LOCAL FUNCTION
1104
1105 init_syscall_table - initialize syscall translation table
1106
1107 SYNOPSIS
1108
1109 void init_syscall_table (void)
1110
1111 DESCRIPTION
1112
1113 Dynamically initialize the translation table to convert system
1114 call numbers into printable system call names. Done once per
1115 gdb run, on initialization.
1116
1117 NOTES
1118
1119 This is awfully ugly, but preprocessor tricks to make it prettier
1120 tend to be nonportable.
1121 */
1122
1123 static void
1124 init_syscall_table ()
1125 {
1126 #if defined (SYS_exit)
1127 syscall_table[SYS_exit] = "exit";
1128 #endif
1129 #if defined (SYS_fork)
1130 syscall_table[SYS_fork] = "fork";
1131 #endif
1132 #if defined (SYS_read)
1133 syscall_table[SYS_read] = "read";
1134 #endif
1135 #if defined (SYS_write)
1136 syscall_table[SYS_write] = "write";
1137 #endif
1138 #if defined (SYS_open)
1139 syscall_table[SYS_open] = "open";
1140 #endif
1141 #if defined (SYS_close)
1142 syscall_table[SYS_close] = "close";
1143 #endif
1144 #if defined (SYS_wait)
1145 syscall_table[SYS_wait] = "wait";
1146 #endif
1147 #if defined (SYS_creat)
1148 syscall_table[SYS_creat] = "creat";
1149 #endif
1150 #if defined (SYS_link)
1151 syscall_table[SYS_link] = "link";
1152 #endif
1153 #if defined (SYS_unlink)
1154 syscall_table[SYS_unlink] = "unlink";
1155 #endif
1156 #if defined (SYS_exec)
1157 syscall_table[SYS_exec] = "exec";
1158 #endif
1159 #if defined (SYS_execv)
1160 syscall_table[SYS_execv] = "execv";
1161 #endif
1162 #if defined (SYS_execve)
1163 syscall_table[SYS_execve] = "execve";
1164 #endif
1165 #if defined (SYS_chdir)
1166 syscall_table[SYS_chdir] = "chdir";
1167 #endif
1168 #if defined (SYS_time)
1169 syscall_table[SYS_time] = "time";
1170 #endif
1171 #if defined (SYS_mknod)
1172 syscall_table[SYS_mknod] = "mknod";
1173 #endif
1174 #if defined (SYS_chmod)
1175 syscall_table[SYS_chmod] = "chmod";
1176 #endif
1177 #if defined (SYS_chown)
1178 syscall_table[SYS_chown] = "chown";
1179 #endif
1180 #if defined (SYS_brk)
1181 syscall_table[SYS_brk] = "brk";
1182 #endif
1183 #if defined (SYS_stat)
1184 syscall_table[SYS_stat] = "stat";
1185 #endif
1186 #if defined (SYS_lseek)
1187 syscall_table[SYS_lseek] = "lseek";
1188 #endif
1189 #if defined (SYS_getpid)
1190 syscall_table[SYS_getpid] = "getpid";
1191 #endif
1192 #if defined (SYS_mount)
1193 syscall_table[SYS_mount] = "mount";
1194 #endif
1195 #if defined (SYS_umount)
1196 syscall_table[SYS_umount] = "umount";
1197 #endif
1198 #if defined (SYS_setuid)
1199 syscall_table[SYS_setuid] = "setuid";
1200 #endif
1201 #if defined (SYS_getuid)
1202 syscall_table[SYS_getuid] = "getuid";
1203 #endif
1204 #if defined (SYS_stime)
1205 syscall_table[SYS_stime] = "stime";
1206 #endif
1207 #if defined (SYS_ptrace)
1208 syscall_table[SYS_ptrace] = "ptrace";
1209 #endif
1210 #if defined (SYS_alarm)
1211 syscall_table[SYS_alarm] = "alarm";
1212 #endif
1213 #if defined (SYS_fstat)
1214 syscall_table[SYS_fstat] = "fstat";
1215 #endif
1216 #if defined (SYS_pause)
1217 syscall_table[SYS_pause] = "pause";
1218 #endif
1219 #if defined (SYS_utime)
1220 syscall_table[SYS_utime] = "utime";
1221 #endif
1222 #if defined (SYS_stty)
1223 syscall_table[SYS_stty] = "stty";
1224 #endif
1225 #if defined (SYS_gtty)
1226 syscall_table[SYS_gtty] = "gtty";
1227 #endif
1228 #if defined (SYS_access)
1229 syscall_table[SYS_access] = "access";
1230 #endif
1231 #if defined (SYS_nice)
1232 syscall_table[SYS_nice] = "nice";
1233 #endif
1234 #if defined (SYS_statfs)
1235 syscall_table[SYS_statfs] = "statfs";
1236 #endif
1237 #if defined (SYS_sync)
1238 syscall_table[SYS_sync] = "sync";
1239 #endif
1240 #if defined (SYS_kill)
1241 syscall_table[SYS_kill] = "kill";
1242 #endif
1243 #if defined (SYS_fstatfs)
1244 syscall_table[SYS_fstatfs] = "fstatfs";
1245 #endif
1246 #if defined (SYS_pgrpsys)
1247 syscall_table[SYS_pgrpsys] = "pgrpsys";
1248 #endif
1249 #if defined (SYS_xenix)
1250 syscall_table[SYS_xenix] = "xenix";
1251 #endif
1252 #if defined (SYS_dup)
1253 syscall_table[SYS_dup] = "dup";
1254 #endif
1255 #if defined (SYS_pipe)
1256 syscall_table[SYS_pipe] = "pipe";
1257 #endif
1258 #if defined (SYS_times)
1259 syscall_table[SYS_times] = "times";
1260 #endif
1261 #if defined (SYS_profil)
1262 syscall_table[SYS_profil] = "profil";
1263 #endif
1264 #if defined (SYS_plock)
1265 syscall_table[SYS_plock] = "plock";
1266 #endif
1267 #if defined (SYS_setgid)
1268 syscall_table[SYS_setgid] = "setgid";
1269 #endif
1270 #if defined (SYS_getgid)
1271 syscall_table[SYS_getgid] = "getgid";
1272 #endif
1273 #if defined (SYS_signal)
1274 syscall_table[SYS_signal] = "signal";
1275 #endif
1276 #if defined (SYS_msgsys)
1277 syscall_table[SYS_msgsys] = "msgsys";
1278 #endif
1279 #if defined (SYS_sys3b)
1280 syscall_table[SYS_sys3b] = "sys3b";
1281 #endif
1282 #if defined (SYS_sysi86)
1283 syscall_table[SYS_sysi86] = "sysi86";
1284 #endif
1285 #if defined (SYS_acct)
1286 syscall_table[SYS_acct] = "acct";
1287 #endif
1288 #if defined (SYS_shmsys)
1289 syscall_table[SYS_shmsys] = "shmsys";
1290 #endif
1291 #if defined (SYS_semsys)
1292 syscall_table[SYS_semsys] = "semsys";
1293 #endif
1294 #if defined (SYS_ioctl)
1295 syscall_table[SYS_ioctl] = "ioctl";
1296 #endif
1297 #if defined (SYS_uadmin)
1298 syscall_table[SYS_uadmin] = "uadmin";
1299 #endif
1300 #if defined (SYS_utssys)
1301 syscall_table[SYS_utssys] = "utssys";
1302 #endif
1303 #if defined (SYS_fsync)
1304 syscall_table[SYS_fsync] = "fsync";
1305 #endif
1306 #if defined (SYS_umask)
1307 syscall_table[SYS_umask] = "umask";
1308 #endif
1309 #if defined (SYS_chroot)
1310 syscall_table[SYS_chroot] = "chroot";
1311 #endif
1312 #if defined (SYS_fcntl)
1313 syscall_table[SYS_fcntl] = "fcntl";
1314 #endif
1315 #if defined (SYS_ulimit)
1316 syscall_table[SYS_ulimit] = "ulimit";
1317 #endif
1318 #if defined (SYS_rfsys)
1319 syscall_table[SYS_rfsys] = "rfsys";
1320 #endif
1321 #if defined (SYS_rmdir)
1322 syscall_table[SYS_rmdir] = "rmdir";
1323 #endif
1324 #if defined (SYS_mkdir)
1325 syscall_table[SYS_mkdir] = "mkdir";
1326 #endif
1327 #if defined (SYS_getdents)
1328 syscall_table[SYS_getdents] = "getdents";
1329 #endif
1330 #if defined (SYS_sysfs)
1331 syscall_table[SYS_sysfs] = "sysfs";
1332 #endif
1333 #if defined (SYS_getmsg)
1334 syscall_table[SYS_getmsg] = "getmsg";
1335 #endif
1336 #if defined (SYS_putmsg)
1337 syscall_table[SYS_putmsg] = "putmsg";
1338 #endif
1339 #if defined (SYS_poll)
1340 syscall_table[SYS_poll] = "poll";
1341 #endif
1342 #if defined (SYS_lstat)
1343 syscall_table[SYS_lstat] = "lstat";
1344 #endif
1345 #if defined (SYS_symlink)
1346 syscall_table[SYS_symlink] = "symlink";
1347 #endif
1348 #if defined (SYS_readlink)
1349 syscall_table[SYS_readlink] = "readlink";
1350 #endif
1351 #if defined (SYS_setgroups)
1352 syscall_table[SYS_setgroups] = "setgroups";
1353 #endif
1354 #if defined (SYS_getgroups)
1355 syscall_table[SYS_getgroups] = "getgroups";
1356 #endif
1357 #if defined (SYS_fchmod)
1358 syscall_table[SYS_fchmod] = "fchmod";
1359 #endif
1360 #if defined (SYS_fchown)
1361 syscall_table[SYS_fchown] = "fchown";
1362 #endif
1363 #if defined (SYS_sigprocmask)
1364 syscall_table[SYS_sigprocmask] = "sigprocmask";
1365 #endif
1366 #if defined (SYS_sigsuspend)
1367 syscall_table[SYS_sigsuspend] = "sigsuspend";
1368 #endif
1369 #if defined (SYS_sigaltstack)
1370 syscall_table[SYS_sigaltstack] = "sigaltstack";
1371 #endif
1372 #if defined (SYS_sigaction)
1373 syscall_table[SYS_sigaction] = "sigaction";
1374 #endif
1375 #if defined (SYS_sigpending)
1376 syscall_table[SYS_sigpending] = "sigpending";
1377 #endif
1378 #if defined (SYS_context)
1379 syscall_table[SYS_context] = "context";
1380 #endif
1381 #if defined (SYS_evsys)
1382 syscall_table[SYS_evsys] = "evsys";
1383 #endif
1384 #if defined (SYS_evtrapret)
1385 syscall_table[SYS_evtrapret] = "evtrapret";
1386 #endif
1387 #if defined (SYS_statvfs)
1388 syscall_table[SYS_statvfs] = "statvfs";
1389 #endif
1390 #if defined (SYS_fstatvfs)
1391 syscall_table[SYS_fstatvfs] = "fstatvfs";
1392 #endif
1393 #if defined (SYS_nfssys)
1394 syscall_table[SYS_nfssys] = "nfssys";
1395 #endif
1396 #if defined (SYS_waitsys)
1397 syscall_table[SYS_waitsys] = "waitsys";
1398 #endif
1399 #if defined (SYS_sigsendsys)
1400 syscall_table[SYS_sigsendsys] = "sigsendsys";
1401 #endif
1402 #if defined (SYS_hrtsys)
1403 syscall_table[SYS_hrtsys] = "hrtsys";
1404 #endif
1405 #if defined (SYS_acancel)
1406 syscall_table[SYS_acancel] = "acancel";
1407 #endif
1408 #if defined (SYS_async)
1409 syscall_table[SYS_async] = "async";
1410 #endif
1411 #if defined (SYS_priocntlsys)
1412 syscall_table[SYS_priocntlsys] = "priocntlsys";
1413 #endif
1414 #if defined (SYS_pathconf)
1415 syscall_table[SYS_pathconf] = "pathconf";
1416 #endif
1417 #if defined (SYS_mincore)
1418 syscall_table[SYS_mincore] = "mincore";
1419 #endif
1420 #if defined (SYS_mmap)
1421 syscall_table[SYS_mmap] = "mmap";
1422 #endif
1423 #if defined (SYS_mprotect)
1424 syscall_table[SYS_mprotect] = "mprotect";
1425 #endif
1426 #if defined (SYS_munmap)
1427 syscall_table[SYS_munmap] = "munmap";
1428 #endif
1429 #if defined (SYS_fpathconf)
1430 syscall_table[SYS_fpathconf] = "fpathconf";
1431 #endif
1432 #if defined (SYS_vfork)
1433 syscall_table[SYS_vfork] = "vfork";
1434 #endif
1435 #if defined (SYS_fchdir)
1436 syscall_table[SYS_fchdir] = "fchdir";
1437 #endif
1438 #if defined (SYS_readv)
1439 syscall_table[SYS_readv] = "readv";
1440 #endif
1441 #if defined (SYS_writev)
1442 syscall_table[SYS_writev] = "writev";
1443 #endif
1444 #if defined (SYS_xstat)
1445 syscall_table[SYS_xstat] = "xstat";
1446 #endif
1447 #if defined (SYS_lxstat)
1448 syscall_table[SYS_lxstat] = "lxstat";
1449 #endif
1450 #if defined (SYS_fxstat)
1451 syscall_table[SYS_fxstat] = "fxstat";
1452 #endif
1453 #if defined (SYS_xmknod)
1454 syscall_table[SYS_xmknod] = "xmknod";
1455 #endif
1456 #if defined (SYS_clocal)
1457 syscall_table[SYS_clocal] = "clocal";
1458 #endif
1459 #if defined (SYS_setrlimit)
1460 syscall_table[SYS_setrlimit] = "setrlimit";
1461 #endif
1462 #if defined (SYS_getrlimit)
1463 syscall_table[SYS_getrlimit] = "getrlimit";
1464 #endif
1465 #if defined (SYS_lchown)
1466 syscall_table[SYS_lchown] = "lchown";
1467 #endif
1468 #if defined (SYS_memcntl)
1469 syscall_table[SYS_memcntl] = "memcntl";
1470 #endif
1471 #if defined (SYS_getpmsg)
1472 syscall_table[SYS_getpmsg] = "getpmsg";
1473 #endif
1474 #if defined (SYS_putpmsg)
1475 syscall_table[SYS_putpmsg] = "putpmsg";
1476 #endif
1477 #if defined (SYS_rename)
1478 syscall_table[SYS_rename] = "rename";
1479 #endif
1480 #if defined (SYS_uname)
1481 syscall_table[SYS_uname] = "uname";
1482 #endif
1483 #if defined (SYS_setegid)
1484 syscall_table[SYS_setegid] = "setegid";
1485 #endif
1486 #if defined (SYS_sysconfig)
1487 syscall_table[SYS_sysconfig] = "sysconfig";
1488 #endif
1489 #if defined (SYS_adjtime)
1490 syscall_table[SYS_adjtime] = "adjtime";
1491 #endif
1492 #if defined (SYS_systeminfo)
1493 syscall_table[SYS_systeminfo] = "systeminfo";
1494 #endif
1495 #if defined (SYS_seteuid)
1496 syscall_table[SYS_seteuid] = "seteuid";
1497 #endif
1498 #if defined (SYS_sproc)
1499 syscall_table[SYS_sproc] = "sproc";
1500 #endif
1501 #if defined (SYS_keyctl)
1502 syscall_table[SYS_keyctl] = "keyctl";
1503 #endif
1504 #if defined (SYS_secsys)
1505 syscall_table[SYS_secsys] = "secsys";
1506 #endif
1507 #if defined (SYS_filepriv)
1508 syscall_table[SYS_filepriv] = "filepriv";
1509 #endif
1510 #if defined (SYS_procpriv)
1511 syscall_table[SYS_procpriv] = "procpriv";
1512 #endif
1513 #if defined (SYS_devstat)
1514 syscall_table[SYS_devstat] = "devstat";
1515 #endif
1516 #if defined (SYS_aclipc)
1517 syscall_table[SYS_aclipc] = "aclipc";
1518 #endif
1519 #if defined (SYS_fdevstat)
1520 syscall_table[SYS_fdevstat] = "fdevstat";
1521 #endif
1522 #if defined (SYS_flvlfile)
1523 syscall_table[SYS_flvlfile] = "flvlfile";
1524 #endif
1525 #if defined (SYS_lvlfile)
1526 syscall_table[SYS_lvlfile] = "lvlfile";
1527 #endif
1528 #if defined (SYS_lvlequal)
1529 syscall_table[SYS_lvlequal] = "lvlequal";
1530 #endif
1531 #if defined (SYS_lvlproc)
1532 syscall_table[SYS_lvlproc] = "lvlproc";
1533 #endif
1534 #if defined (SYS_lvlipc)
1535 syscall_table[SYS_lvlipc] = "lvlipc";
1536 #endif
1537 #if defined (SYS_acl)
1538 syscall_table[SYS_acl] = "acl";
1539 #endif
1540 #if defined (SYS_auditevt)
1541 syscall_table[SYS_auditevt] = "auditevt";
1542 #endif
1543 #if defined (SYS_auditctl)
1544 syscall_table[SYS_auditctl] = "auditctl";
1545 #endif
1546 #if defined (SYS_auditdmp)
1547 syscall_table[SYS_auditdmp] = "auditdmp";
1548 #endif
1549 #if defined (SYS_auditlog)
1550 syscall_table[SYS_auditlog] = "auditlog";
1551 #endif
1552 #if defined (SYS_auditbuf)
1553 syscall_table[SYS_auditbuf] = "auditbuf";
1554 #endif
1555 #if defined (SYS_lvldom)
1556 syscall_table[SYS_lvldom] = "lvldom";
1557 #endif
1558 #if defined (SYS_lvlvfs)
1559 syscall_table[SYS_lvlvfs] = "lvlvfs";
1560 #endif
1561 #if defined (SYS_mkmld)
1562 syscall_table[SYS_mkmld] = "mkmld";
1563 #endif
1564 #if defined (SYS_mldmode)
1565 syscall_table[SYS_mldmode] = "mldmode";
1566 #endif
1567 #if defined (SYS_secadvise)
1568 syscall_table[SYS_secadvise] = "secadvise";
1569 #endif
1570 #if defined (SYS_online)
1571 syscall_table[SYS_online] = "online";
1572 #endif
1573 #if defined (SYS_setitimer)
1574 syscall_table[SYS_setitimer] = "setitimer";
1575 #endif
1576 #if defined (SYS_getitimer)
1577 syscall_table[SYS_getitimer] = "getitimer";
1578 #endif
1579 #if defined (SYS_gettimeofday)
1580 syscall_table[SYS_gettimeofday] = "gettimeofday";
1581 #endif
1582 #if defined (SYS_settimeofday)
1583 syscall_table[SYS_settimeofday] = "settimeofday";
1584 #endif
1585 #if defined (SYS_lwp_create)
1586 syscall_table[SYS_lwp_create] = "_lwp_create";
1587 #endif
1588 #if defined (SYS_lwp_exit)
1589 syscall_table[SYS_lwp_exit] = "_lwp_exit";
1590 #endif
1591 #if defined (SYS_lwp_wait)
1592 syscall_table[SYS_lwp_wait] = "_lwp_wait";
1593 #endif
1594 #if defined (SYS_lwp_self)
1595 syscall_table[SYS_lwp_self] = "_lwp_self";
1596 #endif
1597 #if defined (SYS_lwp_info)
1598 syscall_table[SYS_lwp_info] = "_lwp_info";
1599 #endif
1600 #if defined (SYS_lwp_private)
1601 syscall_table[SYS_lwp_private] = "_lwp_private";
1602 #endif
1603 #if defined (SYS_processor_bind)
1604 syscall_table[SYS_processor_bind] = "processor_bind";
1605 #endif
1606 #if defined (SYS_processor_exbind)
1607 syscall_table[SYS_processor_exbind] = "processor_exbind";
1608 #endif
1609 #if defined (SYS_prepblock)
1610 syscall_table[SYS_prepblock] = "prepblock";
1611 #endif
1612 #if defined (SYS_block)
1613 syscall_table[SYS_block] = "block";
1614 #endif
1615 #if defined (SYS_rdblock)
1616 syscall_table[SYS_rdblock] = "rdblock";
1617 #endif
1618 #if defined (SYS_unblock)
1619 syscall_table[SYS_unblock] = "unblock";
1620 #endif
1621 #if defined (SYS_cancelblock)
1622 syscall_table[SYS_cancelblock] = "cancelblock";
1623 #endif
1624 #if defined (SYS_pread)
1625 syscall_table[SYS_pread] = "pread";
1626 #endif
1627 #if defined (SYS_pwrite)
1628 syscall_table[SYS_pwrite] = "pwrite";
1629 #endif
1630 #if defined (SYS_truncate)
1631 syscall_table[SYS_truncate] = "truncate";
1632 #endif
1633 #if defined (SYS_ftruncate)
1634 syscall_table[SYS_ftruncate] = "ftruncate";
1635 #endif
1636 #if defined (SYS_lwp_kill)
1637 syscall_table[SYS_lwp_kill] = "_lwp_kill";
1638 #endif
1639 #if defined (SYS_sigwait)
1640 syscall_table[SYS_sigwait] = "sigwait";
1641 #endif
1642 #if defined (SYS_fork1)
1643 syscall_table[SYS_fork1] = "fork1";
1644 #endif
1645 #if defined (SYS_forkall)
1646 syscall_table[SYS_forkall] = "forkall";
1647 #endif
1648 #if defined (SYS_modload)
1649 syscall_table[SYS_modload] = "modload";
1650 #endif
1651 #if defined (SYS_moduload)
1652 syscall_table[SYS_moduload] = "moduload";
1653 #endif
1654 #if defined (SYS_modpath)
1655 syscall_table[SYS_modpath] = "modpath";
1656 #endif
1657 #if defined (SYS_modstat)
1658 syscall_table[SYS_modstat] = "modstat";
1659 #endif
1660 #if defined (SYS_modadm)
1661 syscall_table[SYS_modadm] = "modadm";
1662 #endif
1663 #if defined (SYS_getksym)
1664 syscall_table[SYS_getksym] = "getksym";
1665 #endif
1666 #if defined (SYS_lwp_suspend)
1667 syscall_table[SYS_lwp_suspend] = "_lwp_suspend";
1668 #endif
1669 #if defined (SYS_lwp_continue)
1670 syscall_table[SYS_lwp_continue] = "_lwp_continue";
1671 #endif
1672 #if defined (SYS_priocntllst)
1673 syscall_table[SYS_priocntllst] = "priocntllst";
1674 #endif
1675 #if defined (SYS_sleep)
1676 syscall_table[SYS_sleep] = "sleep";
1677 #endif
1678 #if defined (SYS_lwp_sema_wait)
1679 syscall_table[SYS_lwp_sema_wait] = "_lwp_sema_wait";
1680 #endif
1681 #if defined (SYS_lwp_sema_post)
1682 syscall_table[SYS_lwp_sema_post] = "_lwp_sema_post";
1683 #endif
1684 #if defined (SYS_lwp_sema_trywait)
1685 syscall_table[SYS_lwp_sema_trywait] = "lwp_sema_trywait";
1686 #endif
1687 }
1688
1689 /*
1690
1691 LOCAL FUNCTION
1692
1693 procfs_kill_inferior - kill any currently inferior
1694
1695 SYNOPSIS
1696
1697 void procfs_kill_inferior (void)
1698
1699 DESCRIPTION
1700
1701 Kill any current inferior.
1702
1703 NOTES
1704
1705 Kills even attached inferiors. Presumably the user has already
1706 been prompted that the inferior is an attached one rather than
1707 one started by gdb. (FIXME?)
1708
1709 */
1710
1711 static void
1712 procfs_kill_inferior ()
1713 {
1714 target_mourn_inferior ();
1715 }
1716
1717 /*
1718
1719 LOCAL FUNCTION
1720
1721 unconditionally_kill_inferior - terminate the inferior
1722
1723 SYNOPSIS
1724
1725 static void unconditionally_kill_inferior (struct procinfo *)
1726
1727 DESCRIPTION
1728
1729 Kill the specified inferior.
1730
1731 NOTE
1732
1733 A possibly useful enhancement would be to first try sending
1734 the inferior a terminate signal, politely asking it to commit
1735 suicide, before we murder it (we could call that
1736 politely_kill_inferior()).
1737
1738 */
1739
1740 static void
1741 unconditionally_kill_inferior (pi)
1742 struct procinfo *pi;
1743 {
1744 int ppid;
1745 struct proc_ctl pctl;
1746
1747 ppid = pi->prstatus.pr_ppid;
1748
1749 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
1750 /* Alpha OSF/1-3.x procfs needs a clear of the current signal
1751 before the PIOCKILL, otherwise it might generate a corrupted core
1752 file for the inferior. */
1753 ioctl (pi->ctl_fd, PIOCSSIG, NULL);
1754 #endif
1755 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
1756 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
1757 to kill the inferior, otherwise it might remain stopped with a
1758 pending SIGKILL.
1759 We do not check the result of the PIOCSSIG, the inferior might have
1760 died already. */
1761 {
1762 struct siginfo newsiginfo;
1763
1764 memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
1765 newsiginfo.si_signo = SIGKILL;
1766 newsiginfo.si_code = 0;
1767 newsiginfo.si_errno = 0;
1768 newsiginfo.si_pid = getpid ();
1769 newsiginfo.si_uid = getuid ();
1770 ioctl (pi->ctl_fd, PIOCSSIG, &newsiginfo);
1771 }
1772 #else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
1773 procfs_write_pckill (pi);
1774 #endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
1775
1776 close_proc_file (pi);
1777
1778 /* Only wait() for our direct children. Our grandchildren zombies are killed
1779 by the death of their parents. */
1780
1781 if (ppid == getpid())
1782 wait ((int *) 0);
1783 }
1784
1785 /*
1786
1787 LOCAL FUNCTION
1788
1789 procfs_xfer_memory -- copy data to or from inferior memory space
1790
1791 SYNOPSIS
1792
1793 int procfs_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
1794 int dowrite, struct target_ops target)
1795
1796 DESCRIPTION
1797
1798 Copy LEN bytes to/from inferior's memory starting at MEMADDR
1799 from/to debugger memory starting at MYADDR. Copy from inferior
1800 if DOWRITE is zero or to inferior if DOWRITE is nonzero.
1801
1802 Returns the length copied, which is either the LEN argument or
1803 zero. This xfer function does not do partial moves, since procfs_ops
1804 doesn't allow memory operations to cross below us in the target stack
1805 anyway.
1806
1807 NOTES
1808
1809 The /proc interface makes this an almost trivial task.
1810 */
1811
1812 static int
1813 procfs_xfer_memory (memaddr, myaddr, len, dowrite, target)
1814 CORE_ADDR memaddr;
1815 char *myaddr;
1816 int len;
1817 int dowrite;
1818 struct target_ops *target; /* ignored */
1819 {
1820 int nbytes = 0;
1821 struct procinfo *pi;
1822
1823 pi = current_procinfo;
1824
1825 if (lseek(pi->as_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr)
1826 {
1827 if (dowrite)
1828 {
1829 nbytes = write (pi->as_fd, myaddr, len);
1830 }
1831 else
1832 {
1833 nbytes = read (pi->as_fd, myaddr, len);
1834 }
1835 if (nbytes < 0)
1836 {
1837 nbytes = 0;
1838 }
1839 }
1840 return (nbytes);
1841 }
1842
1843 /*
1844
1845 LOCAL FUNCTION
1846
1847 procfs_store_registers -- copy register values back to inferior
1848
1849 SYNOPSIS
1850
1851 void procfs_store_registers (int regno)
1852
1853 DESCRIPTION
1854
1855 Store our current register values back into the inferior. If
1856 REGNO is -1 then store all the register, otherwise store just
1857 the value specified by REGNO.
1858
1859 NOTES
1860
1861 If we are storing only a single register, we first have to get all
1862 the current values from the process, overwrite the desired register
1863 in the gregset with the one we want from gdb's registers, and then
1864 send the whole set back to the process. For writing all the
1865 registers, all we have to do is generate the gregset and send it to
1866 the process.
1867
1868 Also note that the process has to be stopped on an event of interest
1869 for this to work, which basically means that it has to have been
1870 run under the control of one of the other /proc ioctl calls and not
1871 ptrace. Since we don't use ptrace anyway, we don't worry about this
1872 fine point, but it is worth noting for future reference.
1873
1874 Gdb is confused about what this function is supposed to return.
1875 Some versions return a value, others return nothing. Some are
1876 declared to return a value and actually return nothing. Gdb ignores
1877 anything returned. (FIXME)
1878
1879 */
1880
1881 static void
1882 procfs_store_registers (regno)
1883 int regno;
1884 {
1885 struct procinfo *pi;
1886 #ifdef PROCFS_USE_READ_WRITE
1887 struct greg_ctl greg;
1888 struct fpreg_ctl fpreg;
1889 #endif
1890
1891 pi = current_procinfo;
1892
1893 #ifdef PROCFS_USE_READ_WRITE
1894 if (regno != -1)
1895 {
1896 procfs_read_status (pi);
1897 memcpy ((char *) &greg.gregset,
1898 (char *) &pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs,
1899 sizeof (gregset_t));
1900 }
1901 fill_gregset (&greg.gregset, regno);
1902 greg.cmd = PCSREG;
1903 write (pi->ctl_fd, &greg, sizeof (greg));
1904 #else /* PROCFS_USE_READ_WRITE */
1905 if (regno != -1)
1906 {
1907 ioctl (pi->ctl_fd, PIOCGREG, &pi->gregset.gregset);
1908 }
1909 fill_gregset (&pi->gregset.gregset, regno);
1910 ioctl (pi->ctl_fd, PIOCSREG, &pi->gregset.gregset);
1911 #endif /* PROCFS_USE_READ_WRITE */
1912
1913 #if defined (FP0_REGNUM)
1914
1915 /* Now repeat everything using the floating point register set, if the
1916 target has floating point hardware. Since we ignore the returned value,
1917 we'll never know whether it worked or not anyway. */
1918
1919 #ifdef PROCFS_USE_READ_WRITE
1920 if (regno != -1)
1921 {
1922 procfs_read_status (pi);
1923 memcpy ((char *) &fpreg.fpregset,
1924 (char *) &pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs,
1925 sizeof (fpregset_t));
1926 }
1927 fill_fpregset (&fpreg.fpregset, regno);
1928 fpreg.cmd = PCSFPREG;
1929 write (pi->ctl_fd, &fpreg, sizeof (fpreg));
1930 #else /* PROCFS_USE_READ_WRITE */
1931 if (regno != -1)
1932 {
1933 ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset.fpregset);
1934 }
1935 fill_fpregset (&pi->fpregset.fpregset, regno);
1936 ioctl (pi->ctl_fd, PIOCSFPREG, &pi->fpregset.fpregset);
1937 #endif /* PROCFS_USE_READ_WRITE */
1938
1939 #endif /* FP0_REGNUM */
1940
1941 }
1942
1943 /*
1944
1945 LOCAL FUNCTION
1946
1947 init_procinfo - setup a procinfo struct and connect it to a process
1948
1949 SYNOPSIS
1950
1951 struct procinfo * init_procinfo (int pid)
1952
1953 DESCRIPTION
1954
1955 Allocate a procinfo structure, open the /proc file and then set up the
1956 set of signals and faults that are to be traced. Returns a pointer to
1957 the new procinfo structure.
1958
1959 NOTES
1960
1961 If proc_init_failed ever gets called, control returns to the command
1962 processing loop via the standard error handling code.
1963
1964 */
1965
1966 static struct procinfo *
1967 init_procinfo (pid, kill)
1968 int pid;
1969 int kill;
1970 {
1971 struct procinfo *pi = (struct procinfo *)
1972 xmalloc (sizeof (struct procinfo));
1973
1974 memset ((char *) pi, 0, sizeof (*pi));
1975 if (!open_proc_file (pid, pi, O_RDWR, 1))
1976 proc_init_failed (pi, "can't open process file", kill);
1977
1978 /* open_proc_file may modify pid. */
1979
1980 pid = pi -> pid;
1981
1982 /* Add new process to process info list */
1983
1984 pi->next = procinfo_list;
1985 procinfo_list = pi;
1986
1987 add_fd (pi); /* Add to list for poll/select */
1988
1989 /* Remember some things about the inferior that we will, or might, change
1990 so that we can restore them when we detach. */
1991 #ifdef UNIXWARE
1992 memcpy ((char *) &pi->saved_trace.sigset,
1993 (char *) &pi->prstatus.pr_sigtrace, sizeof (sigset_t));
1994 memcpy ((char *) &pi->saved_fltset.fltset,
1995 (char *) &pi->prstatus.pr_flttrace, sizeof (fltset_t));
1996 memcpy ((char *) &pi->saved_entryset.sysset,
1997 (char *) &pi->prstatus.pr_sysentry, sizeof (sysset_t));
1998 memcpy ((char *) &pi->saved_exitset.sysset,
1999 (char *) &pi->prstatus.pr_sysexit, sizeof (sysset_t));
2000
2001 /* Set up trace and fault sets, as gdb expects them. */
2002
2003 prfillset (&sctl.sigset);
2004 notice_signals (pi, &sctl);
2005 prfillset (&fctl.fltset);
2006 prdelset (&fctl.fltset, FLTPAGE);
2007
2008 #else /* ! UNIXWARE */
2009 ioctl (pi->ctl_fd, PIOCGTRACE, &pi->saved_trace.sigset);
2010 ioctl (pi->ctl_fd, PIOCGHOLD, &pi->saved_sighold.sigset);
2011 ioctl (pi->ctl_fd, PIOCGFAULT, &pi->saved_fltset.fltset);
2012 ioctl (pi->ctl_fd, PIOCGENTRY, &pi->saved_entryset.sysset);
2013 ioctl (pi->ctl_fd, PIOCGEXIT, &pi->saved_exitset.sysset);
2014
2015 /* Set up trace and fault sets, as gdb expects them. */
2016
2017 memset ((char *) &pi->prrun, 0, sizeof (pi->prrun));
2018 prfillset (&pi->prrun.pr_trace);
2019 procfs_notice_signals (pid);
2020 prfillset (&pi->prrun.pr_fault);
2021 prdelset (&pi->prrun.pr_fault, FLTPAGE);
2022 #ifdef PROCFS_DONT_TRACE_FAULTS
2023 premptyset (&pi->prrun.pr_fault);
2024 #endif
2025 #endif /* UNIXWARE */
2026
2027 if (!procfs_read_status (pi))
2028 proc_init_failed (pi, "procfs_read_status failed", kill);
2029
2030 return pi;
2031 }
2032
2033 /*
2034
2035 LOCAL FUNCTION
2036
2037 create_procinfo - initialize access to a /proc entry
2038
2039 SYNOPSIS
2040
2041 struct procinfo * create_procinfo (int pid)
2042
2043 DESCRIPTION
2044
2045 Allocate a procinfo structure, open the /proc file and then set up the
2046 set of signals and faults that are to be traced. Returns a pointer to
2047 the new procinfo structure.
2048
2049 NOTES
2050
2051 If proc_init_failed ever gets called, control returns to the command
2052 processing loop via the standard error handling code.
2053
2054 */
2055
2056 static struct procinfo *
2057 create_procinfo (pid)
2058 int pid;
2059 {
2060 struct procinfo *pi;
2061 struct sig_ctl sctl;
2062 struct flt_ctl fctl;
2063
2064 pi = find_procinfo (pid, 1);
2065 if (pi != NULL)
2066 return pi; /* All done! It already exists */
2067
2068 pi = init_procinfo (pid, 1);
2069
2070 #ifndef UNIXWARE
2071 /* A bug in Solaris (2.5 at least) causes PIOCWSTOP to hang on LWPs that are
2072 already stopped, even if they all have PR_ASYNC set. */
2073 if (!(pi->prstatus.pr_flags & PR_STOPPED))
2074 #endif
2075 if (!procfs_write_pcwstop (pi))
2076 proc_init_failed (pi, "procfs_write_pcwstop failed", 1);
2077
2078 #ifdef PROCFS_USE_READ_WRITE
2079 fctl.cmd = PCSFAULT;
2080 if (write (pi->ctl_fd, (char *) &fctl, sizeof (struct flt_ctl)) < 0)
2081 proc_init_failed (pi, "PCSFAULT failed", 1);
2082 #else
2083 if (ioctl (pi->ctl_fd, PIOCSFAULT, &pi->prrun.pr_fault) < 0)
2084 proc_init_failed (pi, "PIOCSFAULT failed", 1);
2085 #endif
2086
2087 return pi;
2088 }
2089
2090 /*
2091
2092 LOCAL FUNCTION
2093
2094 procfs_exit_handler - handle entry into the _exit syscall
2095
2096 SYNOPSIS
2097
2098 int procfs_exit_handler (pi, syscall_num, why, rtnvalp, statvalp)
2099
2100 DESCRIPTION
2101
2102 This routine is called when an inferior process enters the _exit()
2103 system call. It continues the process, and then collects the exit
2104 status and pid which are returned in *statvalp and *rtnvalp. After
2105 that it returns non-zero to indicate that procfs_wait should wake up.
2106
2107 NOTES
2108 There is probably a better way to do this.
2109
2110 */
2111
2112 static int
2113 procfs_exit_handler (pi, syscall_num, why, rtnvalp, statvalp)
2114 struct procinfo *pi;
2115 int syscall_num;
2116 int why;
2117 int *rtnvalp;
2118 int *statvalp;
2119 {
2120 struct procinfo *temp_pi, *next_pi;
2121
2122 pi->prrun.pr_flags = PRCFAULT;
2123
2124 if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
2125 perror_with_name (pi->pathname);
2126
2127 if (attach_flag)
2128 {
2129 /* Claim it exited (don't call wait). */
2130 if (info_verbose)
2131 printf_filtered ("(attached process has exited)\n");
2132 *statvalp = 0;
2133 *rtnvalp = inferior_pid;
2134 }
2135 else
2136 {
2137 *rtnvalp = wait (statvalp);
2138 if (*rtnvalp >= 0)
2139 *rtnvalp = pi->pid;
2140 }
2141
2142 /* Close ALL open proc file handles,
2143 except the one that called SYS_exit. */
2144 for (temp_pi = procinfo_list; temp_pi; temp_pi = next_pi)
2145 {
2146 next_pi = temp_pi->next;
2147 if (temp_pi == pi)
2148 continue; /* Handled below */
2149 close_proc_file (temp_pi);
2150 }
2151 return 1;
2152 }
2153
2154 /*
2155
2156 LOCAL FUNCTION
2157
2158 procfs_exec_handler - handle exit from the exec family of syscalls
2159
2160 SYNOPSIS
2161
2162 int procfs_exec_handler (pi, syscall_num, why, rtnvalp, statvalp)
2163
2164 DESCRIPTION
2165
2166 This routine is called when an inferior process is about to finish any
2167 of the exec() family of system calls. It pretends that we got a
2168 SIGTRAP (for compatibility with ptrace behavior), and returns non-zero
2169 to tell procfs_wait to wake up.
2170
2171 NOTES
2172 This need for compatibility with ptrace is questionable. In the
2173 future, it shouldn't be necessary.
2174
2175 */
2176
2177 static int
2178 procfs_exec_handler (pi, syscall_num, why, rtnvalp, statvalp)
2179 struct procinfo *pi;
2180 int syscall_num;
2181 int why;
2182 int *rtnvalp;
2183 int *statvalp;
2184 {
2185 *statvalp = (SIGTRAP << 8) | 0177;
2186
2187 return 1;
2188 }
2189
2190 #if defined(SYS_sproc) && !defined(UNIXWARE)
2191 /* IRIX lwp creation system call */
2192
2193 /*
2194
2195 LOCAL FUNCTION
2196
2197 procfs_sproc_handler - handle exit from the sproc syscall
2198
2199 SYNOPSIS
2200
2201 int procfs_sproc_handler (pi, syscall_num, why, rtnvalp, statvalp)
2202
2203 DESCRIPTION
2204
2205 This routine is called when an inferior process is about to finish an
2206 sproc() system call. This is the system call that IRIX uses to create
2207 a lightweight process. When the target process gets this event, we can
2208 look at rval1 to find the new child processes ID, and create a new
2209 procinfo struct from that.
2210
2211 After that, it pretends that we got a SIGTRAP, and returns non-zero
2212 to tell procfs_wait to wake up. Subsequently, wait_for_inferior gets
2213 woken up, sees the new process and continues it.
2214
2215 NOTES
2216 We actually never see the child exiting from sproc because we will
2217 shortly stop the child with PIOCSTOP, which is then registered as the
2218 event of interest.
2219 */
2220
2221 static int
2222 procfs_sproc_handler (pi, syscall_num, why, rtnvalp, statvalp)
2223 struct procinfo *pi;
2224 int syscall_num;
2225 int why;
2226 int *rtnvalp;
2227 int *statvalp;
2228 {
2229 /* We've just detected the completion of an sproc system call. Now we need to
2230 setup a procinfo struct for this thread, and notify the thread system of the
2231 new arrival. */
2232
2233 /* If sproc failed, then nothing interesting happened. Continue the process
2234 and go back to sleep. */
2235
2236 if (pi->prstatus.pr_errno != 0)
2237 {
2238 pi->prrun.pr_flags &= PRSTEP;
2239 pi->prrun.pr_flags |= PRCFAULT;
2240
2241 if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
2242 perror_with_name (pi->pathname);
2243
2244 return 0;
2245 }
2246
2247 /* At this point, the new thread is stopped at it's first instruction, and
2248 the parent is stopped at the exit from sproc. */
2249
2250 /* Notify the caller of the arrival of a new thread. */
2251 create_procinfo (pi->prstatus.pr_rval1);
2252
2253 *rtnvalp = pi->prstatus.pr_rval1;
2254 *statvalp = (SIGTRAP << 8) | 0177;
2255
2256 return 1;
2257 }
2258
2259 /*
2260
2261 LOCAL FUNCTION
2262
2263 procfs_fork_handler - handle exit from the fork syscall
2264
2265 SYNOPSIS
2266
2267 int procfs_fork_handler (pi, syscall_num, why, rtnvalp, statvalp)
2268
2269 DESCRIPTION
2270
2271 This routine is called when an inferior process is about to finish a
2272 fork() system call. We will open up the new process, and then close
2273 it, which releases it from the clutches of the debugger.
2274
2275 After that, we continue the target process as though nothing had
2276 happened.
2277
2278 NOTES
2279 This is necessary for IRIX because we have to set PR_FORK in order
2280 to catch the creation of lwps (via sproc()). When an actual fork
2281 occurs, it becomes necessary to reset the forks debugger flags and
2282 continue it because we can't hack multiple processes yet.
2283 */
2284
2285 static int
2286 procfs_fork_handler (pi, syscall_num, why, rtnvalp, statvalp)
2287 struct procinfo *pi;
2288 int syscall_num;
2289 int why;
2290 int *rtnvalp;
2291 int *statvalp;
2292 {
2293 struct procinfo *pitemp;
2294
2295 /* At this point, we've detected the completion of a fork (or vfork) call in
2296 our child. The grandchild is also stopped because we set inherit-on-fork
2297 earlier. (Note that nobody has the grandchilds' /proc file open at this
2298 point.) We will release the grandchild from the debugger by opening it's
2299 /proc file and then closing it. Since run-on-last-close is set, the
2300 grandchild continues on its' merry way. */
2301
2302
2303 pitemp = create_procinfo (pi->prstatus.pr_rval1);
2304 if (pitemp)
2305 close_proc_file (pitemp);
2306
2307 if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
2308 perror_with_name (pi->pathname);
2309
2310 return 0;
2311 }
2312 #endif /* SYS_sproc && !UNIXWARE */
2313
2314 /*
2315
2316 LOCAL FUNCTION
2317
2318 procfs_set_inferior_syscall_traps - setup the syscall traps
2319
2320 SYNOPSIS
2321
2322 void procfs_set_inferior_syscall_traps (struct procinfo *pip)
2323
2324 DESCRIPTION
2325
2326 Called for each "procinfo" (process, thread, or LWP) in the
2327 inferior, to register for notification of and handlers for
2328 syscall traps in the inferior.
2329
2330 */
2331
2332 static void
2333 procfs_set_inferior_syscall_traps (pip)
2334 struct procinfo *pip;
2335 {
2336 procfs_set_syscall_trap (pip, SYS_exit, PROCFS_SYSCALL_ENTRY,
2337 procfs_exit_handler);
2338
2339 #ifndef PRFS_STOPEXEC
2340 #ifdef SYS_exec
2341 procfs_set_syscall_trap (pip, SYS_exec, PROCFS_SYSCALL_EXIT,
2342 procfs_exec_handler);
2343 #endif
2344 #ifdef SYS_execv
2345 procfs_set_syscall_trap (pip, SYS_execv, PROCFS_SYSCALL_EXIT,
2346 procfs_exec_handler);
2347 #endif
2348 #ifdef SYS_execve
2349 procfs_set_syscall_trap (pip, SYS_execve, PROCFS_SYSCALL_EXIT,
2350 procfs_exec_handler);
2351 #endif
2352 #endif /* PRFS_STOPEXEC */
2353
2354 /* Setup traps on exit from sproc() */
2355
2356 #ifdef SYS_sproc
2357 procfs_set_syscall_trap (pip, SYS_sproc, PROCFS_SYSCALL_EXIT,
2358 procfs_sproc_handler);
2359 procfs_set_syscall_trap (pip, SYS_fork, PROCFS_SYSCALL_EXIT,
2360 procfs_fork_handler);
2361 #ifdef SYS_vfork
2362 procfs_set_syscall_trap (pip, SYS_vfork, PROCFS_SYSCALL_EXIT,
2363 procfs_fork_handler);
2364 #endif
2365 /* Turn on inherit-on-fork flag so that all children of the target process
2366 start with tracing flags set. This allows us to trap lwp creation. Note
2367 that we also have to trap on fork and vfork in order to disable all tracing
2368 in the targets child processes. */
2369
2370 modify_inherit_on_fork_flag (pip->ctl_fd, 1);
2371 #endif
2372
2373 #ifdef SYS_lwp_create
2374 procfs_set_syscall_trap (pip, SYS_lwp_create, PROCFS_SYSCALL_EXIT,
2375 procfs_lwp_creation_handler);
2376 #endif
2377 }
2378
2379 /*
2380
2381 LOCAL FUNCTION
2382
2383 procfs_init_inferior - initialize target vector and access to a
2384 /proc entry
2385
2386 SYNOPSIS
2387
2388 int procfs_init_inferior (int pid)
2389
2390 DESCRIPTION
2391
2392 When gdb starts an inferior, this function is called in the parent
2393 process immediately after the fork. It waits for the child to stop
2394 on the return from the exec system call (the child itself takes care
2395 of ensuring that this is set up), then sets up the set of signals
2396 and faults that are to be traced. Returns the pid, which may have had
2397 the thread-id added to it.
2398
2399 NOTES
2400
2401 If proc_init_failed ever gets called, control returns to the command
2402 processing loop via the standard error handling code.
2403
2404 */
2405
2406 static int
2407 procfs_init_inferior (pid)
2408 int pid;
2409 {
2410 struct procinfo *pip;
2411
2412 push_target (&procfs_ops);
2413
2414 pip = create_procinfo (pid);
2415
2416 procfs_set_inferior_syscall_traps (pip);
2417
2418 /* create_procinfo may change the pid, so we have to update inferior_pid
2419 here before calling other gdb routines that need the right pid. */
2420
2421 pid = pip -> pid;
2422 inferior_pid = pid;
2423
2424 add_thread (pip -> pid); /* Setup initial thread */
2425
2426 #ifdef START_INFERIOR_TRAPS_EXPECTED
2427 startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
2428 #else
2429 /* One trap to exec the shell, one to exec the program being debugged. */
2430 startup_inferior (2);
2431 #endif
2432
2433 return pid;
2434 }
2435
2436 /*
2437
2438 GLOBAL FUNCTION
2439
2440 procfs_notice_signals
2441
2442 SYNOPSIS
2443
2444 static void procfs_notice_signals (int pid);
2445
2446 DESCRIPTION
2447
2448 When the user changes the state of gdb's signal handling via the
2449 "handle" command, this function gets called to see if any change
2450 in the /proc interface is required. It is also called internally
2451 by other /proc interface functions to initialize the state of
2452 the traced signal set.
2453
2454 One thing it does is that signals for which the state is "nostop",
2455 "noprint", and "pass", have their trace bits reset in the pr_trace
2456 field, so that they are no longer traced. This allows them to be
2457 delivered directly to the inferior without the debugger ever being
2458 involved.
2459 */
2460
2461 static void
2462 procfs_notice_signals (pid)
2463 int pid;
2464 {
2465 struct procinfo *pi;
2466 struct sig_ctl sctl;
2467
2468 pi = find_procinfo (pid, 0);
2469
2470 #ifdef UNIXWARE
2471 premptyset (&sctl.sigset);
2472 #else
2473 sctl.sigset = pi->prrun.pr_trace;
2474 #endif
2475
2476 notice_signals (pi, &sctl);
2477
2478 #ifndef UNIXWARE
2479 pi->prrun.pr_trace = sctl.sigset;
2480 #endif
2481 }
2482
2483 static void
2484 notice_signals (pi, sctl)
2485 struct procinfo *pi;
2486 struct sig_ctl *sctl;
2487 {
2488 int signo;
2489
2490 for (signo = 0; signo < NSIG; signo++)
2491 {
2492 if (signal_stop_state (target_signal_from_host (signo)) == 0 &&
2493 signal_print_state (target_signal_from_host (signo)) == 0 &&
2494 signal_pass_state (target_signal_from_host (signo)) == 1)
2495 {
2496 prdelset (&sctl->sigset, signo);
2497 }
2498 else
2499 {
2500 praddset (&sctl->sigset, signo);
2501 }
2502 }
2503 #ifdef PROCFS_USE_READ_WRITE
2504 sctl->cmd = PCSTRACE;
2505 if (write (pi->ctl_fd, (char *) sctl, sizeof (struct sig_ctl)) < 0)
2506 #else
2507 if (ioctl (pi->ctl_fd, PIOCSTRACE, &sctl->sigset))
2508 #endif
2509 {
2510 print_sys_errmsg ("PIOCSTRACE failed", errno);
2511 }
2512 }
2513
2514 /*
2515
2516 LOCAL FUNCTION
2517
2518 proc_set_exec_trap -- arrange for exec'd child to halt at startup
2519
2520 SYNOPSIS
2521
2522 void proc_set_exec_trap (void)
2523
2524 DESCRIPTION
2525
2526 This function is called in the child process when starting up
2527 an inferior, prior to doing the exec of the actual inferior.
2528 It sets the child process's exitset to make exit from the exec
2529 system call an event of interest to stop on, and then simply
2530 returns. The child does the exec, the system call returns, and
2531 the child stops at the first instruction, ready for the gdb
2532 parent process to take control of it.
2533
2534 NOTE
2535
2536 We need to use all local variables since the child may be sharing
2537 it's data space with the parent, if vfork was used rather than
2538 fork.
2539
2540 Also note that we want to turn off the inherit-on-fork flag in
2541 the child process so that any grand-children start with all
2542 tracing flags cleared.
2543 */
2544
2545 static void
2546 proc_set_exec_trap ()
2547 {
2548 struct sys_ctl exitset;
2549 struct sys_ctl entryset;
2550 char procname[MAX_PROC_NAME_SIZE];
2551 int fd;
2552
2553 sprintf (procname, CTL_PROC_NAME_FMT, getpid ());
2554 #ifdef UNIXWARE
2555 if ((fd = open (procname, O_WRONLY)) < 0)
2556 #else
2557 if ((fd = open (procname, O_RDWR)) < 0)
2558 #endif
2559 {
2560 perror (procname);
2561 gdb_flush (gdb_stderr);
2562 _exit (127);
2563 }
2564 premptyset (&exitset.sysset);
2565 premptyset (&entryset.sysset);
2566
2567 #ifdef PRFS_STOPEXEC
2568 /* Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
2569 exits from exec system calls because of the user level loader. */
2570 {
2571 int prfs_flags;
2572
2573 if (ioctl (fd, PIOCGSPCACT, &prfs_flags) < 0)
2574 {
2575 perror (procname);
2576 gdb_flush (gdb_stderr);
2577 _exit (127);
2578 }
2579 prfs_flags |= PRFS_STOPEXEC;
2580 if (ioctl (fd, PIOCSSPCACT, &prfs_flags) < 0)
2581 {
2582 perror (procname);
2583 gdb_flush (gdb_stderr);
2584 _exit (127);
2585 }
2586 }
2587 #else /* PRFS_STOPEXEC */
2588 /* GW: Rationale...
2589 Not all systems with /proc have all the exec* syscalls with the same
2590 names. On the SGI, for example, there is no SYS_exec, but there
2591 *is* a SYS_execv. So, we try to account for that. */
2592
2593 #ifdef SYS_exec
2594 praddset (&exitset.sysset, SYS_exec);
2595 #endif
2596 #ifdef SYS_execve
2597 praddset (&exitset.sysset, SYS_execve);
2598 #endif
2599 #ifdef SYS_execv
2600 praddset (&exitset.sysset, SYS_execv);
2601 #endif
2602
2603 #ifdef PROCFS_USE_READ_WRITE
2604 exitset.cmd = PCSEXIT;
2605 if (write (fd, (char *) &exitset, sizeof (struct sys_ctl)) < 0)
2606 #else
2607 if (ioctl (fd, PIOCSEXIT, &exitset.sysset) < 0)
2608 #endif
2609 {
2610 perror (procname);
2611 gdb_flush (gdb_stderr);
2612 _exit (127);
2613 }
2614 #endif /* PRFS_STOPEXEC */
2615
2616 praddset (&entryset.sysset, SYS_exit);
2617
2618 #ifdef PROCFS_USE_READ_WRITE
2619 entryset.cmd = PCSENTRY;
2620 if (write (fd, (char *) &entryset, sizeof (struct sys_ctl)) < 0)
2621 #else
2622 if (ioctl (fd, PIOCSENTRY, &entryset.sysset) < 0)
2623 #endif
2624 {
2625 perror (procname);
2626 gdb_flush (gdb_stderr);
2627 _exit (126);
2628 }
2629
2630 /* Turn off inherit-on-fork flag so that all grand-children of gdb
2631 start with tracing flags cleared. */
2632
2633 modify_inherit_on_fork_flag (fd, 0);
2634
2635 /* Turn on run-on-last-close flag so that this process will not hang
2636 if GDB goes away for some reason. */
2637
2638 modify_run_on_last_close_flag (fd, 1);
2639
2640 #ifdef PR_ASYNC
2641 {
2642 long pr_flags;
2643 struct proc_ctl pctl;
2644
2645 /* Solaris needs this to make procfs treat all threads seperately. Without
2646 this, all threads halt whenever something happens to any thread. Since
2647 GDB wants to control all this itself, it needs to set PR_ASYNC. */
2648
2649 pr_flags = PR_ASYNC;
2650 #ifdef PROCFS_USE_READ_WRITE
2651 pctl.cmd = PCSET;
2652 pctl.data = PR_FORK|PR_ASYNC;
2653 write (fd, (char *) &pctl, sizeof (struct proc_ctl));
2654 #else
2655 ioctl (fd, PIOCSET, &pr_flags);
2656 #endif
2657 }
2658 #endif /* PR_ASYNC */
2659 }
2660
2661 /*
2662
2663 GLOBAL FUNCTION
2664
2665 proc_iterate_over_mappings -- call function for every mapped space
2666
2667 SYNOPSIS
2668
2669 int proc_iterate_over_mappings (int (*func)())
2670
2671 DESCRIPTION
2672
2673 Given a pointer to a function, call that function for every
2674 mapped address space, passing it an open file descriptor for
2675 the file corresponding to that mapped address space (if any)
2676 and the base address of the mapped space. Quit when we hit
2677 the end of the mappings or the function returns nonzero.
2678 */
2679
2680 #ifdef UNIXWARE
2681 int
2682 proc_iterate_over_mappings (func)
2683 int (*func) PARAMS ((int, CORE_ADDR));
2684 {
2685 int nmap;
2686 int fd;
2687 int funcstat = 0;
2688 prmap_t *prmaps;
2689 prmap_t *prmap;
2690 struct procinfo *pi;
2691 struct stat sbuf;
2692
2693 pi = current_procinfo;
2694
2695 if (fstat (pi->map_fd, &sbuf) < 0)
2696 return 0;
2697
2698 nmap = sbuf.st_size / sizeof (prmap_t);
2699 prmaps = (prmap_t *) alloca (nmap * sizeof(prmap_t));
2700 if ((lseek (pi->map_fd, 0, SEEK_SET) == 0) &&
2701 (read (pi->map_fd, (char *) prmaps, nmap * sizeof (prmap_t)) ==
2702 (nmap * sizeof (prmap_t))))
2703 {
2704 int i = 0;
2705 for (prmap = prmaps; i < nmap && funcstat == 0; ++prmap, ++i)
2706 {
2707 char name[sizeof ("/proc/1234567890/object") +
2708 sizeof (prmap->pr_mapname)];
2709 sprintf (name, "/proc/%d/object/%s", pi->pid, prmap->pr_mapname);
2710 if ((fd = open (name, O_RDONLY)) == -1)
2711 {
2712 funcstat = 1;
2713 break;
2714 }
2715 funcstat = (*func) (fd, (CORE_ADDR) prmap->pr_vaddr);
2716 close (fd);
2717 }
2718 }
2719 return (funcstat);
2720 }
2721 #else /* UNIXWARE */
2722 int
2723 proc_iterate_over_mappings (func)
2724 int (*func) PARAMS ((int, CORE_ADDR));
2725 {
2726 int nmap;
2727 int fd;
2728 int funcstat = 0;
2729 struct prmap *prmaps;
2730 struct prmap *prmap;
2731 struct procinfo *pi;
2732
2733 pi = current_procinfo;
2734
2735 if (ioctl (pi->map_fd, PIOCNMAP, &nmap) == 0)
2736 {
2737 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
2738 if (ioctl (pi->map_fd, PIOCMAP, prmaps) == 0)
2739 {
2740 for (prmap = prmaps; prmap -> pr_size && funcstat == 0; ++prmap)
2741 {
2742 fd = proc_address_to_fd (pi, (CORE_ADDR) prmap -> pr_vaddr, 0);
2743 funcstat = (*func) (fd, (CORE_ADDR) prmap -> pr_vaddr);
2744 close (fd);
2745 }
2746 }
2747 }
2748 return (funcstat);
2749 }
2750 #endif /* UNIXWARE */
2751
2752 #if 0 /* Currently unused */
2753 /*
2754
2755 GLOBAL FUNCTION
2756
2757 proc_base_address -- find base address for segment containing address
2758
2759 SYNOPSIS
2760
2761 CORE_ADDR proc_base_address (CORE_ADDR addr)
2762
2763 DESCRIPTION
2764
2765 Given an address of a location in the inferior, find and return
2766 the base address of the mapped segment containing that address.
2767
2768 This is used for example, by the shared library support code,
2769 where we have the pc value for some location in the shared library
2770 where we are stopped, and need to know the base address of the
2771 segment containing that address.
2772 */
2773
2774 CORE_ADDR
2775 proc_base_address (addr)
2776 CORE_ADDR addr;
2777 {
2778 int nmap;
2779 struct prmap *prmaps;
2780 struct prmap *prmap;
2781 CORE_ADDR baseaddr = 0;
2782 struct procinfo *pi;
2783
2784 pi = current_procinfo;
2785
2786 if (ioctl (pi->map_fd, PIOCNMAP, &nmap) == 0)
2787 {
2788 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
2789 if (ioctl (pi->map_fd, PIOCMAP, prmaps) == 0)
2790 {
2791 for (prmap = prmaps; prmap -> pr_size; ++prmap)
2792 {
2793 if ((prmap -> pr_vaddr <= (caddr_t) addr) &&
2794 (prmap -> pr_vaddr + prmap -> pr_size > (caddr_t) addr))
2795 {
2796 baseaddr = (CORE_ADDR) prmap -> pr_vaddr;
2797 break;
2798 }
2799 }
2800 }
2801 }
2802 return (baseaddr);
2803 }
2804
2805 #endif /* 0 */
2806
2807 /*
2808
2809 LOCAL FUNCTION
2810
2811 proc_address_to_fd -- return open fd for file mapped to address
2812
2813 SYNOPSIS
2814
2815 int proc_address_to_fd (struct procinfo *pi, CORE_ADDR addr, complain)
2816
2817 DESCRIPTION
2818
2819 Given an address in the current inferior's address space, use the
2820 /proc interface to find an open file descriptor for the file that
2821 this address was mapped in from. Return -1 if there is no current
2822 inferior. Print a warning message if there is an inferior but
2823 the address corresponds to no file (IE a bogus address).
2824
2825 */
2826
2827 static int
2828 proc_address_to_fd (pi, addr, complain)
2829 struct procinfo *pi;
2830 CORE_ADDR addr;
2831 int complain;
2832 {
2833 int fd = -1;
2834
2835 if ((fd = ioctl (pi->ctl_fd, PIOCOPENM, (caddr_t *) &addr)) < 0)
2836 {
2837 if (complain)
2838 {
2839 print_sys_errmsg (pi->pathname, errno);
2840 warning ("can't find mapped file for address 0x%x", addr);
2841 }
2842 }
2843 return (fd);
2844 }
2845
2846
2847 /* Attach to process PID, then initialize for debugging it
2848 and wait for the trace-trap that results from attaching. */
2849
2850 static void
2851 procfs_attach (args, from_tty)
2852 char *args;
2853 int from_tty;
2854 {
2855 char *exec_file;
2856 int pid;
2857
2858 if (!args)
2859 error_no_arg ("process-id to attach");
2860
2861 pid = atoi (args);
2862
2863 if (pid == getpid()) /* Trying to masturbate? */
2864 error ("I refuse to debug myself!");
2865
2866 if (from_tty)
2867 {
2868 exec_file = (char *) get_exec_file (0);
2869
2870 if (exec_file)
2871 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file, target_pid_to_str (pid));
2872 else
2873 printf_unfiltered ("Attaching to %s\n", target_pid_to_str (pid));
2874
2875 gdb_flush (gdb_stdout);
2876 }
2877
2878 inferior_pid = pid = do_attach (pid);
2879 push_target (&procfs_ops);
2880 }
2881
2882
2883 /* Take a program previously attached to and detaches it.
2884 The program resumes execution and will no longer stop
2885 on signals, etc. We'd better not have left any breakpoints
2886 in the program or it'll die when it hits one. For this
2887 to work, it may be necessary for the process to have been
2888 previously attached. It *might* work if the program was
2889 started via the normal ptrace (PTRACE_TRACEME). */
2890
2891 static void
2892 procfs_detach (args, from_tty)
2893 char *args;
2894 int from_tty;
2895 {
2896 int siggnal = 0;
2897
2898 if (from_tty)
2899 {
2900 char *exec_file = get_exec_file (0);
2901 if (exec_file == 0)
2902 exec_file = "";
2903 printf_unfiltered ("Detaching from program: %s %s\n",
2904 exec_file, target_pid_to_str (inferior_pid));
2905 gdb_flush (gdb_stdout);
2906 }
2907 if (args)
2908 siggnal = atoi (args);
2909
2910 do_detach (siggnal);
2911 inferior_pid = 0;
2912 unpush_target (&procfs_ops); /* Pop out of handling an inferior */
2913 }
2914
2915 /* Get ready to modify the registers array. On machines which store
2916 individual registers, this doesn't need to do anything. On machines
2917 which store all the registers in one fell swoop, this makes sure
2918 that registers contains all the registers from the program being
2919 debugged. */
2920
2921 static void
2922 procfs_prepare_to_store ()
2923 {
2924 #ifdef CHILD_PREPARE_TO_STORE
2925 CHILD_PREPARE_TO_STORE ();
2926 #endif
2927 }
2928
2929 /* Print status information about what we're accessing. */
2930
2931 static void
2932 procfs_files_info (ignore)
2933 struct target_ops *ignore;
2934 {
2935 printf_unfiltered ("\tUsing the running image of %s %s via /proc.\n",
2936 attach_flag? "attached": "child", target_pid_to_str (inferior_pid));
2937 }
2938
2939 /* ARGSUSED */
2940 static void
2941 procfs_open (arg, from_tty)
2942 char *arg;
2943 int from_tty;
2944 {
2945 error ("Use the \"run\" command to start a Unix child process.");
2946 }
2947
2948 /*
2949
2950 LOCAL FUNCTION
2951
2952 do_attach -- attach to an already existing process
2953
2954 SYNOPSIS
2955
2956 int do_attach (int pid)
2957
2958 DESCRIPTION
2959
2960 Attach to an already existing process with the specified process
2961 id. If the process is not already stopped, query whether to
2962 stop it or not.
2963
2964 NOTES
2965
2966 The option of stopping at attach time is specific to the /proc
2967 versions of gdb. Versions using ptrace force the attachee
2968 to stop. (I have changed this version to do so, too. All you
2969 have to do is "continue" to make it go on. -- gnu@cygnus.com)
2970
2971 */
2972
2973 static int
2974 do_attach (pid)
2975 int pid;
2976 {
2977 struct procinfo *pi;
2978 struct sig_ctl sctl;
2979 struct flt_ctl fctl;
2980 int nlwp, *lwps;
2981
2982 pi = init_procinfo (pid, 0);
2983
2984 #ifdef PIOCLWPIDS
2985 nlwp = pi->prstatus.pr_nlwp;
2986 lwps = alloca ((2 * nlwp + 2) * sizeof (id_t));
2987
2988 if (ioctl (pi->ctl_fd, PIOCLWPIDS, lwps))
2989 {
2990 print_sys_errmsg (pi -> pathname, errno);
2991 error ("PIOCLWPIDS failed");
2992 }
2993 #else /* PIOCLWPIDS */
2994 nlwp = 1;
2995 lwps = alloca ((2 * nlwp + 2) * sizeof *lwps);
2996 lwps[0] = 0;
2997 #endif
2998 for (; nlwp > 0; nlwp--, lwps++)
2999 {
3000 /* First one has already been created above. */
3001 if ((pi = find_procinfo ((*lwps << 16) | pid, 1)) == 0)
3002 pi = init_procinfo ((*lwps << 16) | pid, 0);
3003
3004 #ifdef UNIXWARE
3005 if (pi->prstatus.pr_lwp.pr_flags & (PR_STOPPED | PR_ISTOP))
3006 #else
3007 if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
3008 #endif
3009 {
3010 pi->was_stopped = 1;
3011 }
3012 else
3013 {
3014 pi->was_stopped = 0;
3015 if (1 || query ("Process is currently running, stop it? "))
3016 {
3017 long cmd;
3018 /* Make it run again when we close it. */
3019 modify_run_on_last_close_flag (pi->ctl_fd, 1);
3020 #ifdef PROCFS_USE_READ_WRITE
3021 cmd = PCSTOP;
3022 if (write (pi->ctl_fd, (char *) &cmd, sizeof (long)) < 0)
3023 #else
3024 if (ioctl (pi->ctl_fd, PIOCSTOP, &pi->prstatus) < 0)
3025 #endif
3026 {
3027 print_sys_errmsg (pi->pathname, errno);
3028 close_proc_file (pi);
3029 error ("PIOCSTOP failed");
3030 }
3031 #ifdef UNIXWARE
3032 if (!procfs_read_status (pi))
3033 {
3034 print_sys_errmsg (pi->pathname, errno);
3035 close_proc_file (pi);
3036 error ("procfs_read_status failed");
3037 }
3038 #endif
3039 pi->nopass_next_sigstop = 1;
3040 }
3041 else
3042 {
3043 printf_unfiltered ("Ok, gdb will wait for %s to stop.\n",
3044 target_pid_to_str (pi->pid));
3045 }
3046 }
3047
3048 #ifdef PROCFS_USE_READ_WRITE
3049 fctl.cmd = PCSFAULT;
3050 if (write (pi->ctl_fd, (char *) &fctl, sizeof (struct flt_ctl)) < 0)
3051 print_sys_errmsg ("PCSFAULT failed", errno);
3052 #else /* PROCFS_USE_READ_WRITE */
3053 if (ioctl (pi->ctl_fd, PIOCSFAULT, &pi->prrun.pr_fault))
3054 {
3055 print_sys_errmsg ("PIOCSFAULT failed", errno);
3056 }
3057 if (ioctl (pi->ctl_fd, PIOCSTRACE, &pi->prrun.pr_trace))
3058 {
3059 print_sys_errmsg ("PIOCSTRACE failed", errno);
3060 }
3061 add_thread (pi->pid);
3062 procfs_set_inferior_syscall_traps (pi);
3063 }
3064 #endif /* PROCFS_USE_READ_WRITE */
3065 attach_flag = 1;
3066 return (pi->pid);
3067 }
3068
3069 /*
3070
3071 LOCAL FUNCTION
3072
3073 do_detach -- detach from an attached-to process
3074
3075 SYNOPSIS
3076
3077 void do_detach (int signal)
3078
3079 DESCRIPTION
3080
3081 Detach from the current attachee.
3082
3083 If signal is non-zero, the attachee is started running again and sent
3084 the specified signal.
3085
3086 If signal is zero and the attachee was not already stopped when we
3087 attached to it, then we make it runnable again when we detach.
3088
3089 Otherwise, we query whether or not to make the attachee runnable
3090 again, since we may simply want to leave it in the state it was in
3091 when we attached.
3092
3093 We report any problems, but do not consider them errors, since we
3094 MUST detach even if some things don't seem to go right. This may not
3095 be the ideal situation. (FIXME).
3096 */
3097
3098 static void
3099 do_detach (signal)
3100 int signal;
3101 {
3102 struct procinfo *pi;
3103
3104 for (pi = procinfo_list; pi; pi = pi->next)
3105 {
3106 if (signal)
3107 {
3108 set_proc_siginfo (pi, signal);
3109 }
3110 #ifdef PROCFS_USE_READ_WRITE
3111 pi->saved_exitset.cmd = PCSEXIT;
3112 if (write (pi->ctl_fd, (char *) &pi->saved_exitset,
3113 sizeof (struct sys_ctl)) < 0)
3114 #else
3115 if (ioctl (pi->ctl_fd, PIOCSEXIT, &pi->saved_exitset.sysset) < 0)
3116 #endif
3117 {
3118 print_sys_errmsg (pi->pathname, errno);
3119 printf_unfiltered ("PIOCSEXIT failed.\n");
3120 }
3121 #ifdef PROCFS_USE_READ_WRITE
3122 pi->saved_entryset.cmd = PCSENTRY;
3123 if (write (pi->ctl_fd, (char *) &pi->saved_entryset,
3124 sizeof (struct sys_ctl)) < 0)
3125 #else
3126 if (ioctl (pi->ctl_fd, PIOCSENTRY, &pi->saved_entryset.sysset) < 0)
3127 #endif
3128 {
3129 print_sys_errmsg (pi->pathname, errno);
3130 printf_unfiltered ("PIOCSENTRY failed.\n");
3131 }
3132 #ifdef PROCFS_USE_READ_WRITE
3133 pi->saved_trace.cmd = PCSTRACE;
3134 if (write (pi->ctl_fd, (char *) &pi->saved_trace,
3135 sizeof (struct sig_ctl)) < 0)
3136 #else
3137 if (ioctl (pi->ctl_fd, PIOCSTRACE, &pi->saved_trace.sigset) < 0)
3138 #endif
3139 {
3140 print_sys_errmsg (pi->pathname, errno);
3141 printf_unfiltered ("PIOCSTRACE failed.\n");
3142 }
3143 #ifndef UNIXWARE
3144 if (ioctl (pi->ctl_fd, PIOCSHOLD, &pi->saved_sighold.sigset) < 0)
3145 {
3146 print_sys_errmsg (pi->pathname, errno);
3147 printf_unfiltered ("PIOSCHOLD failed.\n");
3148 }
3149 #endif
3150 #ifdef PROCFS_USE_READ_WRITE
3151 pi->saved_fltset.cmd = PCSFAULT;
3152 if (write (pi->ctl_fd, (char *) &pi->saved_fltset,
3153 sizeof (struct flt_ctl)) < 0)
3154 #else
3155 if (ioctl (pi->ctl_fd, PIOCSFAULT, &pi->saved_fltset.fltset) < 0)
3156 #endif
3157 {
3158 print_sys_errmsg (pi->pathname, errno);
3159 printf_unfiltered ("PIOCSFAULT failed.\n");
3160 }
3161 if (!procfs_read_status (pi))
3162 {
3163 print_sys_errmsg (pi->pathname, errno);
3164 printf_unfiltered ("procfs_read_status failed.\n");
3165 }
3166 else
3167 {
3168 #ifdef UNIXWARE
3169 if (signal || (pi->prstatus.pr_lwp.pr_flags & (PR_STOPPED | PR_ISTOP)))
3170 #else
3171 if (signal || (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)))
3172 #endif
3173 {
3174 long cmd;
3175 struct proc_ctl pctl;
3176
3177 if (signal || !pi->was_stopped ||
3178 query ("Was stopped when attached, make it runnable again? "))
3179 {
3180 /* Clear any pending signal if we want to detach without
3181 a signal. */
3182 if (signal == 0)
3183 set_proc_siginfo (pi, signal);
3184
3185 /* Clear any fault that might have stopped it. */
3186 #ifdef PROCFS_USE_READ_WRITE
3187 cmd = PCCFAULT;
3188 if (write (pi->ctl_fd, (char *) &cmd, sizeof (long)) < 0)
3189 #else
3190 if (ioctl (pi->ctl_fd, PIOCCFAULT, 0))
3191 #endif
3192 {
3193 print_sys_errmsg (pi->pathname, errno);
3194 printf_unfiltered ("PIOCCFAULT failed.\n");
3195 }
3196
3197 /* Make it run again when we close it. */
3198
3199 modify_run_on_last_close_flag (pi->ctl_fd, 1);
3200 }
3201 }
3202 }
3203 close_proc_file (pi);
3204 }
3205 attach_flag = 0;
3206 }
3207
3208 /* emulate wait() as much as possible.
3209 Wait for child to do something. Return pid of child, or -1 in case
3210 of error; store status in *OURSTATUS.
3211
3212 Not sure why we can't
3213 just use wait(), but it seems to have problems when applied to a
3214 process being controlled with the /proc interface.
3215
3216 We have a race problem here with no obvious solution. We need to let
3217 the inferior run until it stops on an event of interest, which means
3218 that we need to use the PIOCWSTOP ioctl. However, we cannot use this
3219 ioctl if the process is already stopped on something that is not an
3220 event of interest, or the call will hang indefinitely. Thus we first
3221 use PIOCSTATUS to see if the process is not stopped. If not, then we
3222 use PIOCWSTOP. But during the window between the two, if the process
3223 stops for any reason that is not an event of interest (such as a job
3224 control signal) then gdb will hang. One possible workaround is to set
3225 an alarm to wake up every minute of so and check to see if the process
3226 is still running, and if so, then reissue the PIOCWSTOP. But this is
3227 a real kludge, so has not been implemented. FIXME: investigate
3228 alternatives.
3229
3230 FIXME: Investigate why wait() seems to have problems with programs
3231 being control by /proc routines. */
3232 static int
3233 procfs_wait (pid, ourstatus)
3234 int pid;
3235 struct target_waitstatus *ourstatus;
3236 {
3237 short what;
3238 short why;
3239 int statval = 0;
3240 int checkerr = 0;
3241 int rtnval = -1;
3242 struct procinfo *pi;
3243 struct proc_ctl pctl;
3244
3245 #ifndef UNIXWARE
3246 if (pid != -1) /* Non-specific process? */
3247 pi = NULL;
3248 else
3249 for (pi = procinfo_list; pi; pi = pi->next)
3250 if (pi->had_event)
3251 break;
3252
3253 if (!pi)
3254 {
3255 wait_again:
3256
3257 if (pi)
3258 pi->had_event = 0;
3259
3260 pi = wait_fd ();
3261 }
3262
3263 if (pid != -1)
3264 for (pi = procinfo_list; pi; pi = pi->next)
3265 if (pi->pid == pid && pi->had_event)
3266 break;
3267 #endif
3268
3269 if (!pi && !checkerr)
3270 goto wait_again;
3271
3272 #ifdef UNIXWARE
3273 if (!checkerr && !(pi->prstatus.pr_lwp.pr_flags & (PR_STOPPED | PR_ISTOP)))
3274 #else
3275 if (!checkerr && !(pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)))
3276 #endif
3277 {
3278 if (!procfs_write_pcwstop (pi))
3279 {
3280 checkerr++;
3281 }
3282 }
3283 if (checkerr)
3284 {
3285 if (errno == ENOENT)
3286 {
3287 /* XXX Fixme -- what to do if attached? Can't call wait... */
3288 rtnval = wait (&statval);
3289 if ((rtnval) != (inferior_pid))
3290 {
3291 print_sys_errmsg (pi->pathname, errno);
3292 error ("procfs_wait: wait failed, returned %d", rtnval);
3293 /* NOTREACHED */
3294 }
3295 }
3296 else
3297 {
3298 print_sys_errmsg (pi->pathname, errno);
3299 error ("PIOCSTATUS or PIOCWSTOP failed.");
3300 /* NOTREACHED */
3301 }
3302 }
3303 else if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
3304 {
3305 #ifdef UNIXWARE
3306 rtnval = pi->prstatus.pr_pid;
3307 why = pi->prstatus.pr_lwp.pr_why;
3308 what = pi->prstatus.pr_lwp.pr_what;
3309 #else
3310 rtnval = pi->pid;
3311 why = pi->prstatus.pr_why;
3312 what = pi->prstatus.pr_what;
3313 #endif
3314
3315 switch (why)
3316 {
3317 case PR_SIGNALLED:
3318 statval = (what << 8) | 0177;
3319 break;
3320 case PR_SYSENTRY:
3321 case PR_SYSEXIT:
3322 {
3323 int i;
3324 int found_handler = 0;
3325
3326 for (i = 0; i < pi->num_syscall_handlers; i++)
3327 if (pi->syscall_handlers[i].syscall_num == what)
3328 {
3329 found_handler = 1;
3330 if (!pi->syscall_handlers[i].func (pi, what, why,
3331 &rtnval, &statval))
3332 goto wait_again;
3333
3334 break;
3335 }
3336
3337 if (!found_handler)
3338 if (why == PR_SYSENTRY)
3339 error ("PR_SYSENTRY, unhandled system call %d", what);
3340 else
3341 error ("PR_SYSEXIT, unhandled system call %d", what);
3342 }
3343 break;
3344 case PR_REQUESTED:
3345 statval = (SIGSTOP << 8) | 0177;
3346 break;
3347 case PR_JOBCONTROL:
3348 statval = (what << 8) | 0177;
3349 break;
3350 case PR_FAULTED:
3351 switch (what)
3352 {
3353 #ifdef FLTWATCH
3354 case FLTWATCH:
3355 statval = (SIGTRAP << 8) | 0177;
3356 break;
3357 #endif
3358 #ifdef FLTKWATCH
3359 case FLTKWATCH:
3360 statval = (SIGTRAP << 8) | 0177;
3361 break;
3362 #endif
3363 #ifndef FAULTED_USE_SIGINFO
3364 /* Irix, contrary to the documentation, fills in 0 for si_signo.
3365 Solaris fills in si_signo. I'm not sure about others. */
3366 case FLTPRIV:
3367 case FLTILL:
3368 statval = (SIGILL << 8) | 0177;
3369 break;
3370 case FLTBPT:
3371 case FLTTRACE:
3372 statval = (SIGTRAP << 8) | 0177;
3373 break;
3374 case FLTSTACK:
3375 case FLTACCESS:
3376 case FLTBOUNDS:
3377 statval = (SIGSEGV << 8) | 0177;
3378 break;
3379 case FLTIOVF:
3380 case FLTIZDIV:
3381 case FLTFPE:
3382 statval = (SIGFPE << 8) | 0177;
3383 break;
3384 case FLTPAGE: /* Recoverable page fault */
3385 #endif /* not FAULTED_USE_SIGINFO */
3386 default:
3387 /* Use the signal which the kernel assigns. This is better than
3388 trying to second-guess it from the fault. In fact, I suspect
3389 that FLTACCESS can be either SIGSEGV or SIGBUS. */
3390 #ifdef UNIXWARE
3391 statval = ((pi->prstatus.pr_lwp.pr_info.si_signo) << 8) | 0177;
3392 #else
3393 statval = ((pi->prstatus.pr_info.si_signo) << 8) | 0177;
3394 #endif
3395 break;
3396 }
3397 break;
3398 default:
3399 error ("PIOCWSTOP, unknown why %d, what %d", why, what);
3400 }
3401 /* Stop all the other threads when any of them stops. */
3402
3403 {
3404 struct procinfo *procinfo, *next_pi;
3405
3406 for (procinfo = procinfo_list; procinfo; procinfo = next_pi)
3407 {
3408 next_pi = procinfo->next;
3409 if (!procinfo->had_event)
3410 {
3411 #ifdef PROCFS_USE_READ_WRITE
3412 cmd = PCSTOP;
3413 if (write (pi->ctl_fd, (char *) &cmd, sizeof (long)) < 0)
3414 {
3415 print_sys_errmsg (procinfo->pathname, errno);
3416 error ("PCSTOP failed");
3417 }
3418 #else
3419 /* A bug in Solaris (2.5) causes us to hang when trying to
3420 stop a stopped process. So, we have to check first in
3421 order to avoid the hang. */
3422 if (!procfs_read_status (procinfo))
3423 {
3424 /* The LWP has apparently terminated. */
3425 if (info_verbose)
3426 printf_filtered ("LWP %d doesn't respond.\n",
3427 (procinfo->pid >> 16) & 0xffff);
3428 close_proc_file (procinfo);
3429 continue;
3430 }
3431
3432 if (!(procinfo->prstatus.pr_flags & PR_STOPPED))
3433 if (ioctl (procinfo->ctl_fd, PIOCSTOP, &procinfo->prstatus)
3434 < 0)
3435 {
3436 print_sys_errmsg (procinfo->pathname, errno);
3437 warning ("PIOCSTOP failed");
3438 }
3439 #endif
3440 }
3441 }
3442 }
3443 }
3444 else
3445 {
3446 error ("PIOCWSTOP, stopped for unknown/unhandled reason, flags %#x",
3447 pi->prstatus.pr_flags);
3448 }
3449
3450 store_waitstatus (ourstatus, statval);
3451
3452 if (rtnval == -1) /* No more children to wait for */
3453 {
3454 warning ("Child process unexpectedly missing");
3455 /* Claim it exited with unknown signal. */
3456 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
3457 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
3458 return rtnval;
3459 }
3460
3461 pi->had_event = 0; /* Indicate that we've seen this one */
3462 return (rtnval);
3463 }
3464
3465 /*
3466
3467 LOCAL FUNCTION
3468
3469 set_proc_siginfo - set a process's current signal info
3470
3471 SYNOPSIS
3472
3473 void set_proc_siginfo (struct procinfo *pip, int signo);
3474
3475 DESCRIPTION
3476
3477 Given a pointer to a process info struct in PIP and a signal number
3478 in SIGNO, set the process's current signal and its associated signal
3479 information. The signal will be delivered to the process immediately
3480 after execution is resumed, even if it is being held. In addition,
3481 this particular delivery will not cause another PR_SIGNALLED stop
3482 even if the signal is being traced.
3483
3484 If we are not delivering the same signal that the prstatus siginfo
3485 struct contains information about, then synthesize a siginfo struct
3486 to match the signal we are doing to deliver, make it of the type
3487 "generated by a user process", and send this synthesized copy. When
3488 used to set the inferior's signal state, this will be required if we
3489 are not currently stopped because of a traced signal, or if we decide
3490 to continue with a different signal.
3491
3492 Note that when continuing the inferior from a stop due to receipt
3493 of a traced signal, we either have set PRCSIG to clear the existing
3494 signal, or we have to call this function to do a PIOCSSIG with either
3495 the existing siginfo struct from pr_info, or one we have synthesized
3496 appropriately for the signal we want to deliver. Otherwise if the
3497 signal is still being traced, the inferior will immediately stop
3498 again.
3499
3500 See siginfo(5) for more details.
3501 */
3502
3503 static void
3504 set_proc_siginfo (pip, signo)
3505 struct procinfo *pip;
3506 int signo;
3507 {
3508 struct siginfo newsiginfo;
3509 struct siginfo *sip;
3510 struct sigi_ctl sictl;
3511
3512 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
3513 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
3514 receives a PIOCSSIG with a signal identical to the current signal,
3515 it messes up the current signal. Work around the kernel bug. */
3516 #ifdef UNIXWARE
3517 if (signo == pip -> prstatus.pr_lwp.pr_cursig)
3518 #else
3519 if (signo == pip -> prstatus.pr_cursig)
3520 #endif
3521 return;
3522 #endif
3523
3524 #ifdef UNIXWARE
3525 if (signo == pip->prstatus.pr_lwp.pr_info.si_signo)
3526 {
3527 memcpy ((char *) &sictl.siginfo, (char *) &pip->prstatus.pr_lwp.pr_info,
3528 sizeof (siginfo_t));
3529 }
3530 #else
3531 if (signo == pip -> prstatus.pr_info.si_signo)
3532 {
3533 sip = &pip -> prstatus.pr_info;
3534 }
3535 #endif
3536 else
3537 {
3538 #ifdef UNIXWARE
3539 siginfo_t *sip = &sictl.siginfo;
3540 memset ((char *) sip, 0, sizeof (siginfo_t));
3541 #else
3542 memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
3543 sip = &newsiginfo;
3544 #endif
3545 sip -> si_signo = signo;
3546 sip -> si_code = 0;
3547 sip -> si_errno = 0;
3548 sip -> si_pid = getpid ();
3549 sip -> si_uid = getuid ();
3550 }
3551 #ifdef PROCFS_USE_READ_WRITE
3552 sictl.cmd = PCSSIG;
3553 if (write (pip->ctl_fd, (char *) &sictl, sizeof (struct sigi_ctl)) < 0)
3554 #else
3555 if (ioctl (pip->ctl_fd, PIOCSSIG, sip) < 0)
3556 #endif
3557 {
3558 print_sys_errmsg (pip -> pathname, errno);
3559 warning ("PIOCSSIG failed");
3560 }
3561 }
3562
3563 /* Resume execution of process PID. If STEP is nozero, then
3564 just single step it. If SIGNAL is nonzero, restart it with that
3565 signal activated. */
3566
3567 static void
3568 procfs_resume (pid, step, signo)
3569 int pid;
3570 int step;
3571 enum target_signal signo;
3572 {
3573 int signal_to_pass;
3574 struct procinfo *pi, *procinfo, *next_pi;
3575 struct proc_ctl pctl;
3576
3577 pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
3578
3579 errno = 0;
3580 #ifdef UNIXWARE
3581 pctl.cmd = PCRUN;
3582 pctl.data = PRCFAULT;
3583 #else
3584 pi->prrun.pr_flags = PRSTRACE | PRSFAULT | PRCFAULT;
3585 #endif
3586
3587 #if 0
3588 /* It should not be necessary. If the user explicitly changes the value,
3589 value_assign calls write_register_bytes, which writes it. */
3590 /* It may not be absolutely necessary to specify the PC value for
3591 restarting, but to be safe we use the value that gdb considers
3592 to be current. One case where this might be necessary is if the
3593 user explicitly changes the PC value that gdb considers to be
3594 current. FIXME: Investigate if this is necessary or not. */
3595
3596 #ifdef PRSVADDR_BROKEN
3597 /* Can't do this under Solaris running on a Sparc, as there seems to be no
3598 place to put nPC. In fact, if you use this, nPC seems to be set to some
3599 random garbage. We have to rely on the fact that PC and nPC have been
3600 written previously via PIOCSREG during a register flush. */
3601
3602 pi->prrun.pr_vaddr = (caddr_t) *(int *) &registers[REGISTER_BYTE (PC_REGNUM)];
3603 pi->prrun.pr_flags != PRSVADDR;
3604 #endif
3605 #endif
3606
3607 if (signo == TARGET_SIGNAL_STOP && pi->nopass_next_sigstop)
3608 /* When attaching to a child process, if we forced it to stop with
3609 a PIOCSTOP, then we will have set the nopass_next_sigstop flag.
3610 Upon resuming the first time after such a stop, we explicitly
3611 inhibit sending it another SIGSTOP, which would be the normal
3612 result of default signal handling. One potential drawback to
3613 this is that we will also ignore any attempt to by the user
3614 to explicitly continue after the attach with a SIGSTOP. Ultimately
3615 this problem should be dealt with by making the routines that
3616 deal with the inferior a little smarter, and possibly even allow
3617 an inferior to continue running at the same time as gdb. (FIXME?) */
3618 signal_to_pass = 0;
3619 else if (signo == TARGET_SIGNAL_TSTP
3620 #ifdef UNIXWARE
3621 && pi->prstatus.pr_lwp.pr_cursig == SIGTSTP
3622 && pi->prstatus.pr_lwp.pr_action.sa_handler == SIG_DFL
3623 #else
3624 && pi->prstatus.pr_cursig == SIGTSTP
3625 && pi->prstatus.pr_action.sa_handler == SIG_DFL
3626 #endif
3627 )
3628
3629 /* We are about to pass the inferior a SIGTSTP whose action is
3630 SIG_DFL. The SIG_DFL action for a SIGTSTP is to stop
3631 (notifying the parent via wait()), and then keep going from the
3632 same place when the parent is ready for you to keep going. So
3633 under the debugger, it should do nothing (as if the program had
3634 been stopped and then later resumed. Under ptrace, this
3635 happens for us, but under /proc, the system obligingly stops
3636 the process, and wait_for_inferior would have no way of
3637 distinguishing that type of stop (which indicates that we
3638 should just start it again), with a stop due to the pr_trace
3639 field of the prrun_t struct.
3640
3641 Note that if the SIGTSTP is being caught, we *do* need to pass it,
3642 because the handler needs to get executed. */
3643 signal_to_pass = 0;
3644 else
3645 signal_to_pass = target_signal_to_host (signo);
3646
3647 if (signal_to_pass)
3648 {
3649 set_proc_siginfo (pi, signal_to_pass);
3650 }
3651 else
3652 {
3653 #ifdef UNIXWARE
3654 pctl.data |= PRCSIG;
3655 #else
3656 pi->prrun.pr_flags |= PRCSIG;
3657 #endif
3658 }
3659 pi->nopass_next_sigstop = 0;
3660 if (step)
3661 {
3662 #ifdef UNIXWARE
3663 pctl.data |= PRSTEP;
3664 #else
3665 pi->prrun.pr_flags |= PRSTEP;
3666 #endif
3667 }
3668 pi->had_event = 0;
3669 /* Don't try to start a process unless it's stopped on an
3670 `event of interest'. Doing so will cause errors. */
3671
3672 if (!procfs_read_status (pi))
3673 {
3674 /* The LWP has apparently terminated. */
3675 if (info_verbose)
3676 printf_filtered ("LWP %d doesn't respond.\n",
3677 (pi->pid >> 16) & 0xffff);
3678 close_proc_file (pi);
3679 }
3680 else
3681 {
3682 #ifdef PROCFS_USE_READ_WRITE
3683 if (write (pi->ctl_fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
3684 #else
3685 if ((pi->prstatus.pr_flags & PR_ISTOP)
3686 && ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
3687 #endif
3688 {
3689 /* The LWP has apparently terminated. */
3690 if (info_verbose)
3691 printf_filtered ("LWP %d doesn't respond.\n",
3692 (pi->pid >> 16) & 0xffff);
3693 close_proc_file (pi);
3694 }
3695 }
3696
3697 /* Continue all the other threads that haven't had an event of interest.
3698 Also continue them if they have NOPASS_NEXT_SIGSTOP set; this is only
3699 set by do_attach, and means this is the first resume after an attach.
3700 All threads were CSTOP'd by do_attach, and should be resumed now. */
3701
3702 if (pid == -1)
3703 for (procinfo = procinfo_list; procinfo; procinfo = next_pi)
3704 {
3705 next_pi = procinfo->next;
3706 if (pi != procinfo)
3707 if (!procinfo->had_event ||
3708 (procinfo->nopass_next_sigstop && signo == TARGET_SIGNAL_STOP))
3709 {
3710 procinfo->had_event = procinfo->nopass_next_sigstop = 0;
3711 #ifdef PROCFS_USE_READ_WRITE
3712 pctl.data = PRCFAULT | PRCSIG;
3713 if (write (procinfo->ctl_fd, (char *) &pctl,
3714 sizeof (struct proc_ctl)) < 0)
3715 {
3716 if (!procfs_read_status (procinfo))
3717 fprintf_unfiltered(gdb_stderr,
3718 "procfs_read_status failed, errno=%d\n",
3719 errno);
3720 print_sys_errmsg (procinfo->pathname, errno);
3721 error ("PCRUN failed");
3722 }
3723 procfs_read_status (procinfo);
3724 #else
3725 procinfo->prrun.pr_flags &= PRSTEP;
3726 procinfo->prrun.pr_flags |= PRCFAULT | PRCSIG;
3727 if (!procfs_read_status (procinfo))
3728 {
3729 /* The LWP has apparently terminated. */
3730 if (info_verbose)
3731 printf_filtered ("LWP %d doesn't respond.\n",
3732 (procinfo->pid >> 16) & 0xffff);
3733 close_proc_file (procinfo);
3734 continue;
3735 }
3736
3737 /* Don't try to start a process unless it's stopped on an
3738 `event of interest'. Doing so will cause errors. */
3739
3740 if ((procinfo->prstatus.pr_flags & PR_ISTOP)
3741 && ioctl (procinfo->ctl_fd, PIOCRUN, &procinfo->prrun) < 0)
3742 {
3743 if (!procfs_read_status (procinfo))
3744 fprintf_unfiltered(gdb_stderr,
3745 "procfs_read_status failed, errno=%d\n",
3746 errno);
3747 print_sys_errmsg (procinfo->pathname, errno);
3748 warning ("PIOCRUN failed");
3749 }
3750 }
3751 procfs_read_status (procinfo);
3752 #endif
3753 }
3754 }
3755
3756 /*
3757
3758 LOCAL FUNCTION
3759
3760 procfs_fetch_registers -- fetch current registers from inferior
3761
3762 SYNOPSIS
3763
3764 void procfs_fetch_registers (int regno)
3765
3766 DESCRIPTION
3767
3768 Read the current values of the inferior's registers, both the
3769 general register set and floating point registers (if supported)
3770 and update gdb's idea of their current values.
3771
3772 */
3773
3774 static void
3775 procfs_fetch_registers (regno)
3776 int regno;
3777 {
3778 struct procinfo *pi;
3779
3780 pi = current_procinfo;
3781
3782 #ifdef UNIXWARE
3783 if (procfs_read_status (pi))
3784 {
3785 supply_gregset (&pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs);
3786 #if defined (FP0_REGNUM)
3787 supply_fpregset (&pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs);
3788 #endif
3789 }
3790 #else /* UNIXWARE */
3791 if (ioctl (pi->ctl_fd, PIOCGREG, &pi->gregset.gregset) != -1)
3792 {
3793 supply_gregset (&pi->gregset.gregset);
3794 }
3795 #if defined (FP0_REGNUM)
3796 if (ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset.fpregset) != -1)
3797 {
3798 supply_fpregset (&pi->fpregset.fpregset);
3799 }
3800 #endif
3801 #endif /* UNIXWARE */
3802 }
3803
3804 /*
3805
3806 LOCAL FUNCTION
3807
3808 proc_init_failed - called when /proc access initialization fails
3809 fails
3810
3811 SYNOPSIS
3812
3813 static void proc_init_failed (struct procinfo *pi,
3814 char *why, int kill_p)
3815
3816 DESCRIPTION
3817
3818 This function is called whenever initialization of access to a /proc
3819 entry fails. It prints a suitable error message, does some cleanup,
3820 and then invokes the standard error processing routine which dumps
3821 us back into the command loop. If KILL_P is true, sends SIGKILL.
3822 */
3823
3824 static void
3825 proc_init_failed (pi, why, kill_p)
3826 struct procinfo *pi;
3827 char *why;
3828 int kill_p;
3829 {
3830 print_sys_errmsg (pi->pathname, errno);
3831 if (kill_p)
3832 kill (pi->pid, SIGKILL);
3833 close_proc_file (pi);
3834 error (why);
3835 /* NOTREACHED */
3836 }
3837
3838 /*
3839
3840 LOCAL FUNCTION
3841
3842 close_proc_file - close any currently open /proc entry
3843
3844 SYNOPSIS
3845
3846 static void close_proc_file (struct procinfo *pip)
3847
3848 DESCRIPTION
3849
3850 Close any currently open /proc entry and mark the process information
3851 entry as invalid. In order to ensure that we don't try to reuse any
3852 stale information, the pid, fd, and pathnames are explicitly
3853 invalidated, which may be overkill.
3854
3855 */
3856
3857 static void
3858 close_proc_file (pip)
3859 struct procinfo *pip;
3860 {
3861 struct procinfo *procinfo;
3862
3863 delete_thread (pip->pid); /* remove thread from GDB's thread list */
3864 remove_fd (pip); /* Remove fd from poll/select list */
3865
3866 close (pip->ctl_fd);
3867 #ifdef HAVE_MULTIPLE_PROC_FDS
3868 close (pip->as_fd);
3869 close (pip->status_fd);
3870 close (pip->map_fd);
3871 #endif
3872
3873 free (pip -> pathname);
3874
3875 /* Unlink pip from the procinfo chain. Note pip might not be on the list. */
3876
3877 if (procinfo_list == pip)
3878 procinfo_list = pip->next;
3879 else
3880 {
3881 for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
3882 {
3883 if (procinfo->next == pip)
3884 {
3885 procinfo->next = pip->next;
3886 break;
3887 }
3888 }
3889 free (pip);
3890 }
3891 }
3892
3893 /*
3894
3895 LOCAL FUNCTION
3896
3897 open_proc_file - open a /proc entry for a given process id
3898
3899 SYNOPSIS
3900
3901 static int open_proc_file (int pid, struct procinfo *pip, int mode)
3902
3903 DESCRIPTION
3904
3905 Given a process id and a mode, close the existing open /proc
3906 entry (if any) and open one for the new process id, in the
3907 specified mode. Once it is open, then mark the local process
3908 information structure as valid, which guarantees that the pid,
3909 fd, and pathname fields match an open /proc entry. Returns
3910 zero if the open fails, nonzero otherwise.
3911
3912 Note that the pathname is left intact, even when the open fails,
3913 so that callers can use it to construct meaningful error messages
3914 rather than just "file open failed".
3915
3916 Note that for Solaris, the process-id also includes an LWP-id, so we
3917 actually attempt to open that. If we are handed a pid with a 0 LWP-id,
3918 then we will ask the kernel what it is and add it to the pid. Hence,
3919 the pid can be changed by us.
3920 */
3921
3922 static int
3923 open_proc_file (pid, pip, mode, control)
3924 int pid;
3925 struct procinfo *pip;
3926 int mode;
3927 int control;
3928 {
3929 int tmp, tmpfd;
3930
3931 pip -> next = NULL;
3932 pip -> had_event = 0;
3933 pip -> pathname = xmalloc (MAX_PROC_NAME_SIZE);
3934 pip -> pid = pid;
3935
3936 #ifndef PIOCOPENLWP
3937 tmp = pid;
3938 #else
3939 tmp = pid & 0xffff;
3940 #endif
3941
3942 #ifdef HAVE_MULTIPLE_PROC_FDS
3943 sprintf (pip->pathname, STATUS_PROC_NAME_FMT, tmp);
3944 if ((pip->status_fd = open (pip->pathname, O_RDONLY)) < 0)
3945 {
3946 return 0;
3947 }
3948
3949 sprintf (pip->pathname, AS_PROC_NAME_FMT, tmp);
3950 if ((pip->as_fd = open (pip->pathname, O_RDWR)) < 0)
3951 {
3952 close (pip->status_fd);
3953 return 0;
3954 }
3955
3956 sprintf (pip->pathname, MAP_PROC_NAME_FMT, tmp);
3957 if ((pip->map_fd = open (pip->pathname, O_RDONLY)) < 0)
3958 {
3959 close (pip->status_fd);
3960 close (pip->as_fd);
3961 return 0;
3962 }
3963
3964 sprintf (pip->pathname, MAP_PROC_NAME_FMT, tmp);
3965 if ((pip->map_fd = open (pip->pathname, O_RDONLY)) < 0)
3966 {
3967 close (pip->status_fd);
3968 close (pip->as_fd);
3969 return 0;
3970 }
3971
3972 if (control)
3973 {
3974 sprintf (pip->pathname, CTL_PROC_NAME_FMT, tmp);
3975 if ((pip->ctl_fd = open (pip->pathname, O_WRONLY)) < 0)
3976 {
3977 close (pip->status_fd);
3978 close (pip->as_fd);
3979 close (pip->map_fd);
3980 return 0;
3981 }
3982 }
3983
3984 #else /* HAVE_MULTIPLE_PROC_FDS */
3985 sprintf (pip -> pathname, CTL_PROC_NAME_FMT, tmp);
3986
3987 if ((tmpfd = open (pip -> pathname, mode)) < 0)
3988 return 0;
3989
3990 #ifndef PIOCOPENLWP
3991 pip -> ctl_fd = tmpfd;
3992 pip -> as_fd = tmpfd;
3993 pip -> map_fd = tmpfd;
3994 pip -> status_fd = tmpfd;
3995 #else
3996 tmp = (pid >> 16) & 0xffff; /* Extract thread id */
3997
3998 if (tmp == 0)
3999 { /* Don't know thread id yet */
4000 if (ioctl (tmpfd, PIOCSTATUS, &pip -> prstatus) < 0)
4001 {
4002 print_sys_errmsg (pip -> pathname, errno);
4003 close (tmpfd);
4004 error ("open_proc_file: PIOCSTATUS failed");
4005 }
4006
4007 tmp = pip -> prstatus.pr_who; /* Get thread id from prstatus_t */
4008 pip -> pid = (tmp << 16) | pid; /* Update pip */
4009 }
4010
4011 if ((pip -> ctl_fd = ioctl (tmpfd, PIOCOPENLWP, &tmp)) < 0)
4012 {
4013 close (tmpfd);
4014 return 0;
4015 }
4016
4017 #ifdef PIOCSET /* New method */
4018 {
4019 long pr_flags;
4020 pr_flags = PR_ASYNC;
4021 ioctl (pip -> ctl_fd, PIOCSET, &pr_flags);
4022 }
4023 #endif
4024
4025 /* keep extra fds in sync */
4026 pip->as_fd = pip->ctl_fd;
4027 pip->map_fd = pip->ctl_fd;
4028 pip->status_fd = pip->ctl_fd;
4029
4030 close (tmpfd); /* All done with main pid */
4031 #endif /* PIOCOPENLWP */
4032
4033 #endif /* HAVE_MULTIPLE_PROC_FDS */
4034
4035 return 1;
4036 }
4037
4038 static char *
4039 mappingflags (flags)
4040 long flags;
4041 {
4042 static char asciiflags[8];
4043
4044 strcpy (asciiflags, "-------");
4045 #if defined (MA_PHYS)
4046 if (flags & MA_PHYS) asciiflags[0] = 'd';
4047 #endif
4048 if (flags & MA_STACK) asciiflags[1] = 's';
4049 if (flags & MA_BREAK) asciiflags[2] = 'b';
4050 if (flags & MA_SHARED) asciiflags[3] = 's';
4051 if (flags & MA_READ) asciiflags[4] = 'r';
4052 if (flags & MA_WRITE) asciiflags[5] = 'w';
4053 if (flags & MA_EXEC) asciiflags[6] = 'x';
4054 return (asciiflags);
4055 }
4056
4057 static void
4058 info_proc_flags (pip, summary)
4059 struct procinfo *pip;
4060 int summary;
4061 {
4062 struct trans *transp;
4063 #ifdef UNIXWARE
4064 long flags = pip->prstatus.pr_flags | pip->prstatus.pr_lwp.pr_flags;
4065 #else
4066 long flags = pip->prstatus.pr_flags;
4067 #endif
4068
4069 printf_filtered ("%-32s", "Process status flags:");
4070 if (!summary)
4071 {
4072 printf_filtered ("\n\n");
4073 }
4074 for (transp = pr_flag_table; transp -> name != NULL; transp++)
4075 {
4076 if (flags & transp -> value)
4077 {
4078 if (summary)
4079 {
4080 printf_filtered ("%s ", transp -> name);
4081 }
4082 else
4083 {
4084 printf_filtered ("\t%-16s %s.\n", transp -> name, transp -> desc);
4085 }
4086 }
4087 }
4088 printf_filtered ("\n");
4089 }
4090
4091 static void
4092 info_proc_stop (pip, summary)
4093 struct procinfo *pip;
4094 int summary;
4095 {
4096 struct trans *transp;
4097 int why;
4098 int what;
4099
4100 #ifdef UNIXWARE
4101 why = pip -> prstatus.pr_lwp.pr_why;
4102 what = pip -> prstatus.pr_lwp.pr_what;
4103 #else
4104 why = pip -> prstatus.pr_why;
4105 what = pip -> prstatus.pr_what;
4106 #endif
4107
4108 #ifdef UNIXWARE
4109 if (pip -> prstatus.pr_lwp.pr_flags & PR_STOPPED)
4110 #else
4111 if (pip -> prstatus.pr_flags & PR_STOPPED)
4112 #endif
4113 {
4114 printf_filtered ("%-32s", "Reason for stopping:");
4115 if (!summary)
4116 {
4117 printf_filtered ("\n\n");
4118 }
4119 for (transp = pr_why_table; transp -> name != NULL; transp++)
4120 {
4121 if (why == transp -> value)
4122 {
4123 if (summary)
4124 {
4125 printf_filtered ("%s ", transp -> name);
4126 }
4127 else
4128 {
4129 printf_filtered ("\t%-16s %s.\n",
4130 transp -> name, transp -> desc);
4131 }
4132 break;
4133 }
4134 }
4135
4136 /* Use the pr_why field to determine what the pr_what field means, and
4137 print more information. */
4138
4139 switch (why)
4140 {
4141 case PR_REQUESTED:
4142 /* pr_what is unused for this case */
4143 break;
4144 case PR_JOBCONTROL:
4145 case PR_SIGNALLED:
4146 if (summary)
4147 {
4148 printf_filtered ("%s ", signalname (what));
4149 }
4150 else
4151 {
4152 printf_filtered ("\t%-16s %s.\n", signalname (what),
4153 safe_strsignal (what));
4154 }
4155 break;
4156 case PR_SYSENTRY:
4157 if (summary)
4158 {
4159 printf_filtered ("%s ", syscallname (what));
4160 }
4161 else
4162 {
4163 printf_filtered ("\t%-16s %s.\n", syscallname (what),
4164 "Entered this system call");
4165 }
4166 break;
4167 case PR_SYSEXIT:
4168 if (summary)
4169 {
4170 printf_filtered ("%s ", syscallname (what));
4171 }
4172 else
4173 {
4174 printf_filtered ("\t%-16s %s.\n", syscallname (what),
4175 "Returned from this system call");
4176 }
4177 break;
4178 case PR_FAULTED:
4179 if (summary)
4180 {
4181 printf_filtered ("%s ",
4182 lookupname (faults_table, what, "fault"));
4183 }
4184 else
4185 {
4186 printf_filtered ("\t%-16s %s.\n",
4187 lookupname (faults_table, what, "fault"),
4188 lookupdesc (faults_table, what));
4189 }
4190 break;
4191 }
4192 printf_filtered ("\n");
4193 }
4194 }
4195
4196 static void
4197 info_proc_siginfo (pip, summary)
4198 struct procinfo *pip;
4199 int summary;
4200 {
4201 struct siginfo *sip;
4202
4203 #ifdef UNIXWARE
4204 if ((pip -> prstatus.pr_lwp.pr_flags & PR_STOPPED) &&
4205 (pip -> prstatus.pr_lwp.pr_why == PR_SIGNALLED ||
4206 pip -> prstatus.pr_lwp.pr_why == PR_FAULTED))
4207 #else
4208 if ((pip -> prstatus.pr_flags & PR_STOPPED) &&
4209 (pip -> prstatus.pr_why == PR_SIGNALLED ||
4210 pip -> prstatus.pr_why == PR_FAULTED))
4211 #endif
4212 {
4213 printf_filtered ("%-32s", "Additional signal/fault info:");
4214 #ifdef UNIXWARE
4215 sip = &pip -> prstatus.pr_lwp.pr_info;
4216 #else
4217 sip = &pip -> prstatus.pr_info;
4218 #endif
4219 if (summary)
4220 {
4221 printf_filtered ("%s ", signalname (sip -> si_signo));
4222 if (sip -> si_errno > 0)
4223 {
4224 printf_filtered ("%s ", errnoname (sip -> si_errno));
4225 }
4226 if (sip -> si_code <= 0)
4227 {
4228 printf_filtered ("sent by %s, uid %d ",
4229 target_pid_to_str (sip -> si_pid),
4230 sip -> si_uid);
4231 }
4232 else
4233 {
4234 printf_filtered ("%s ", sigcodename (sip));
4235 if ((sip -> si_signo == SIGILL) ||
4236 (sip -> si_signo == SIGFPE) ||
4237 (sip -> si_signo == SIGSEGV) ||
4238 (sip -> si_signo == SIGBUS))
4239 {
4240 printf_filtered ("addr=%#lx ",
4241 (unsigned long) sip -> si_addr);
4242 }
4243 else if ((sip -> si_signo == SIGCHLD))
4244 {
4245 printf_filtered ("child %s, status %u ",
4246 target_pid_to_str (sip -> si_pid),
4247 sip -> si_status);
4248 }
4249 else if ((sip -> si_signo == SIGPOLL))
4250 {
4251 printf_filtered ("band %u ", sip -> si_band);
4252 }
4253 }
4254 }
4255 else
4256 {
4257 printf_filtered ("\n\n");
4258 printf_filtered ("\t%-16s %s.\n", signalname (sip -> si_signo),
4259 safe_strsignal (sip -> si_signo));
4260 if (sip -> si_errno > 0)
4261 {
4262 printf_filtered ("\t%-16s %s.\n",
4263 errnoname (sip -> si_errno),
4264 safe_strerror (sip -> si_errno));
4265 }
4266 if (sip -> si_code <= 0)
4267 {
4268 printf_filtered ("\t%-16u %s\n", sip -> si_pid, /* XXX need target_pid_to_str() */
4269 "PID of process sending signal");
4270 printf_filtered ("\t%-16u %s\n", sip -> si_uid,
4271 "UID of process sending signal");
4272 }
4273 else
4274 {
4275 printf_filtered ("\t%-16s %s.\n", sigcodename (sip),
4276 sigcodedesc (sip));
4277 if ((sip -> si_signo == SIGILL) ||
4278 (sip -> si_signo == SIGFPE))
4279 {
4280 printf_filtered ("\t%#-16lx %s.\n",
4281 (unsigned long) sip -> si_addr,
4282 "Address of faulting instruction");
4283 }
4284 else if ((sip -> si_signo == SIGSEGV) ||
4285 (sip -> si_signo == SIGBUS))
4286 {
4287 printf_filtered ("\t%#-16lx %s.\n",
4288 (unsigned long) sip -> si_addr,
4289 "Address of faulting memory reference");
4290 }
4291 else if ((sip -> si_signo == SIGCHLD))
4292 {
4293 printf_filtered ("\t%-16u %s.\n", sip -> si_pid, /* XXX need target_pid_to_str() */
4294 "Child process ID");
4295 printf_filtered ("\t%-16u %s.\n", sip -> si_status,
4296 "Child process exit value or signal");
4297 }
4298 else if ((sip -> si_signo == SIGPOLL))
4299 {
4300 printf_filtered ("\t%-16u %s.\n", sip -> si_band,
4301 "Band event for POLL_{IN,OUT,MSG}");
4302 }
4303 }
4304 }
4305 printf_filtered ("\n");
4306 }
4307 }
4308
4309 static void
4310 info_proc_syscalls (pip, summary)
4311 struct procinfo *pip;
4312 int summary;
4313 {
4314 int syscallnum;
4315
4316 if (!summary)
4317 {
4318
4319 #if 0 /* FIXME: Needs to use gdb-wide configured info about system calls. */
4320 if (pip -> prstatus.pr_flags & PR_ASLEEP)
4321 {
4322 int syscallnum = pip -> prstatus.pr_reg[R_D0];
4323 if (summary)
4324 {
4325 printf_filtered ("%-32s", "Sleeping in system call:");
4326 printf_filtered ("%s", syscallname (syscallnum));
4327 }
4328 else
4329 {
4330 printf_filtered ("Sleeping in system call '%s'.\n",
4331 syscallname (syscallnum));
4332 }
4333 }
4334 #endif
4335
4336 #ifndef UNIXWARE
4337 if (ioctl (pip -> ctl_fd, PIOCGENTRY, &pip -> entryset) < 0)
4338 {
4339 print_sys_errmsg (pip -> pathname, errno);
4340 error ("PIOCGENTRY failed");
4341 }
4342
4343 if (ioctl (pip -> ctl_fd, PIOCGEXIT, &pip -> exitset) < 0)
4344 {
4345 print_sys_errmsg (pip -> pathname, errno);
4346 error ("PIOCGEXIT failed");
4347 }
4348 #endif
4349
4350 printf_filtered ("System call tracing information:\n\n");
4351
4352 printf_filtered ("\t%-12s %-8s %-8s\n",
4353 "System call",
4354 "Entry",
4355 "Exit");
4356 for (syscallnum = 0; syscallnum < MAX_SYSCALLS; syscallnum++)
4357 {
4358 QUIT;
4359 if (syscall_table[syscallnum] != NULL)
4360 printf_filtered ("\t%-12s ", syscall_table[syscallnum]);
4361 else
4362 printf_filtered ("\t%-12d ", syscallnum);
4363
4364 #ifdef UNIXWARE
4365 printf_filtered ("%-8s ",
4366 prismember (&pip->prstatus.pr_sysentry, syscallnum)
4367 ? "on" : "off");
4368 printf_filtered ("%-8s ",
4369 prismember (&pip->prstatus.pr_sysexit, syscallnum)
4370 ? "on" : "off");
4371 #else
4372 printf_filtered ("%-8s ",
4373 prismember (&pip -> entryset, syscallnum)
4374 ? "on" : "off");
4375 printf_filtered ("%-8s ",
4376 prismember (&pip -> exitset, syscallnum)
4377 ? "on" : "off");
4378 #endif
4379 printf_filtered ("\n");
4380 }
4381 printf_filtered ("\n");
4382 }
4383 }
4384
4385 static char *
4386 signalname (signo)
4387 int signo;
4388 {
4389 const char *name;
4390 static char locbuf[32];
4391
4392 name = strsigno (signo);
4393 if (name == NULL)
4394 {
4395 sprintf (locbuf, "Signal %d", signo);
4396 }
4397 else
4398 {
4399 sprintf (locbuf, "%s (%d)", name, signo);
4400 }
4401 return (locbuf);
4402 }
4403
4404 static char *
4405 errnoname (errnum)
4406 int errnum;
4407 {
4408 const char *name;
4409 static char locbuf[32];
4410
4411 name = strerrno (errnum);
4412 if (name == NULL)
4413 {
4414 sprintf (locbuf, "Errno %d", errnum);
4415 }
4416 else
4417 {
4418 sprintf (locbuf, "%s (%d)", name, errnum);
4419 }
4420 return (locbuf);
4421 }
4422
4423 static void
4424 info_proc_signals (pip, summary)
4425 struct procinfo *pip;
4426 int summary;
4427 {
4428 int signo;
4429
4430 if (!summary)
4431 {
4432 #ifndef PROCFS_USE_READ_WRITE
4433 if (ioctl (pip -> ctl_fd, PIOCGTRACE, &pip -> trace) < 0)
4434 {
4435 print_sys_errmsg (pip -> pathname, errno);
4436 error ("PIOCGTRACE failed");
4437 }
4438 #endif
4439
4440 printf_filtered ("Disposition of signals:\n\n");
4441 printf_filtered ("\t%-15s %-8s %-8s %-8s %s\n\n",
4442 "Signal", "Trace", "Hold", "Pending", "Description");
4443 for (signo = 0; signo < NSIG; signo++)
4444 {
4445 QUIT;
4446 printf_filtered ("\t%-15s ", signalname (signo));
4447 #ifdef UNIXWARE
4448 printf_filtered ("%-8s ",
4449 prismember (&pip -> prstatus.pr_sigtrace, signo)
4450 ? "on" : "off");
4451 printf_filtered ("%-8s ",
4452 prismember (&pip -> prstatus.pr_lwp.pr_context.uc_sigmask, signo)
4453 ? "on" : "off");
4454 #else
4455 printf_filtered ("%-8s ",
4456 prismember (&pip -> trace, signo)
4457 ? "on" : "off");
4458 printf_filtered ("%-8s ",
4459 prismember (&pip -> prstatus.pr_sighold, signo)
4460 ? "on" : "off");
4461 #endif
4462
4463 #ifdef UNIXWARE
4464 if (prismember (&pip->prstatus.pr_sigpend, signo) ||
4465 prismember (&pip->prstatus.pr_lwp.pr_lwppend, signo))
4466 printf_filtered("%-8s ", "yes");
4467 else
4468 printf_filtered("%-8s ", "no");
4469 #else /* UNIXWARE */
4470 #ifdef PROCFS_SIGPEND_OFFSET
4471 /* Alpha OSF/1 numbers the pending signals from 1. */
4472 printf_filtered ("%-8s ",
4473 (signo ? prismember (&pip -> prstatus.pr_sigpend,
4474 signo - 1)
4475 : 0)
4476 ? "yes" : "no");
4477 #else
4478 printf_filtered ("%-8s ",
4479 prismember (&pip -> prstatus.pr_sigpend, signo)
4480 ? "yes" : "no");
4481 #endif
4482 #endif /* UNIXWARE */
4483 printf_filtered (" %s\n", safe_strsignal (signo));
4484 }
4485 printf_filtered ("\n");
4486 }
4487 }
4488
4489 static void
4490 info_proc_faults (pip, summary)
4491 struct procinfo *pip;
4492 int summary;
4493 {
4494 struct trans *transp;
4495
4496 if (!summary)
4497 {
4498 #ifndef UNIXWARE
4499 if (ioctl (pip -> ctl_fd, PIOCGFAULT, &pip->fltset.fltset) < 0)
4500 {
4501 print_sys_errmsg (pip -> pathname, errno);
4502 error ("PIOCGFAULT failed");
4503 }
4504 #endif
4505
4506 printf_filtered ("Current traced hardware fault set:\n\n");
4507 printf_filtered ("\t%-12s %-8s\n", "Fault", "Trace");
4508
4509 for (transp = faults_table; transp -> name != NULL; transp++)
4510 {
4511 QUIT;
4512 printf_filtered ("\t%-12s ", transp -> name);
4513 #ifdef UNIXWARE
4514 printf_filtered ("%-8s", prismember (&pip->prstatus.pr_flttrace, transp -> value)
4515 ? "on" : "off");
4516 #else
4517 printf_filtered ("%-8s", prismember (&pip->fltset.fltset, transp -> value)
4518 ? "on" : "off");
4519 #endif
4520 printf_filtered ("\n");
4521 }
4522 printf_filtered ("\n");
4523 }
4524 }
4525
4526 static void
4527 info_proc_mappings (pip, summary)
4528 struct procinfo *pip;
4529 int summary;
4530 {
4531 int nmap;
4532 struct prmap *prmaps;
4533 struct prmap *prmap;
4534 struct stat sbuf;
4535
4536 if (!summary)
4537 {
4538 printf_filtered ("Mapped address spaces:\n\n");
4539 #ifdef BFD_HOST_64_BIT
4540 printf_filtered (" %18s %18s %10s %10s %7s\n",
4541 #else
4542 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
4543 #endif
4544 "Start Addr",
4545 " End Addr",
4546 " Size",
4547 " Offset",
4548 "Flags");
4549 #ifdef PROCFS_USE_READ_WRITE
4550 if (fstat (pip->map_fd, &sbuf) == 0)
4551 {
4552 nmap = sbuf.st_size / sizeof (prmap_t);
4553 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
4554 if ((lseek (pip->map_fd, 0, SEEK_SET) == 0) &&
4555 (read (pip->map_fd, (char *) prmaps,
4556 nmap * sizeof (*prmaps)) == (nmap * sizeof (*prmaps))))
4557 {
4558 int i = 0;
4559 for (prmap = prmaps; i < nmap; ++prmap, ++i)
4560 #else
4561 if (ioctl (pip -> ctl_fd, PIOCNMAP, &nmap) == 0)
4562 {
4563 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
4564 if (ioctl (pip -> ctl_fd, PIOCMAP, prmaps) == 0)
4565 {
4566 for (prmap = prmaps; prmap -> pr_size; ++prmap)
4567 #endif /* PROCFS_USE_READ_WRITE */
4568 {
4569 #ifdef BFD_HOST_64_BIT
4570 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
4571 #else
4572 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
4573 #endif
4574 (unsigned long)prmap -> pr_vaddr,
4575 (unsigned long)prmap -> pr_vaddr
4576 + prmap -> pr_size - 1,
4577 prmap -> pr_size,
4578 prmap -> pr_off,
4579 mappingflags (prmap -> pr_mflags));
4580 }
4581 }
4582 }
4583 printf_filtered ("\n");
4584 }
4585 }
4586
4587 /*
4588
4589 LOCAL FUNCTION
4590
4591 info_proc -- implement the "info proc" command
4592
4593 SYNOPSIS
4594
4595 void info_proc (char *args, int from_tty)
4596
4597 DESCRIPTION
4598
4599 Implement gdb's "info proc" command by using the /proc interface
4600 to print status information about any currently running process.
4601
4602 Examples of the use of "info proc" are:
4603
4604 info proc (prints summary info for current inferior)
4605 info proc 123 (prints summary info for process with pid 123)
4606 info proc mappings (prints address mappings)
4607 info proc times (prints process/children times)
4608 info proc id (prints pid, ppid, gid, sid, etc)
4609 FIXME: i proc id not implemented.
4610 info proc status (prints general process state info)
4611 FIXME: i proc status not implemented.
4612 info proc signals (prints info about signal handling)
4613 info proc all (prints all info)
4614
4615 */
4616
4617 static void
4618 info_proc (args, from_tty)
4619 char *args;
4620 int from_tty;
4621 {
4622 int pid;
4623 struct procinfo *pip;
4624 struct cleanup *old_chain;
4625 char **argv;
4626 int argsize;
4627 int summary = 1;
4628 int flags = 0;
4629 int syscalls = 0;
4630 int signals = 0;
4631 int faults = 0;
4632 int mappings = 0;
4633 int times = 0;
4634 int id = 0;
4635 int status = 0;
4636 int all = 0;
4637 int nlwp;
4638 int *lwps;
4639
4640 old_chain = make_cleanup (null_cleanup, 0);
4641
4642 /* Default to using the current inferior if no pid specified. Note
4643 that inferior_pid may be 0, hence we set okerr. */
4644
4645 pid = inferior_pid & 0x7fffffff; /* strip off sol-thread bit */
4646 if (!(pip = find_procinfo (pid, 1))) /* inferior_pid no good? */
4647 pip = procinfo_list; /* take first available */
4648 pid = pid & 0xffff; /* extract "real" pid */
4649
4650 if (args != NULL)
4651 {
4652 if ((argv = buildargv (args)) == NULL)
4653 {
4654 nomem (0);
4655 }
4656 make_cleanup (freeargv, (char *) argv);
4657
4658 while (*argv != NULL)
4659 {
4660 argsize = strlen (*argv);
4661 if (argsize >= 1 && strncmp (*argv, "all", argsize) == 0)
4662 {
4663 summary = 0;
4664 all = 1;
4665 }
4666 else if (argsize >= 2 && strncmp (*argv, "faults", argsize) == 0)
4667 {
4668 summary = 0;
4669 faults = 1;
4670 }
4671 else if (argsize >= 2 && strncmp (*argv, "flags", argsize) == 0)
4672 {
4673 summary = 0;
4674 flags = 1;
4675 }
4676 else if (argsize >= 1 && strncmp (*argv, "id", argsize) == 0)
4677 {
4678 summary = 0;
4679 id = 1;
4680 }
4681 else if (argsize >= 1 && strncmp (*argv, "mappings", argsize) == 0)
4682 {
4683 summary = 0;
4684 mappings = 1;
4685 }
4686 else if (argsize >= 2 && strncmp (*argv, "signals", argsize) == 0)
4687 {
4688 summary = 0;
4689 signals = 1;
4690 }
4691 else if (argsize >= 2 && strncmp (*argv, "status", argsize) == 0)
4692 {
4693 summary = 0;
4694 status = 1;
4695 }
4696 else if (argsize >= 2 && strncmp (*argv, "syscalls", argsize) == 0)
4697 {
4698 summary = 0;
4699 syscalls = 1;
4700 }
4701 else if (argsize >= 1 && strncmp (*argv, "times", argsize) == 0)
4702 {
4703 summary = 0;
4704 times = 1;
4705 }
4706 else if ((pid = atoi (*argv)) > 0)
4707 {
4708 pip = (struct procinfo *) xmalloc (sizeof (struct procinfo));
4709 memset (pip, 0, sizeof (*pip));
4710
4711 pip->pid = pid;
4712 if (!open_proc_file (pid, pip, O_RDONLY, 0))
4713 {
4714 perror_with_name (pip -> pathname);
4715 /* NOTREACHED */
4716 }
4717 pid = pip->pid;
4718 make_cleanup (close_proc_file, pip);
4719 }
4720 else if (**argv != '\000')
4721 {
4722 error ("Unrecognized or ambiguous keyword `%s'.", *argv);
4723 }
4724 argv++;
4725 }
4726 }
4727
4728 /* If we don't have a valid open process at this point, then we have no
4729 inferior or didn't specify a specific pid. */
4730
4731 if (!pip)
4732 {
4733 error ("\
4734 No process. Start debugging a program or specify an explicit process ID.");
4735 }
4736
4737 if (!procfs_read_status (pip))
4738 {
4739 print_sys_errmsg (pip -> pathname, errno);
4740 error ("procfs_read_status failed");
4741 }
4742
4743 #ifndef PROCFS_USE_READ_WRITE
4744 #ifdef PIOCLWPIDS
4745 nlwp = pip->prstatus.pr_nlwp;
4746 lwps = alloca ((2 * nlwp + 2) * sizeof (*lwps));
4747
4748 if (ioctl (pip->ctl_fd, PIOCLWPIDS, lwps))
4749 {
4750 print_sys_errmsg (pip -> pathname, errno);
4751 error ("PIOCLWPIDS failed");
4752 }
4753 #else /* PIOCLWPIDS */
4754 nlwp = 1;
4755 lwps = alloca ((2 * nlwp + 2) * sizeof *lwps);
4756 lwps[0] = 0;
4757 #endif /* PIOCLWPIDS */
4758
4759 for (; nlwp > 0; nlwp--, lwps++)
4760 {
4761 pip = find_procinfo ((*lwps << 16) | pid, 1);
4762
4763 if (!pip)
4764 {
4765 pip = (struct procinfo *) xmalloc (sizeof (struct procinfo));
4766 memset (pip, 0, sizeof (*pip));
4767 if (!open_proc_file ((*lwps << 16) | pid, pip, O_RDONLY, 0))
4768 continue;
4769
4770 make_cleanup (close_proc_file, pip);
4771
4772 if (!procfs_read_status (pip))
4773 {
4774 print_sys_errmsg (pip -> pathname, errno);
4775 error ("procfs_read_status failed");
4776 }
4777 }
4778
4779 #endif /* PROCFS_USE_READ_WRITE */
4780
4781 /* Print verbose information of the requested type(s), or just a summary
4782 of the information for all types. */
4783
4784 printf_filtered ("\nInformation for %s.%d:\n\n", pip -> pathname, *lwps);
4785 if (summary || all || flags)
4786 {
4787 info_proc_flags (pip, summary);
4788 }
4789 if (summary || all)
4790 {
4791 info_proc_stop (pip, summary);
4792 supply_gregset (&pip->prstatus.pr_reg);
4793 printf_filtered ("PC: ");
4794 print_address (read_pc (), gdb_stdout);
4795 printf_filtered ("\n");
4796 }
4797 if (summary || all || signals || faults)
4798 {
4799 info_proc_siginfo (pip, summary);
4800 }
4801 if (summary || all || syscalls)
4802 {
4803 info_proc_syscalls (pip, summary);
4804 }
4805 if (summary || all || mappings)
4806 {
4807 info_proc_mappings (pip, summary);
4808 }
4809 if (summary || all || signals)
4810 {
4811 info_proc_signals (pip, summary);
4812 }
4813 if (summary || all || faults)
4814 {
4815 info_proc_faults (pip, summary);
4816 }
4817 printf_filtered ("\n");
4818
4819 /* All done, deal with closing any temporary process info structure,
4820 freeing temporary memory , etc. */
4821
4822 do_cleanups (old_chain);
4823 #ifndef PROCFS_USE_READ_WRITE
4824 }
4825 #endif
4826 }
4827
4828 /*
4829
4830 LOCAL FUNCTION
4831
4832 modify_inherit_on_fork_flag - Change the inherit-on-fork flag
4833
4834 SYNOPSIS
4835
4836 void modify_inherit_on_fork_flag (fd, flag)
4837
4838 DESCRIPTION
4839
4840 Call this routine to modify the inherit-on-fork flag. This routine is
4841 just a nice wrapper to hide the #ifdefs needed by various systems to
4842 control this flag.
4843
4844 */
4845
4846 static void
4847 modify_inherit_on_fork_flag (fd, flag)
4848 int fd;
4849 int flag;
4850 {
4851 #if defined (PIOCSET) || defined (PCSET)
4852 long pr_flags;
4853 #endif
4854 int retval = 0;
4855 struct proc_ctl pctl;
4856
4857 #if defined (PIOCSET) || defined (PCSET) /* New method */
4858 pr_flags = PR_FORK;
4859 if (flag)
4860 {
4861 #ifdef PROCFS_USE_READ_WRITE
4862 pctl.cmd = PCSET;
4863 pctl.data = PR_FORK;
4864 if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
4865 retval = -1;
4866 #else
4867 retval = ioctl (fd, PIOCSET, &pr_flags);
4868 #endif
4869 }
4870 else
4871 {
4872 #ifdef PROCFS_USE_READ_WRITE
4873 pctl.cmd = PCRESET;
4874 pctl.data = PR_FORK;
4875 if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
4876 retval = -1;
4877 #else
4878 retval = ioctl (fd, PIOCRESET, &pr_flags);
4879 #endif
4880 }
4881
4882 #else
4883 #ifdef PIOCSFORK /* Original method */
4884 if (flag)
4885 {
4886 retval = ioctl (fd, PIOCSFORK, NULL);
4887 }
4888 else
4889 {
4890 retval = ioctl (fd, PIOCRFORK, NULL);
4891 }
4892 #else
4893 Neither PR_FORK nor PIOCSFORK exist!!!
4894 #endif
4895 #endif
4896
4897 if (!retval)
4898 return;
4899
4900 print_sys_errmsg ("modify_inherit_on_fork_flag", errno);
4901 error ("PIOCSFORK or PR_FORK modification failed");
4902 }
4903
4904 /*
4905
4906 LOCAL FUNCTION
4907
4908 modify_run_on_last_close_flag - Change the run-on-last-close flag
4909
4910 SYNOPSIS
4911
4912 void modify_run_on_last_close_flag (fd, flag)
4913
4914 DESCRIPTION
4915
4916 Call this routine to modify the run-on-last-close flag. This routine
4917 is just a nice wrapper to hide the #ifdefs needed by various systems to
4918 control this flag.
4919
4920 */
4921
4922 static void
4923 modify_run_on_last_close_flag (fd, flag)
4924 int fd;
4925 int flag;
4926 {
4927 #if defined (PIOCSET) || defined (PCSET)
4928 long pr_flags;
4929 #endif
4930 int retval = 0;
4931 struct proc_ctl pctl;
4932
4933 #if defined (PIOCSET) || defined (PCSET) /* New method */
4934 pr_flags = PR_RLC;
4935 if (flag)
4936 {
4937 #ifdef PROCFS_USE_READ_WRITE
4938 pctl.cmd = PCSET;
4939 pctl.data = PR_RLC;
4940 if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
4941 retval = -1;
4942 #else
4943 retval = ioctl (fd, PIOCSET, &pr_flags);
4944 #endif
4945 }
4946 else
4947 {
4948 #ifdef PROCFS_USE_READ_WRITE
4949 pctl.cmd = PCRESET;
4950 pctl.data = PR_RLC;
4951 if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
4952 retval = -1;
4953 #else
4954 retval = ioctl (fd, PIOCRESET, &pr_flags);
4955 #endif
4956 }
4957
4958 #else
4959 #ifdef PIOCSRLC /* Original method */
4960 if (flag)
4961 retval = ioctl (fd, PIOCSRLC, NULL);
4962 else
4963 retval = ioctl (fd, PIOCRRLC, NULL);
4964 #else
4965 Neither PR_RLC nor PIOCSRLC exist!!!
4966 #endif
4967 #endif
4968
4969 if (!retval)
4970 return;
4971
4972 print_sys_errmsg ("modify_run_on_last_close_flag", errno);
4973 error ("PIOCSRLC or PR_RLC modification failed");
4974 }
4975
4976 /*
4977
4978 LOCAL FUNCTION
4979
4980 procfs_clear_syscall_trap -- Deletes the trap for the specified system call.
4981
4982 SYNOPSIS
4983
4984 void procfs_clear_syscall_trap (struct procinfo *, int syscall_num, int errok)
4985
4986 DESCRIPTION
4987
4988 This function function disables traps for the specified system call.
4989 errok is non-zero if errors should be ignored.
4990 */
4991
4992 static void
4993 procfs_clear_syscall_trap (pi, syscall_num, errok)
4994 struct procinfo *pi;
4995 int syscall_num;
4996 int errok;
4997 {
4998 sysset_t sysset;
4999 int goterr, i;
5000
5001 goterr = ioctl (pi->ctl_fd, PIOCGENTRY, &sysset) < 0;
5002
5003 if (goterr && !errok)
5004 {
5005 print_sys_errmsg (pi->pathname, errno);
5006 error ("PIOCGENTRY failed");
5007 }
5008
5009 if (!goterr)
5010 {
5011 prdelset (&sysset, syscall_num);
5012
5013 if ((ioctl (pi->ctl_fd, PIOCSENTRY, &sysset) < 0) && !errok)
5014 {
5015 print_sys_errmsg (pi->pathname, errno);
5016 error ("PIOCSENTRY failed");
5017 }
5018 }
5019
5020 goterr = ioctl (pi->ctl_fd, PIOCGEXIT, &sysset) < 0;
5021
5022 if (goterr && !errok)
5023 {
5024 procfs_clear_syscall_trap (pi, syscall_num, 1);
5025 print_sys_errmsg (pi->pathname, errno);
5026 error ("PIOCGEXIT failed");
5027 }
5028
5029 if (!goterr)
5030 {
5031 praddset (&sysset, syscall_num);
5032
5033 if ((ioctl (pi->ctl_fd, PIOCSEXIT, &sysset) < 0) && !errok)
5034 {
5035 procfs_clear_syscall_trap (pi, syscall_num, 1);
5036 print_sys_errmsg (pi->pathname, errno);
5037 error ("PIOCSEXIT failed");
5038 }
5039 }
5040
5041 if (!pi->syscall_handlers)
5042 {
5043 if (!errok)
5044 error ("procfs_clear_syscall_trap: syscall_handlers is empty");
5045 return;
5046 }
5047
5048 /* Remove handler func from the handler list */
5049
5050 for (i = 0; i < pi->num_syscall_handlers; i++)
5051 if (pi->syscall_handlers[i].syscall_num == syscall_num)
5052 {
5053 if (i + 1 != pi->num_syscall_handlers)
5054 { /* Not the last entry.
5055 Move subsequent entries fwd. */
5056 memcpy (&pi->syscall_handlers[i], &pi->syscall_handlers[i + 1],
5057 (pi->num_syscall_handlers - i - 1)
5058 * sizeof (struct procfs_syscall_handler));
5059 }
5060
5061 pi->syscall_handlers = xrealloc (pi->syscall_handlers,
5062 (pi->num_syscall_handlers - 1)
5063 * sizeof (struct procfs_syscall_handler));
5064 pi->num_syscall_handlers--;
5065 return;
5066 }
5067
5068 if (!errok)
5069 error ("procfs_clear_syscall_trap: Couldn't find handler for sys call %d",
5070 syscall_num);
5071 }
5072
5073 /*
5074
5075 LOCAL FUNCTION
5076
5077 procfs_set_syscall_trap -- arrange for a function to be called when the
5078 child executes the specified system call.
5079
5080 SYNOPSIS
5081
5082 void procfs_set_syscall_trap (struct procinfo *, int syscall_num, int flags,
5083 syscall_func_t *function)
5084
5085 DESCRIPTION
5086
5087 This function sets up an entry and/or exit trap for the specified system
5088 call. When the child executes the specified system call, your function
5089 will be called with the call #, a flag that indicates entry or exit, and
5090 pointers to rtnval and statval (which are used by procfs_wait). The
5091 function should return non-zero if something interesting happened, zero
5092 otherwise.
5093 */
5094
5095 static void
5096 procfs_set_syscall_trap (pi, syscall_num, flags, func)
5097 struct procinfo *pi;
5098 int syscall_num;
5099 int flags;
5100 syscall_func_t *func;
5101 {
5102 sysset_t sysset;
5103
5104 if (flags & PROCFS_SYSCALL_ENTRY)
5105 {
5106 if (ioctl (pi->ctl_fd, PIOCGENTRY, &sysset) < 0)
5107 {
5108 print_sys_errmsg (pi->pathname, errno);
5109 error ("PIOCGENTRY failed");
5110 }
5111
5112 praddset (&sysset, syscall_num);
5113
5114 if (ioctl (pi->ctl_fd, PIOCSENTRY, &sysset) < 0)
5115 {
5116 print_sys_errmsg (pi->pathname, errno);
5117 error ("PIOCSENTRY failed");
5118 }
5119 }
5120
5121 if (flags & PROCFS_SYSCALL_EXIT)
5122 {
5123 if (ioctl (pi->ctl_fd, PIOCGEXIT, &sysset) < 0)
5124 {
5125 procfs_clear_syscall_trap (pi, syscall_num, 1);
5126 print_sys_errmsg (pi->pathname, errno);
5127 error ("PIOCGEXIT failed");
5128 }
5129
5130 praddset (&sysset, syscall_num);
5131
5132 if (ioctl (pi->ctl_fd, PIOCSEXIT, &sysset) < 0)
5133 {
5134 procfs_clear_syscall_trap (pi, syscall_num, 1);
5135 print_sys_errmsg (pi->pathname, errno);
5136 error ("PIOCSEXIT failed");
5137 }
5138 }
5139
5140 if (!pi->syscall_handlers)
5141 {
5142 pi->syscall_handlers = xmalloc (sizeof (struct procfs_syscall_handler));
5143 pi->syscall_handlers[0].syscall_num = syscall_num;
5144 pi->syscall_handlers[0].func = func;
5145 pi->num_syscall_handlers = 1;
5146 }
5147 else
5148 {
5149 int i;
5150
5151 for (i = 0; i < pi->num_syscall_handlers; i++)
5152 if (pi->syscall_handlers[i].syscall_num == syscall_num)
5153 {
5154 pi->syscall_handlers[i].func = func;
5155 return;
5156 }
5157
5158 pi->syscall_handlers = xrealloc (pi->syscall_handlers, (i + 1)
5159 * sizeof (struct procfs_syscall_handler));
5160 pi->syscall_handlers[i].syscall_num = syscall_num;
5161 pi->syscall_handlers[i].func = func;
5162 pi->num_syscall_handlers++;
5163 }
5164 }
5165
5166 #ifdef SYS_lwp_create
5167
5168 /*
5169
5170 LOCAL FUNCTION
5171
5172 procfs_lwp_creation_handler - handle exit from the _lwp_create syscall
5173
5174 SYNOPSIS
5175
5176 int procfs_lwp_creation_handler (pi, syscall_num, why, rtnvalp, statvalp)
5177
5178 DESCRIPTION
5179
5180 This routine is called both when an inferior process and it's new lwp
5181 are about to finish a _lwp_create() system call. This is the system
5182 call that Solaris uses to create a lightweight process. When the
5183 target process gets this event, we can look at sysarg[2] to find the
5184 new childs lwp ID, and create a procinfo struct from that. After that,
5185 we pretend that we got a SIGTRAP, and return non-zero to tell
5186 procfs_wait to wake up. Subsequently, wait_for_inferior gets woken up,
5187 sees the new process and continues it.
5188
5189 When we see the child exiting from lwp_create, we just contine it,
5190 since everything was handled when the parent trapped.
5191
5192 NOTES
5193 In effect, we are only paying attention to the parent's completion of
5194 the lwp_create syscall. If we only paid attention to the child
5195 instead, then we wouldn't detect the creation of a suspended thread.
5196 */
5197
5198 static int
5199 procfs_lwp_creation_handler (pi, syscall_num, why, rtnvalp, statvalp)
5200 struct procinfo *pi;
5201 int syscall_num;
5202 int why;
5203 int *rtnvalp;
5204 int *statvalp;
5205 {
5206 int lwp_id;
5207 struct procinfo *childpi;
5208
5209 /* We've just detected the completion of an lwp_create system call. Now we
5210 need to setup a procinfo struct for this thread, and notify the thread
5211 system of the new arrival. */
5212
5213 /* If lwp_create failed, then nothing interesting happened. Continue the
5214 process and go back to sleep. */
5215
5216 if (pi->prstatus.pr_reg[R_PSR] & PS_FLAG_CARRY)
5217 { /* _lwp_create failed */
5218 pi->prrun.pr_flags &= PRSTEP;
5219 pi->prrun.pr_flags |= PRCFAULT;
5220
5221 if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
5222 perror_with_name (pi->pathname);
5223
5224 return 0;
5225 }
5226
5227 /* At this point, the new thread is stopped at it's first instruction, and
5228 the parent is stopped at the exit from lwp_create. */
5229
5230 if (pi->new_child) /* Child? */
5231 { /* Yes, just continue it */
5232 pi->prrun.pr_flags &= PRSTEP;
5233 pi->prrun.pr_flags |= PRCFAULT;
5234
5235 if ((pi->prstatus.pr_flags & PR_ISTOP)
5236 && ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
5237 perror_with_name (pi->pathname);
5238
5239 pi->new_child = 0; /* No longer new */
5240
5241 return 0;
5242 }
5243
5244 /* We're the proud parent of a new thread. Setup an exit trap for lwp_create
5245 in the child and continue the parent. */
5246
5247 /* Third arg is pointer to new thread id. */
5248 lwp_id = read_memory_integer (pi->prstatus.pr_sysarg[2], sizeof (int));
5249
5250 lwp_id = (lwp_id << 16) | PIDGET (pi->pid);
5251
5252 childpi = create_procinfo (lwp_id);
5253
5254 /* The new process has actually inherited the lwp_create syscall trap from
5255 it's parent, but we still have to call this to register handlers for
5256 that child. */
5257
5258 procfs_set_inferior_syscall_traps (childpi);
5259 add_thread (lwp_id);
5260 printf_filtered ("[New %s]\n", target_pid_to_str (lwp_id));
5261
5262 /* Continue the parent */
5263
5264 pi->prrun.pr_flags &= PRSTEP;
5265 pi->prrun.pr_flags |= PRCFAULT;
5266 if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
5267 perror_with_name (pi->pathname);
5268
5269 /* The new child may have been created in one of two states:
5270 SUSPENDED or RUNNABLE. If runnable, we will simply signal it to run.
5271 If suspended, we flag it to be continued later, when it has an event. */
5272
5273 if (childpi->prstatus.pr_why == PR_SUSPENDED)
5274 childpi->new_child = 1; /* Flag this as an unseen child process */
5275 else
5276 {
5277 /* Continue the child */
5278 childpi->prrun.pr_flags &= PRSTEP;
5279 childpi->prrun.pr_flags |= PRCFAULT;
5280
5281 if (ioctl (childpi->ctl_fd, PIOCRUN, &childpi->prrun) != 0)
5282 perror_with_name (childpi->pathname);
5283 }
5284 return 0;
5285 }
5286 #endif /* SYS_lwp_create */
5287
5288 /* Fork an inferior process, and start debugging it with /proc. */
5289
5290 static void
5291 procfs_create_inferior (exec_file, allargs, env)
5292 char *exec_file;
5293 char *allargs;
5294 char **env;
5295 {
5296 char *shell_file = getenv ("SHELL");
5297 char *tryname;
5298 if (shell_file != NULL && strchr (shell_file, '/') == NULL)
5299 {
5300
5301 /* We will be looking down the PATH to find shell_file. If we
5302 just do this the normal way (via execlp, which operates by
5303 attempting an exec for each element of the PATH until it
5304 finds one which succeeds), then there will be an exec for
5305 each failed attempt, each of which will cause a PR_SYSEXIT
5306 stop, and we won't know how to distinguish the PR_SYSEXIT's
5307 for these failed execs with the ones for successful execs
5308 (whether the exec has succeeded is stored at that time in the
5309 carry bit or some such architecture-specific and
5310 non-ABI-specified place).
5311
5312 So I can't think of anything better than to search the PATH
5313 now. This has several disadvantages: (1) There is a race
5314 condition; if we find a file now and it is deleted before we
5315 exec it, we lose, even if the deletion leaves a valid file
5316 further down in the PATH, (2) there is no way to know exactly
5317 what an executable (in the sense of "capable of being
5318 exec'd") file is. Using access() loses because it may lose
5319 if the caller is the superuser; failing to use it loses if
5320 there are ACLs or some such. */
5321
5322 char *p;
5323 char *p1;
5324 /* FIXME-maybe: might want "set path" command so user can change what
5325 path is used from within GDB. */
5326 char *path = getenv ("PATH");
5327 int len;
5328 struct stat statbuf;
5329
5330 if (path == NULL)
5331 path = "/bin:/usr/bin";
5332
5333 tryname = alloca (strlen (path) + strlen (shell_file) + 2);
5334 for (p = path; p != NULL; p = p1 ? p1 + 1: NULL)
5335 {
5336 p1 = strchr (p, ':');
5337 if (p1 != NULL)
5338 len = p1 - p;
5339 else
5340 len = strlen (p);
5341 strncpy (tryname, p, len);
5342 tryname[len] = '\0';
5343 strcat (tryname, "/");
5344 strcat (tryname, shell_file);
5345 if (access (tryname, X_OK) < 0)
5346 continue;
5347 if (stat (tryname, &statbuf) < 0)
5348 continue;
5349 if (!S_ISREG (statbuf.st_mode))
5350 /* We certainly need to reject directories. I'm not quite
5351 as sure about FIFOs, sockets, etc., but I kind of doubt
5352 that people want to exec() these things. */
5353 continue;
5354 break;
5355 }
5356 if (p == NULL)
5357 /* Not found. This must be an error rather than merely passing
5358 the file to execlp(), because execlp() would try all the
5359 exec()s, causing GDB to get confused. */
5360 error ("Can't find shell %s in PATH", shell_file);
5361
5362 shell_file = tryname;
5363 }
5364
5365 fork_inferior (exec_file, allargs, env,
5366 proc_set_exec_trap, procfs_init_inferior, shell_file);
5367
5368 /* We are at the first instruction we care about. */
5369 /* Pedal to the metal... */
5370
5371 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
5372 }
5373
5374 /* Clean up after the inferior dies. */
5375
5376 static void
5377 procfs_mourn_inferior ()
5378 {
5379 struct procinfo *pi;
5380 struct procinfo *next_pi;
5381
5382 for (pi = procinfo_list; pi; pi = next_pi)
5383 {
5384 next_pi = pi->next;
5385 unconditionally_kill_inferior (pi);
5386 }
5387
5388 unpush_target (&procfs_ops);
5389 generic_mourn_inferior ();
5390 }
5391
5392
5393 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
5394 static int
5395 procfs_can_run ()
5396 {
5397 /* This variable is controlled by modules that sit atop procfs that may layer
5398 their own process structure atop that provided here. sol-thread.c does
5399 this because of the Solaris two-level thread model. */
5400
5401 return !procfs_suppress_run;
5402 }
5403 #ifdef TARGET_HAS_HARDWARE_WATCHPOINTS
5404 \f
5405 /* Insert a watchpoint */
5406 int
5407 procfs_set_watchpoint(pid, addr, len, rw)
5408 int pid;
5409 CORE_ADDR addr;
5410 int len;
5411 int rw;
5412 {
5413 struct procinfo *pi;
5414 prwatch_t wpt;
5415
5416 pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
5417 wpt.pr_vaddr = (caddr_t)addr;
5418 wpt.pr_size = len;
5419 wpt.pr_wflags = ((rw & 1) ? MA_READ : 0) | ((rw & 2) ? MA_WRITE : 0);
5420 if (ioctl (pi->ctl_fd, PIOCSWATCH, &wpt) < 0)
5421 {
5422 if (errno == E2BIG)
5423 return -1;
5424 /* Currently it sometimes happens that the same watchpoint gets
5425 deleted twice - don't die in this case (FIXME please) */
5426 if (errno == ESRCH && len == 0)
5427 return 0;
5428 print_sys_errmsg (pi->pathname, errno);
5429 error ("PIOCSWATCH failed");
5430 }
5431 return 0;
5432 }
5433
5434 int
5435 procfs_stopped_by_watchpoint(pid)
5436 int pid;
5437 {
5438 struct procinfo *pi;
5439 short what;
5440 short why;
5441
5442 pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
5443 if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
5444 {
5445 why = pi->prstatus.pr_why;
5446 what = pi->prstatus.pr_what;
5447 if (why == PR_FAULTED
5448 #if defined (FLTWATCH) && defined (FLTKWATCH)
5449 && (what == FLTWATCH || what == FLTKWATCH)
5450 #else
5451 #ifdef FLTWATCH
5452 && (what == FLTWATCH)
5453 #endif
5454 #ifdef FLTKWATCH
5455 && (what == FLTKWATCH)
5456 #endif
5457 #endif
5458 )
5459 return what;
5460 }
5461 return 0;
5462 }
5463 #endif /* TARGET_HAS_HARDWARE_WATCHPOINTS */
5464
5465 /* Why is this necessary? Shouldn't dead threads just be removed from the
5466 thread database? */
5467
5468 static int
5469 procfs_thread_alive (pid)
5470 int pid;
5471 {
5472 struct procinfo *pi, *next_pi;
5473
5474 for (pi = procinfo_list; pi; pi = next_pi)
5475 {
5476 next_pi = pi->next;
5477 if (pi -> pid == pid)
5478 if (procfs_read_status (pi)) /* alive */
5479 return 1;
5480 else /* defunct (exited) */
5481 {
5482 close_proc_file (pi);
5483 return 0;
5484 }
5485 }
5486 return 0;
5487 }
5488
5489 int
5490 procfs_first_available ()
5491 {
5492 struct procinfo *pi;
5493
5494 for (pi = procinfo_list; pi; pi = pi->next)
5495 {
5496 if (procfs_read_status (pi))
5497 return pi->pid;
5498 }
5499 return -1;
5500 }
5501
5502 /* Send a SIGINT to the process group. This acts just like the user typed a
5503 ^C on the controlling terminal.
5504
5505 XXX - This may not be correct for all systems. Some may want to use
5506 killpg() instead of kill (-pgrp). */
5507
5508 static void
5509 procfs_stop ()
5510 {
5511 extern pid_t inferior_process_group;
5512
5513 kill (-inferior_process_group, SIGINT);
5514 }
5515 \f
5516 /* Convert a pid to printable form. */
5517
5518 #ifdef TIDGET
5519 char *
5520 procfs_pid_to_str (pid)
5521 int pid;
5522 {
5523 static char buf[100];
5524
5525 sprintf (buf, "Kernel thread %d", TIDGET (pid));
5526
5527 return buf;
5528 }
5529 #endif /* TIDGET */
5530 \f
5531 struct target_ops procfs_ops = {
5532 "procfs", /* to_shortname */
5533 "Unix /proc child process", /* to_longname */
5534 "Unix /proc child process (started by the \"run\" command).", /* to_doc */
5535 procfs_open, /* to_open */
5536 0, /* to_close */
5537 procfs_attach, /* to_attach */
5538 procfs_detach, /* to_detach */
5539 procfs_resume, /* to_resume */
5540 procfs_wait, /* to_wait */
5541 procfs_fetch_registers, /* to_fetch_registers */
5542 procfs_store_registers, /* to_store_registers */
5543 procfs_prepare_to_store, /* to_prepare_to_store */
5544 procfs_xfer_memory, /* to_xfer_memory */
5545 procfs_files_info, /* to_files_info */
5546 memory_insert_breakpoint, /* to_insert_breakpoint */
5547 memory_remove_breakpoint, /* to_remove_breakpoint */
5548 terminal_init_inferior, /* to_terminal_init */
5549 terminal_inferior, /* to_terminal_inferior */
5550 terminal_ours_for_output, /* to_terminal_ours_for_output */
5551 terminal_ours, /* to_terminal_ours */
5552 child_terminal_info, /* to_terminal_info */
5553 procfs_kill_inferior, /* to_kill */
5554 0, /* to_load */
5555 0, /* to_lookup_symbol */
5556 procfs_create_inferior, /* to_create_inferior */
5557 procfs_mourn_inferior, /* to_mourn_inferior */
5558 procfs_can_run, /* to_can_run */
5559 procfs_notice_signals, /* to_notice_signals */
5560 procfs_thread_alive, /* to_thread_alive */
5561 procfs_stop, /* to_stop */
5562 process_stratum, /* to_stratum */
5563 0, /* to_next */
5564 1, /* to_has_all_memory */
5565 1, /* to_has_memory */
5566 1, /* to_has_stack */
5567 1, /* to_has_registers */
5568 1, /* to_has_execution */
5569 0, /* sections */
5570 0, /* sections_end */
5571 OPS_MAGIC /* to_magic */
5572 };
5573
5574 void
5575 _initialize_procfs ()
5576 {
5577 #ifdef HAVE_OPTIONAL_PROC_FS
5578 char procname[MAX_PROC_NAME_SIZE];
5579 int fd;
5580
5581 /* If we have an optional /proc filesystem (e.g. under OSF/1),
5582 don't add procfs support if we cannot access the running
5583 GDB via /proc. */
5584 sprintf (procname, STATUS_PROC_NAME_FMT, getpid ());
5585 if ((fd = open (procname, O_RDONLY)) < 0)
5586 return;
5587 close (fd);
5588 #endif
5589
5590 add_target (&procfs_ops);
5591
5592 add_info ("processes", info_proc,
5593 "Show process status information using /proc entry.\n\
5594 Specify process id or use current inferior by default.\n\
5595 Specify keywords for detailed information; default is summary.\n\
5596 Keywords are: `all', `faults', `flags', `id', `mappings', `signals',\n\
5597 `status', `syscalls', and `times'.\n\
5598 Unambiguous abbreviations may be used.");
5599
5600 init_syscall_table ();
5601 }
A mirror of the official binutils-gdb repository