projects / deliverable / binutils-gdb.git / blob
? search:


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