projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
import gdb-1999-10-04 snapshot
[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 #else /* ! UNIXWARE */
2269 ioctl (pi->ctl_fd, PIOCGTRACE, &pi->saved_trace.sigset);
2270 ioctl (pi->ctl_fd, PIOCGHOLD, &pi->saved_sighold.sigset);
2271 ioctl (pi->ctl_fd, PIOCGFAULT, &pi->saved_fltset.fltset);
2272 ioctl (pi->ctl_fd, PIOCGENTRY, &pi->saved_entryset.sysset);
2273 ioctl (pi->ctl_fd, PIOCGEXIT, &pi->saved_exitset.sysset);
2274
2275 /* Set up trace and fault sets, as gdb expects them. */
2276
2277 memset ((char *) &pi->prrun, 0, sizeof (pi->prrun));
2278 prfillset (&pi->prrun.pr_trace);
2279 procfs_notice_signals (pid);
2280 #endif /* UNIXWARE */
2281
2282 if (!procfs_read_status (pi))
2283 proc_init_failed (pi, "procfs_read_status failed", kill);
2284
2285 return pi;
2286 }
2287
2288 /*
2289
2290 LOCAL FUNCTION
2291
2292 create_procinfo - initialize access to a /proc entry
2293
2294 SYNOPSIS
2295
2296 struct procinfo * create_procinfo (int pid)
2297
2298 DESCRIPTION
2299
2300 Allocate a procinfo structure, open the /proc file and then set up the
2301 set of signals and faults that are to be traced. Returns a pointer to
2302 the new procinfo structure.
2303
2304 NOTES
2305
2306 If proc_init_failed ever gets called, control returns to the command
2307 processing loop via the standard error handling code.
2308
2309 */
2310
2311 static struct procinfo *
2312 create_procinfo (pid)
2313 int pid;
2314 {
2315 struct procinfo *pi;
2316 struct sig_ctl sctl;
2317 struct flt_ctl fctl;
2318
2319 pi = find_procinfo (pid, 1);
2320 if (pi != NULL)
2321 return pi; /* All done! It already exists */
2322
2323 pi = init_procinfo (pid, 1);
2324
2325 #ifndef UNIXWARE
2326 /* A bug in Solaris (2.5 at least) causes PIOCWSTOP to hang on LWPs that are
2327 already stopped, even if they all have PR_ASYNC set. */
2328 if (!(pi->prstatus.pr_flags & PR_STOPPED))
2329 #endif
2330 if (!procfs_write_pcwstop (pi))
2331 proc_init_failed (pi, "procfs_write_pcwstop failed", 1);
2332
2333 #ifdef PROCFS_USE_READ_WRITE
2334 fctl.cmd = PCSFAULT;
2335 prfillset (&fctl.fltset);
2336 prdelset (&fctl.fltset, FLTPAGE);
2337
2338 if (write (pi->ctl_fd, (char *) &fctl, sizeof (struct flt_ctl)) < 0)
2339 proc_init_failed (pi, "PCSFAULT failed", 1);
2340 #else
2341 prfillset (&pi->prrun.pr_fault);
2342 prdelset (&pi->prrun.pr_fault, FLTPAGE);
2343 #ifdef PROCFS_DONT_TRACE_FAULTS
2344 premptyset (&pi->prrun.pr_fault);
2345 #endif
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 prfillset (&fctl.fltset);
3322 prdelset (&fctl.fltset, FLTPAGE);
3323
3324 if (write (pi->ctl_fd, (char *) &fctl, sizeof (struct flt_ctl)) < 0)
3325 print_sys_errmsg ("PCSFAULT failed", errno);
3326 #else /* PROCFS_USE_READ_WRITE */
3327 prfillset (&pi->prrun.pr_fault);
3328 prdelset (&pi->prrun.pr_fault, FLTPAGE);
3329 #ifdef PROCFS_DONT_TRACE_FAULTS
3330 premptyset (&pi->prrun.pr_fault);
3331 #endif
3332 if (ioctl (pi->ctl_fd, PIOCSFAULT, &pi->prrun.pr_fault))
3333 {
3334 print_sys_errmsg ("PIOCSFAULT failed", errno);
3335 }
3336 if (ioctl (pi->ctl_fd, PIOCSTRACE, &pi->prrun.pr_trace))
3337 {
3338 print_sys_errmsg ("PIOCSTRACE failed", errno);
3339 }
3340 add_thread (pi->pid);
3341 procfs_set_inferior_syscall_traps (pi);
3342 #endif /* PROCFS_USE_READ_WRITE */
3343 }
3344 attach_flag = 1;
3345 return (pi->pid);
3346 }
3347
3348 /*
3349
3350 LOCAL FUNCTION
3351
3352 do_detach -- detach from an attached-to process
3353
3354 SYNOPSIS
3355
3356 void do_detach (int signal)
3357
3358 DESCRIPTION
3359
3360 Detach from the current attachee.
3361
3362 If signal is non-zero, the attachee is started running again and sent
3363 the specified signal.
3364
3365 If signal is zero and the attachee was not already stopped when we
3366 attached to it, then we make it runnable again when we detach.
3367
3368 Otherwise, we query whether or not to make the attachee runnable
3369 again, since we may simply want to leave it in the state it was in
3370 when we attached.
3371
3372 We report any problems, but do not consider them errors, since we
3373 MUST detach even if some things don't seem to go right. This may not
3374 be the ideal situation. (FIXME).
3375 */
3376
3377 static void
3378 do_detach (signal)
3379 int signal;
3380 {
3381 struct procinfo *pi;
3382
3383 for (pi = procinfo_list; pi; pi = pi->next)
3384 {
3385 if (signal)
3386 {
3387 set_proc_siginfo (pi, signal);
3388 }
3389 #ifdef PROCFS_USE_READ_WRITE
3390 pi->saved_exitset.cmd = PCSEXIT;
3391 if (write (pi->ctl_fd, (char *) &pi->saved_exitset,
3392 sizeof (struct sys_ctl)) < 0)
3393 #else
3394 if (ioctl (pi->ctl_fd, PIOCSEXIT, &pi->saved_exitset.sysset) < 0)
3395 #endif
3396 {
3397 print_sys_errmsg (pi->pathname, errno);
3398 printf_unfiltered ("PIOCSEXIT failed.\n");
3399 }
3400 #ifdef PROCFS_USE_READ_WRITE
3401 pi->saved_entryset.cmd = PCSENTRY;
3402 if (write (pi->ctl_fd, (char *) &pi->saved_entryset,
3403 sizeof (struct sys_ctl)) < 0)
3404 #else
3405 if (ioctl (pi->ctl_fd, PIOCSENTRY, &pi->saved_entryset.sysset) < 0)
3406 #endif
3407 {
3408 print_sys_errmsg (pi->pathname, errno);
3409 printf_unfiltered ("PIOCSENTRY failed.\n");
3410 }
3411 #ifdef PROCFS_USE_READ_WRITE
3412 pi->saved_trace.cmd = PCSTRACE;
3413 if (write (pi->ctl_fd, (char *) &pi->saved_trace,
3414 sizeof (struct sig_ctl)) < 0)
3415 #else
3416 if (ioctl (pi->ctl_fd, PIOCSTRACE, &pi->saved_trace.sigset) < 0)
3417 #endif
3418 {
3419 print_sys_errmsg (pi->pathname, errno);
3420 printf_unfiltered ("PIOCSTRACE failed.\n");
3421 }
3422 #ifndef UNIXWARE
3423 if (ioctl (pi->ctl_fd, PIOCSHOLD, &pi->saved_sighold.sigset) < 0)
3424 {
3425 print_sys_errmsg (pi->pathname, errno);
3426 printf_unfiltered ("PIOSCHOLD failed.\n");
3427 }
3428 #endif
3429 #ifdef PROCFS_USE_READ_WRITE
3430 pi->saved_fltset.cmd = PCSFAULT;
3431 if (write (pi->ctl_fd, (char *) &pi->saved_fltset,
3432 sizeof (struct flt_ctl)) < 0)
3433 #else
3434 if (ioctl (pi->ctl_fd, PIOCSFAULT, &pi->saved_fltset.fltset) < 0)
3435 #endif
3436 {
3437 print_sys_errmsg (pi->pathname, errno);
3438 printf_unfiltered ("PIOCSFAULT failed.\n");
3439 }
3440 if (!procfs_read_status (pi))
3441 {
3442 print_sys_errmsg (pi->pathname, errno);
3443 printf_unfiltered ("procfs_read_status failed.\n");
3444 }
3445 else
3446 {
3447 if (signal
3448 || (THE_PR_LWP (pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP)))
3449 {
3450 long cmd;
3451 struct proc_ctl pctl;
3452
3453 if (signal || !pi->was_stopped ||
3454 query ("Was stopped when attached, make it runnable again? "))
3455 {
3456 /* Clear any pending signal if we want to detach without
3457 a signal. */
3458 if (signal == 0)
3459 set_proc_siginfo (pi, signal);
3460
3461 /* Clear any fault that might have stopped it. */
3462 #ifdef PROCFS_USE_READ_WRITE
3463 cmd = PCCFAULT;
3464 if (write (pi->ctl_fd, (char *) &cmd, sizeof (long)) < 0)
3465 #else
3466 if (ioctl (pi->ctl_fd, PIOCCFAULT, 0))
3467 #endif
3468 {
3469 print_sys_errmsg (pi->pathname, errno);
3470 printf_unfiltered ("PIOCCFAULT failed.\n");
3471 }
3472
3473 /* Make it run again when we close it. */
3474
3475 modify_run_on_last_close_flag (pi->ctl_fd, 1);
3476 }
3477 }
3478 }
3479 close_proc_file (pi);
3480 }
3481 attach_flag = 0;
3482 }
3483
3484 /* emulate wait() as much as possible.
3485 Wait for child to do something. Return pid of child, or -1 in case
3486 of error; store status in *OURSTATUS.
3487
3488 Not sure why we can't
3489 just use wait(), but it seems to have problems when applied to a
3490 process being controlled with the /proc interface.
3491
3492 We have a race problem here with no obvious solution. We need to let
3493 the inferior run until it stops on an event of interest, which means
3494 that we need to use the PIOCWSTOP ioctl. However, we cannot use this
3495 ioctl if the process is already stopped on something that is not an
3496 event of interest, or the call will hang indefinitely. Thus we first
3497 use PIOCSTATUS to see if the process is not stopped. If not, then we
3498 use PIOCWSTOP. But during the window between the two, if the process
3499 stops for any reason that is not an event of interest (such as a job
3500 control signal) then gdb will hang. One possible workaround is to set
3501 an alarm to wake up every minute of so and check to see if the process
3502 is still running, and if so, then reissue the PIOCWSTOP. But this is
3503 a real kludge, so has not been implemented. FIXME: investigate
3504 alternatives.
3505
3506 FIXME: Investigate why wait() seems to have problems with programs
3507 being control by /proc routines. */
3508 static int
3509 procfs_wait (pid, ourstatus)
3510 int pid;
3511 struct target_waitstatus *ourstatus;
3512 {
3513 short what;
3514 short why;
3515 int statval = 0;
3516 int checkerr = 0;
3517 int rtnval = -1;
3518 struct procinfo *pi;
3519 struct proc_ctl pctl;
3520
3521 scan_again:
3522
3523 /* handle all syscall events first, otherwise we might not
3524 notice a thread was created until too late. */
3525
3526 for (pi = procinfo_list; pi; pi = pi->next)
3527 {
3528 if (!pi->had_event)
3529 continue;
3530
3531 if (!(THE_PR_LWP (pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP)))
3532 continue;
3533
3534 why = THE_PR_LWP (pi->prstatus).pr_why;
3535 what = THE_PR_LWP (pi->prstatus).pr_what;
3536 if (why == PR_SYSENTRY || why == PR_SYSEXIT)
3537 {
3538 int i;
3539 int found_handler = 0;
3540
3541 for (i = 0; i < pi->num_syscall_handlers; i++)
3542 if (pi->syscall_handlers[i].syscall_num == what)
3543 {
3544 found_handler = 1;
3545 pi->saved_rtnval = pi->pid;
3546 pi->saved_statval = 0;
3547 if (!pi->syscall_handlers[i].func
3548 (pi, what, why, &pi->saved_rtnval, &pi->saved_statval))
3549 pi->had_event = 0;
3550 break;
3551 }
3552
3553 if (!found_handler)
3554 {
3555 if (why == PR_SYSENTRY)
3556 error ("PR_SYSENTRY, unhandled system call %d", what);
3557 else
3558 error ("PR_SYSEXIT, unhandled system call %d", what);
3559 }
3560 }
3561 }
3562
3563 /* find a relevant process with an event */
3564
3565 for (pi = procinfo_list; pi; pi = pi->next)
3566 if (pi->had_event && (pid == -1 || pi->pid == pid))
3567 break;
3568
3569 if (!pi)
3570 {
3571 wait_fd ();
3572 goto scan_again;
3573 }
3574
3575 if (!checkerr
3576 && !(THE_PR_LWP (pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP)))
3577 {
3578 if (!procfs_write_pcwstop (pi))
3579 {
3580 checkerr++;
3581 }
3582 }
3583 if (checkerr)
3584 {
3585 if (errno == ENOENT)
3586 {
3587 /* XXX Fixme -- what to do if attached? Can't call wait... */
3588 rtnval = wait (&statval);
3589 if ((rtnval) != (PIDGET (inferior_pid)))
3590 {
3591 print_sys_errmsg (pi->pathname, errno);
3592 error ("procfs_wait: wait failed, returned %d", rtnval);
3593 /* NOTREACHED */
3594 }
3595 }
3596 else
3597 {
3598 print_sys_errmsg (pi->pathname, errno);
3599 error ("PIOCSTATUS or PIOCWSTOP failed.");
3600 /* NOTREACHED */
3601 }
3602 }
3603 else if (THE_PR_LWP (pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP))
3604 {
3605 #ifdef UNIXWARE
3606 rtnval = pi->prstatus.pr_pid;
3607 #else
3608 rtnval = pi->pid;
3609 #endif
3610 why = THE_PR_LWP (pi->prstatus).pr_why;
3611 what = THE_PR_LWP (pi->prstatus).pr_what;
3612
3613 switch (why)
3614 {
3615 case PR_SIGNALLED:
3616 statval = (what << 8) | 0177;
3617 break;
3618 case PR_SYSENTRY:
3619 case PR_SYSEXIT:
3620 rtnval = pi->saved_rtnval;
3621 statval = pi->saved_statval;
3622 break;
3623 case PR_REQUESTED:
3624 statval = (SIGSTOP << 8) | 0177;
3625 break;
3626 case PR_JOBCONTROL:
3627 statval = (what << 8) | 0177;
3628 break;
3629 case PR_FAULTED:
3630 switch (what)
3631 {
3632 #ifdef FLTWATCH
3633 case FLTWATCH:
3634 statval = (SIGTRAP << 8) | 0177;
3635 break;
3636 #endif
3637 #ifdef FLTKWATCH
3638 case FLTKWATCH:
3639 statval = (SIGTRAP << 8) | 0177;
3640 break;
3641 #endif
3642 #ifndef FAULTED_USE_SIGINFO
3643 /* Irix, contrary to the documentation, fills in 0 for si_signo.
3644 Solaris fills in si_signo. I'm not sure about others. */
3645 case FLTPRIV:
3646 case FLTILL:
3647 statval = (SIGILL << 8) | 0177;
3648 break;
3649 case FLTBPT:
3650 case FLTTRACE:
3651 statval = (SIGTRAP << 8) | 0177;
3652 break;
3653 case FLTSTACK:
3654 case FLTACCESS:
3655 case FLTBOUNDS:
3656 statval = (SIGSEGV << 8) | 0177;
3657 break;
3658 case FLTIOVF:
3659 case FLTIZDIV:
3660 case FLTFPE:
3661 statval = (SIGFPE << 8) | 0177;
3662 break;
3663 case FLTPAGE: /* Recoverable page fault */
3664 #endif /* not FAULTED_USE_SIGINFO */
3665 default:
3666 /* Use the signal which the kernel assigns. This is better than
3667 trying to second-guess it from the fault. In fact, I suspect
3668 that FLTACCESS can be either SIGSEGV or SIGBUS. */
3669 statval =
3670 ((THE_PR_LWP (pi->prstatus).pr_info.si_signo) << 8) | 0177;
3671 break;
3672 }
3673 break;
3674 default:
3675 error ("PIOCWSTOP, unknown why %d, what %d", why, what);
3676 }
3677 /* Stop all the other threads when any of them stops. */
3678
3679 {
3680 struct procinfo *procinfo, *next_pi;
3681
3682 for (procinfo = procinfo_list; procinfo; procinfo = next_pi)
3683 {
3684 next_pi = procinfo->next;
3685 if (!procinfo->had_event)
3686 {
3687 #ifdef PROCFS_USE_READ_WRITE
3688 long cmd = PCSTOP;
3689 if (write (pi->ctl_fd, (char *) &cmd, sizeof (long)) < 0)
3690 {
3691 print_sys_errmsg (procinfo->pathname, errno);
3692 error ("PCSTOP failed");
3693 }
3694 #else
3695 /* A bug in Solaris (2.5) causes us to hang when trying to
3696 stop a stopped process. So, we have to check first in
3697 order to avoid the hang. */
3698 if (!procfs_read_status (procinfo))
3699 {
3700 /* The LWP has apparently terminated. */
3701 if (info_verbose)
3702 printf_filtered ("LWP %d doesn't respond.\n",
3703 (procinfo->pid >> 16) & 0xffff);
3704 close_proc_file (procinfo);
3705 continue;
3706 }
3707
3708 if (!(procinfo->prstatus.pr_flags & PR_STOPPED))
3709 if (ioctl (procinfo->ctl_fd, PIOCSTOP, &procinfo->prstatus)
3710 < 0)
3711 {
3712 print_sys_errmsg (procinfo->pathname, errno);
3713 warning ("PIOCSTOP failed");
3714 }
3715 #endif
3716 }
3717 }
3718 }
3719 }
3720 else
3721 {
3722 error ("PIOCWSTOP, stopped for unknown/unhandled reason, flags %#x",
3723 THE_PR_LWP (pi->prstatus).pr_flags);
3724 }
3725
3726 store_waitstatus (ourstatus, statval);
3727
3728 if (rtnval == -1) /* No more children to wait for */
3729 {
3730 warning ("Child process unexpectedly missing");
3731 /* Claim it exited with unknown signal. */
3732 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
3733 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
3734 return rtnval;
3735 }
3736
3737 pi->had_event = 0; /* Indicate that we've seen this one */
3738 return (rtnval);
3739 }
3740
3741 /*
3742
3743 LOCAL FUNCTION
3744
3745 set_proc_siginfo - set a process's current signal info
3746
3747 SYNOPSIS
3748
3749 void set_proc_siginfo (struct procinfo *pip, int signo);
3750
3751 DESCRIPTION
3752
3753 Given a pointer to a process info struct in PIP and a signal number
3754 in SIGNO, set the process's current signal and its associated signal
3755 information. The signal will be delivered to the process immediately
3756 after execution is resumed, even if it is being held. In addition,
3757 this particular delivery will not cause another PR_SIGNALLED stop
3758 even if the signal is being traced.
3759
3760 If we are not delivering the same signal that the prstatus siginfo
3761 struct contains information about, then synthesize a siginfo struct
3762 to match the signal we are going to deliver, make it of the type
3763 "generated by a user process", and send this synthesized copy. When
3764 used to set the inferior's signal state, this will be required if we
3765 are not currently stopped because of a traced signal, or if we decide
3766 to continue with a different signal.
3767
3768 Note that when continuing the inferior from a stop due to receipt
3769 of a traced signal, we either have set PRCSIG to clear the existing
3770 signal, or we have to call this function to do a PIOCSSIG with either
3771 the existing siginfo struct from pr_info, or one we have synthesized
3772 appropriately for the signal we want to deliver. Otherwise if the
3773 signal is still being traced, the inferior will immediately stop
3774 again.
3775
3776 See siginfo(5) for more details.
3777 */
3778
3779 static void
3780 set_proc_siginfo (pip, signo)
3781 struct procinfo *pip;
3782 int signo;
3783 {
3784 struct siginfo newsiginfo;
3785 struct siginfo *sip;
3786 struct sigi_ctl sictl;
3787
3788 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
3789 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
3790 receives a PIOCSSIG with a signal identical to the current signal,
3791 it messes up the current signal. Work around the kernel bug. */
3792 if (signo == THE_PR_LWP (pip->prstatus).pr_cursig)
3793 return;
3794 #endif
3795
3796 #ifdef UNIXWARE
3797 if (signo == THE_PR_LWP (pip->prstatus).pr_info.si_signo)
3798 {
3799 memcpy ((char *) &sictl.siginfo, (char *) &pip->prstatus.pr_lwp.pr_info,
3800 sizeof (siginfo_t));
3801 }
3802 #else
3803 if (signo == THE_PR_LWP (pip->prstatus).pr_info.si_signo)
3804 {
3805 sip = &pip->prstatus.pr_info;
3806 }
3807 #endif
3808 else
3809 {
3810 #ifdef UNIXWARE
3811 siginfo_t *sip = &sictl.siginfo;
3812 memset ((char *) sip, 0, sizeof (siginfo_t));
3813 #else
3814 memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
3815 sip = &newsiginfo;
3816 #endif
3817 sip->si_signo = signo;
3818 sip->si_code = 0;
3819 sip->si_errno = 0;
3820 sip->si_pid = getpid ();
3821 sip->si_uid = getuid ();
3822 }
3823 #ifdef PROCFS_USE_READ_WRITE
3824 sictl.cmd = PCSSIG;
3825 if (write (pip->ctl_fd, (char *) &sictl, sizeof (struct sigi_ctl)) < 0)
3826 #else
3827 if (ioctl (pip->ctl_fd, PIOCSSIG, sip) < 0)
3828 #endif
3829 {
3830 print_sys_errmsg (pip->pathname, errno);
3831 warning ("PIOCSSIG failed");
3832 }
3833 }
3834
3835 /* Resume execution of process PID. If STEP is nozero, then
3836 just single step it. If SIGNAL is nonzero, restart it with that
3837 signal activated. */
3838
3839 static void
3840 procfs_resume (pid, step, signo)
3841 int pid;
3842 int step;
3843 enum target_signal signo;
3844 {
3845 int signal_to_pass;
3846 struct procinfo *pi, *procinfo, *next_pi;
3847 struct proc_ctl pctl;
3848
3849 pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
3850
3851 errno = 0;
3852 #ifdef UNIXWARE
3853 pctl.cmd = PCRUN;
3854 pctl.data = PRCFAULT;
3855 #else
3856 pi->prrun.pr_flags = PRSTRACE | PRSFAULT | PRCFAULT;
3857 #endif
3858
3859 #if 0
3860 /* It should not be necessary. If the user explicitly changes the value,
3861 value_assign calls write_register_bytes, which writes it. */
3862 /* It may not be absolutely necessary to specify the PC value for
3863 restarting, but to be safe we use the value that gdb considers
3864 to be current. One case where this might be necessary is if the
3865 user explicitly changes the PC value that gdb considers to be
3866 current. FIXME: Investigate if this is necessary or not. */
3867
3868 #ifdef PRSVADDR_BROKEN
3869 /* Can't do this under Solaris running on a Sparc, as there seems to be no
3870 place to put nPC. In fact, if you use this, nPC seems to be set to some
3871 random garbage. We have to rely on the fact that PC and nPC have been
3872 written previously via PIOCSREG during a register flush. */
3873
3874 pi->prrun.pr_vaddr = (caddr_t) * (int *) &registers[REGISTER_BYTE (PC_REGNUM)];
3875 pi->prrun.pr_flags != PRSVADDR;
3876 #endif
3877 #endif
3878
3879 if (signo == TARGET_SIGNAL_STOP && pi->nopass_next_sigstop)
3880 /* When attaching to a child process, if we forced it to stop with
3881 a PIOCSTOP, then we will have set the nopass_next_sigstop flag.
3882 Upon resuming the first time after such a stop, we explicitly
3883 inhibit sending it another SIGSTOP, which would be the normal
3884 result of default signal handling. One potential drawback to
3885 this is that we will also ignore any attempt to by the user
3886 to explicitly continue after the attach with a SIGSTOP. Ultimately
3887 this problem should be dealt with by making the routines that
3888 deal with the inferior a little smarter, and possibly even allow
3889 an inferior to continue running at the same time as gdb. (FIXME?) */
3890 signal_to_pass = 0;
3891 else if (signo == TARGET_SIGNAL_TSTP
3892 && THE_PR_LWP (pi->prstatus).pr_cursig == SIGTSTP
3893 && THE_PR_LWP (pi->prstatus).pr_action.sa_handler == SIG_DFL
3894 )
3895
3896 /* We are about to pass the inferior a SIGTSTP whose action is
3897 SIG_DFL. The SIG_DFL action for a SIGTSTP is to stop
3898 (notifying the parent via wait()), and then keep going from the
3899 same place when the parent is ready for you to keep going. So
3900 under the debugger, it should do nothing (as if the program had
3901 been stopped and then later resumed. Under ptrace, this
3902 happens for us, but under /proc, the system obligingly stops
3903 the process, and wait_for_inferior would have no way of
3904 distinguishing that type of stop (which indicates that we
3905 should just start it again), with a stop due to the pr_trace
3906 field of the prrun_t struct.
3907
3908 Note that if the SIGTSTP is being caught, we *do* need to pass it,
3909 because the handler needs to get executed. */
3910 signal_to_pass = 0;
3911 else
3912 signal_to_pass = target_signal_to_host (signo);
3913
3914 if (signal_to_pass)
3915 {
3916 set_proc_siginfo (pi, signal_to_pass);
3917 }
3918 else
3919 {
3920 #ifdef UNIXWARE
3921 pctl.data |= PRCSIG;
3922 #else
3923 pi->prrun.pr_flags |= PRCSIG;
3924 #endif
3925 }
3926 pi->nopass_next_sigstop = 0;
3927 if (step)
3928 {
3929 #ifdef UNIXWARE
3930 pctl.data |= PRSTEP;
3931 #else
3932 pi->prrun.pr_flags |= PRSTEP;
3933 #endif
3934 }
3935 pi->had_event = 0;
3936 /* Don't try to start a process unless it's stopped on an
3937 `event of interest'. Doing so will cause errors. */
3938
3939 if (!procfs_read_status (pi))
3940 {
3941 /* The LWP has apparently terminated. */
3942 if (info_verbose)
3943 printf_filtered ("LWP %d doesn't respond.\n",
3944 (pi->pid >> 16) & 0xffff);
3945 close_proc_file (pi);
3946 }
3947 else
3948 {
3949 #ifdef PROCFS_USE_READ_WRITE
3950 if (write (pi->ctl_fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
3951 #else
3952 if ((pi->prstatus.pr_flags & PR_ISTOP)
3953 && ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
3954 #endif
3955 {
3956 /* The LWP has apparently terminated. */
3957 if (info_verbose)
3958 printf_filtered ("LWP %d doesn't respond.\n",
3959 (pi->pid >> 16) & 0xffff);
3960 close_proc_file (pi);
3961 }
3962 }
3963
3964 /* Continue all the other threads that haven't had an event of interest.
3965 Also continue them if they have NOPASS_NEXT_SIGSTOP set; this is only
3966 set by do_attach, and means this is the first resume after an attach.
3967 All threads were CSTOP'd by do_attach, and should be resumed now. */
3968
3969 if (pid == -1)
3970 for (procinfo = procinfo_list; procinfo; procinfo = next_pi)
3971 {
3972 next_pi = procinfo->next;
3973 if (pi != procinfo)
3974 if (!procinfo->had_event ||
3975 (procinfo->nopass_next_sigstop && signo == TARGET_SIGNAL_STOP))
3976 {
3977 procinfo->had_event = procinfo->nopass_next_sigstop = 0;
3978 #ifdef PROCFS_USE_READ_WRITE
3979 pctl.data = PRCFAULT | PRCSIG;
3980 if (write (procinfo->ctl_fd, (char *) &pctl,
3981 sizeof (struct proc_ctl)) < 0)
3982 {
3983 if (!procfs_read_status (procinfo))
3984 fprintf_unfiltered (gdb_stderr,
3985 "procfs_read_status failed, errno=%d\n",
3986 errno);
3987 print_sys_errmsg (procinfo->pathname, errno);
3988 error ("PCRUN failed");
3989 }
3990 #else
3991 procinfo->prrun.pr_flags &= PRSTEP;
3992 procinfo->prrun.pr_flags |= PRCFAULT | PRCSIG;
3993 if (!procfs_read_status (procinfo))
3994 {
3995 /* The LWP has apparently terminated. */
3996 if (info_verbose)
3997 printf_filtered ("LWP %d doesn't respond.\n",
3998 (procinfo->pid >> 16) & 0xffff);
3999 close_proc_file (procinfo);
4000 continue;
4001 }
4002
4003 /* Don't try to start a process unless it's stopped on an
4004 `event of interest'. Doing so will cause errors. */
4005
4006 if ((procinfo->prstatus.pr_flags & PR_ISTOP)
4007 && ioctl (procinfo->ctl_fd, PIOCRUN, &procinfo->prrun) < 0)
4008 {
4009 if (!procfs_read_status (procinfo))
4010 fprintf_unfiltered (gdb_stderr,
4011 "procfs_read_status failed, errno=%d\n",
4012 errno);
4013 print_sys_errmsg (procinfo->pathname, errno);
4014 warning ("PIOCRUN failed");
4015 }
4016 #endif
4017 }
4018 procfs_read_status (procinfo);
4019 }
4020 }
4021
4022 /*
4023
4024 LOCAL FUNCTION
4025
4026 procfs_fetch_registers -- fetch current registers from inferior
4027
4028 SYNOPSIS
4029
4030 void procfs_fetch_registers (int regno)
4031
4032 DESCRIPTION
4033
4034 Read the current values of the inferior's registers, both the
4035 general register set and floating point registers (if supported)
4036 and update gdb's idea of their current values.
4037
4038 */
4039
4040 static void
4041 procfs_fetch_registers (regno)
4042 int regno;
4043 {
4044 struct procinfo *pi;
4045
4046 pi = current_procinfo;
4047
4048 #ifdef UNIXWARE
4049 if (procfs_read_status (pi))
4050 {
4051 supply_gregset (&pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs);
4052 #if defined (FP0_REGNUM)
4053 supply_fpregset (&pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs);
4054 #endif
4055 }
4056 #else /* UNIXWARE */
4057 if (ioctl (pi->ctl_fd, PIOCGREG, &pi->gregset.gregset) != -1)
4058 {
4059 supply_gregset (&pi->gregset.gregset);
4060 }
4061 #if defined (FP0_REGNUM)
4062 if (ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset.fpregset) != -1)
4063 {
4064 supply_fpregset (&pi->fpregset.fpregset);
4065 }
4066 #endif
4067 #endif /* UNIXWARE */
4068 }
4069
4070 /*
4071
4072 LOCAL FUNCTION
4073
4074 proc_init_failed - called when /proc access initialization fails
4075 fails
4076
4077 SYNOPSIS
4078
4079 static void proc_init_failed (struct procinfo *pi,
4080 char *why, int kill_p)
4081
4082 DESCRIPTION
4083
4084 This function is called whenever initialization of access to a /proc
4085 entry fails. It prints a suitable error message, does some cleanup,
4086 and then invokes the standard error processing routine which dumps
4087 us back into the command loop. If KILL_P is true, sends SIGKILL.
4088 */
4089
4090 static void
4091 proc_init_failed (pi, why, kill_p)
4092 struct procinfo *pi;
4093 char *why;
4094 int kill_p;
4095 {
4096 print_sys_errmsg (pi->pathname, errno);
4097 if (kill_p)
4098 kill (pi->pid, SIGKILL);
4099 close_proc_file (pi);
4100 error (why);
4101 /* NOTREACHED */
4102 }
4103
4104 /*
4105
4106 LOCAL FUNCTION
4107
4108 close_proc_file - close any currently open /proc entry
4109
4110 SYNOPSIS
4111
4112 static void close_proc_file (struct procinfo *pip)
4113
4114 DESCRIPTION
4115
4116 Close any currently open /proc entry and mark the process information
4117 entry as invalid. In order to ensure that we don't try to reuse any
4118 stale information, the pid, fd, and pathnames are explicitly
4119 invalidated, which may be overkill.
4120
4121 */
4122
4123 static void
4124 close_proc_file (pip)
4125 struct procinfo *pip;
4126 {
4127 struct procinfo *procinfo;
4128
4129 delete_thread (pip->pid); /* remove thread from GDB's thread list */
4130 remove_fd (pip); /* Remove fd from poll/select list */
4131
4132 close (pip->ctl_fd);
4133 #ifdef HAVE_MULTIPLE_PROC_FDS
4134 close (pip->as_fd);
4135 close (pip->status_fd);
4136 close (pip->map_fd);
4137 #endif
4138
4139 free (pip->pathname);
4140
4141 /* Unlink pip from the procinfo chain. Note pip might not be on the list. */
4142
4143 if (procinfo_list == pip)
4144 procinfo_list = pip->next;
4145 else
4146 {
4147 for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
4148 {
4149 if (procinfo->next == pip)
4150 {
4151 procinfo->next = pip->next;
4152 break;
4153 }
4154 }
4155 free (pip);
4156 }
4157 }
4158
4159 static void
4160 close_proc_file_cleanup (pip)
4161 void *pip;
4162 {
4163 close_proc_file ((struct procinfo *) pip);
4164 }
4165
4166 static struct cleanup *
4167 make_cleanup_close_proc_file (pip)
4168 struct procinfo *pip;
4169 {
4170 return make_cleanup (close_proc_file_cleanup, pip);
4171 }
4172
4173 /*
4174
4175 LOCAL FUNCTION
4176
4177 open_proc_file - open a /proc entry for a given process id
4178
4179 SYNOPSIS
4180
4181 static int open_proc_file (int pid, struct procinfo *pip, int mode)
4182
4183 DESCRIPTION
4184
4185 Given a process id and a mode, close the existing open /proc
4186 entry (if any) and open one for the new process id, in the
4187 specified mode. Once it is open, then mark the local process
4188 information structure as valid, which guarantees that the pid,
4189 fd, and pathname fields match an open /proc entry. Returns
4190 zero if the open fails, nonzero otherwise.
4191
4192 Note that the pathname is left intact, even when the open fails,
4193 so that callers can use it to construct meaningful error messages
4194 rather than just "file open failed".
4195
4196 Note that for Solaris, the process-id also includes an LWP-id, so we
4197 actually attempt to open that. If we are handed a pid with a 0 LWP-id,
4198 then we will ask the kernel what it is and add it to the pid. Hence,
4199 the pid can be changed by us.
4200 */
4201
4202 static int
4203 open_proc_file (pid, pip, mode, control)
4204 int pid;
4205 struct procinfo *pip;
4206 int mode;
4207 int control;
4208 {
4209 int tmp, tmpfd;
4210
4211 pip->next = NULL;
4212 pip->had_event = 0;
4213 pip->pathname = xmalloc (MAX_PROC_NAME_SIZE);
4214 pip->pid = pid;
4215
4216 #ifndef PIOCOPENLWP
4217 tmp = pid;
4218 #else
4219 tmp = pid & 0xffff;
4220 #endif
4221
4222 #ifdef HAVE_MULTIPLE_PROC_FDS
4223 sprintf (pip->pathname, STATUS_PROC_NAME_FMT, tmp);
4224 if ((pip->status_fd = open (pip->pathname, O_RDONLY)) < 0)
4225 {
4226 return 0;
4227 }
4228
4229 sprintf (pip->pathname, AS_PROC_NAME_FMT, tmp);
4230 if ((pip->as_fd = open (pip->pathname, O_RDWR)) < 0)
4231 {
4232 close (pip->status_fd);
4233 return 0;
4234 }
4235
4236 sprintf (pip->pathname, MAP_PROC_NAME_FMT, tmp);
4237 if ((pip->map_fd = open (pip->pathname, O_RDONLY)) < 0)
4238 {
4239 close (pip->status_fd);
4240 close (pip->as_fd);
4241 return 0;
4242 }
4243
4244 if (control)
4245 {
4246 sprintf (pip->pathname, CTL_PROC_NAME_FMT, tmp);
4247 if ((pip->ctl_fd = open (pip->pathname, O_WRONLY)) < 0)
4248 {
4249 close (pip->status_fd);
4250 close (pip->as_fd);
4251 close (pip->map_fd);
4252 return 0;
4253 }
4254 }
4255
4256 #else /* HAVE_MULTIPLE_PROC_FDS */
4257 sprintf (pip->pathname, CTL_PROC_NAME_FMT, tmp);
4258
4259 if ((tmpfd = open (pip->pathname, mode)) < 0)
4260 return 0;
4261
4262 #ifndef PIOCOPENLWP
4263 pip->ctl_fd = tmpfd;
4264 pip->as_fd = tmpfd;
4265 pip->map_fd = tmpfd;
4266 pip->status_fd = tmpfd;
4267 #else
4268 tmp = (pid >> 16) & 0xffff; /* Extract thread id */
4269
4270 if (tmp == 0)
4271 { /* Don't know thread id yet */
4272 if (ioctl (tmpfd, PIOCSTATUS, &pip->prstatus) < 0)
4273 {
4274 print_sys_errmsg (pip->pathname, errno);
4275 close (tmpfd);
4276 error ("open_proc_file: PIOCSTATUS failed");
4277 }
4278
4279 tmp = pip->prstatus.pr_who; /* Get thread id from prstatus_t */
4280 pip->pid = (tmp << 16) | pid; /* Update pip */
4281 }
4282
4283 if ((pip->ctl_fd = ioctl (tmpfd, PIOCOPENLWP, &tmp)) < 0)
4284 {
4285 close (tmpfd);
4286 return 0;
4287 }
4288
4289 #ifdef PIOCSET /* New method */
4290 {
4291 long pr_flags;
4292 pr_flags = PR_ASYNC;
4293 ioctl (pip->ctl_fd, PIOCSET, &pr_flags);
4294 }
4295 #endif
4296
4297 /* keep extra fds in sync */
4298 pip->as_fd = pip->ctl_fd;
4299 pip->map_fd = pip->ctl_fd;
4300 pip->status_fd = pip->ctl_fd;
4301
4302 close (tmpfd); /* All done with main pid */
4303 #endif /* PIOCOPENLWP */
4304
4305 #endif /* HAVE_MULTIPLE_PROC_FDS */
4306
4307 return 1;
4308 }
4309
4310 static char *
4311 mappingflags (flags)
4312 long flags;
4313 {
4314 static char asciiflags[8];
4315
4316 strcpy (asciiflags, "-------");
4317 #if defined (MA_PHYS)
4318 if (flags & MA_PHYS)
4319 asciiflags[0] = 'd';
4320 #endif
4321 if (flags & MA_STACK)
4322 asciiflags[1] = 's';
4323 if (flags & MA_BREAK)
4324 asciiflags[2] = 'b';
4325 if (flags & MA_SHARED)
4326 asciiflags[3] = 's';
4327 if (flags & MA_READ)
4328 asciiflags[4] = 'r';
4329 if (flags & MA_WRITE)
4330 asciiflags[5] = 'w';
4331 if (flags & MA_EXEC)
4332 asciiflags[6] = 'x';
4333 return (asciiflags);
4334 }
4335
4336 static void
4337 info_proc_flags (pip, summary)
4338 struct procinfo *pip;
4339 int summary;
4340 {
4341 struct trans *transp;
4342 #ifdef UNIXWARE
4343 long flags = pip->prstatus.pr_flags | pip->prstatus.pr_lwp.pr_flags;
4344 #else
4345 long flags = pip->prstatus.pr_flags;
4346 #endif
4347
4348 printf_filtered ("%-32s", "Process status flags:");
4349 if (!summary)
4350 {
4351 printf_filtered ("\n\n");
4352 }
4353 for (transp = pr_flag_table; transp->name != NULL; transp++)
4354 {
4355 if (flags & transp->value)
4356 {
4357 if (summary)
4358 {
4359 printf_filtered ("%s ", transp->name);
4360 }
4361 else
4362 {
4363 printf_filtered ("\t%-16s %s.\n", transp->name, transp->desc);
4364 }
4365 }
4366 }
4367 printf_filtered ("\n");
4368 }
4369
4370 static void
4371 info_proc_stop (pip, summary)
4372 struct procinfo *pip;
4373 int summary;
4374 {
4375 struct trans *transp;
4376 int why;
4377 int what;
4378
4379 why = THE_PR_LWP (pip->prstatus).pr_why;
4380 what = THE_PR_LWP (pip->prstatus).pr_what;
4381
4382 if (THE_PR_LWP (pip->prstatus).pr_flags & PR_STOPPED)
4383 {
4384 printf_filtered ("%-32s", "Reason for stopping:");
4385 if (!summary)
4386 {
4387 printf_filtered ("\n\n");
4388 }
4389 for (transp = pr_why_table; transp->name != NULL; transp++)
4390 {
4391 if (why == transp->value)
4392 {
4393 if (summary)
4394 {
4395 printf_filtered ("%s ", transp->name);
4396 }
4397 else
4398 {
4399 printf_filtered ("\t%-16s %s.\n",
4400 transp->name, transp->desc);
4401 }
4402 break;
4403 }
4404 }
4405
4406 /* Use the pr_why field to determine what the pr_what field means, and
4407 print more information. */
4408
4409 switch (why)
4410 {
4411 case PR_REQUESTED:
4412 /* pr_what is unused for this case */
4413 break;
4414 case PR_JOBCONTROL:
4415 case PR_SIGNALLED:
4416 if (summary)
4417 {
4418 printf_filtered ("%s ", signalname (what));
4419 }
4420 else
4421 {
4422 printf_filtered ("\t%-16s %s.\n", signalname (what),
4423 safe_strsignal (what));
4424 }
4425 break;
4426 case PR_SYSENTRY:
4427 if (summary)
4428 {
4429 printf_filtered ("%s ", syscallname (what));
4430 }
4431 else
4432 {
4433 printf_filtered ("\t%-16s %s.\n", syscallname (what),
4434 "Entered this system call");
4435 }
4436 break;
4437 case PR_SYSEXIT:
4438 if (summary)
4439 {
4440 printf_filtered ("%s ", syscallname (what));
4441 }
4442 else
4443 {
4444 printf_filtered ("\t%-16s %s.\n", syscallname (what),
4445 "Returned from this system call");
4446 }
4447 break;
4448 case PR_FAULTED:
4449 if (summary)
4450 {
4451 printf_filtered ("%s ",
4452 lookupname (faults_table, what, "fault"));
4453 }
4454 else
4455 {
4456 printf_filtered ("\t%-16s %s.\n",
4457 lookupname (faults_table, what, "fault"),
4458 lookupdesc (faults_table, what));
4459 }
4460 break;
4461 }
4462 printf_filtered ("\n");
4463 }
4464 }
4465
4466 static void
4467 info_proc_siginfo (pip, summary)
4468 struct procinfo *pip;
4469 int summary;
4470 {
4471 struct siginfo *sip;
4472
4473 if ((THE_PR_LWP (pip->prstatus).pr_flags & PR_STOPPED) &&
4474 (THE_PR_LWP (pip->prstatus).pr_why == PR_SIGNALLED ||
4475 THE_PR_LWP (pip->prstatus).pr_why == PR_FAULTED))
4476 {
4477 printf_filtered ("%-32s", "Additional signal/fault info:");
4478 sip = &(THE_PR_LWP (pip->prstatus).pr_info);
4479 if (summary)
4480 {
4481 printf_filtered ("%s ", signalname (sip->si_signo));
4482 if (sip->si_errno > 0)
4483 {
4484 printf_filtered ("%s ", errnoname (sip->si_errno));
4485 }
4486 if (sip->si_code <= 0)
4487 {
4488 printf_filtered ("sent by %s, uid %d ",
4489 target_pid_to_str (sip->si_pid),
4490 sip->si_uid);
4491 }
4492 else
4493 {
4494 printf_filtered ("%s ", sigcodename (sip));
4495 if ((sip->si_signo == SIGILL) ||
4496 (sip->si_signo == SIGFPE) ||
4497 (sip->si_signo == SIGSEGV) ||
4498 (sip->si_signo == SIGBUS))
4499 {
4500 printf_filtered ("addr=%#lx ",
4501 (unsigned long) sip->si_addr);
4502 }
4503 else if ((sip->si_signo == SIGCHLD))
4504 {
4505 printf_filtered ("child %s, status %u ",
4506 target_pid_to_str (sip->si_pid),
4507 sip->si_status);
4508 }
4509 else if ((sip->si_signo == SIGPOLL))
4510 {
4511 printf_filtered ("band %u ", sip->si_band);
4512 }
4513 }
4514 }
4515 else
4516 {
4517 printf_filtered ("\n\n");
4518 printf_filtered ("\t%-16s %s.\n", signalname (sip->si_signo),
4519 safe_strsignal (sip->si_signo));
4520 if (sip->si_errno > 0)
4521 {
4522 printf_filtered ("\t%-16s %s.\n",
4523 errnoname (sip->si_errno),
4524 safe_strerror (sip->si_errno));
4525 }
4526 if (sip->si_code <= 0)
4527 {
4528 printf_filtered ("\t%-16u %s\n", sip->si_pid, /* XXX need target_pid_to_str() */
4529 "PID of process sending signal");
4530 printf_filtered ("\t%-16u %s\n", sip->si_uid,
4531 "UID of process sending signal");
4532 }
4533 else
4534 {
4535 printf_filtered ("\t%-16s %s.\n", sigcodename (sip),
4536 sigcodedesc (sip));
4537 if ((sip->si_signo == SIGILL) ||
4538 (sip->si_signo == SIGFPE))
4539 {
4540 printf_filtered ("\t%#-16lx %s.\n",
4541 (unsigned long) sip->si_addr,
4542 "Address of faulting instruction");
4543 }
4544 else if ((sip->si_signo == SIGSEGV) ||
4545 (sip->si_signo == SIGBUS))
4546 {
4547 printf_filtered ("\t%#-16lx %s.\n",
4548 (unsigned long) sip->si_addr,
4549 "Address of faulting memory reference");
4550 }
4551 else if ((sip->si_signo == SIGCHLD))
4552 {
4553 printf_filtered ("\t%-16u %s.\n", sip->si_pid, /* XXX need target_pid_to_str() */
4554 "Child process ID");
4555 printf_filtered ("\t%-16u %s.\n", sip->si_status,
4556 "Child process exit value or signal");
4557 }
4558 else if ((sip->si_signo == SIGPOLL))
4559 {
4560 printf_filtered ("\t%-16u %s.\n", sip->si_band,
4561 "Band event for POLL_{IN,OUT,MSG}");
4562 }
4563 }
4564 }
4565 printf_filtered ("\n");
4566 }
4567 }
4568
4569 static void
4570 info_proc_syscalls (pip, summary)
4571 struct procinfo *pip;
4572 int summary;
4573 {
4574 int syscallnum;
4575
4576 if (!summary)
4577 {
4578
4579 #if 0 /* FIXME: Needs to use gdb-wide configured info about system calls. */
4580 if (pip->prstatus.pr_flags & PR_ASLEEP)
4581 {
4582 int syscallnum = pip->prstatus.pr_reg[R_D0];
4583 if (summary)
4584 {
4585 printf_filtered ("%-32s", "Sleeping in system call:");
4586 printf_filtered ("%s", syscallname (syscallnum));
4587 }
4588 else
4589 {
4590 printf_filtered ("Sleeping in system call '%s'.\n",
4591 syscallname (syscallnum));
4592 }
4593 }
4594 #endif
4595
4596 #ifndef UNIXWARE
4597 if (ioctl (pip->ctl_fd, PIOCGENTRY, &pip->entryset) < 0)
4598 {
4599 print_sys_errmsg (pip->pathname, errno);
4600 error ("PIOCGENTRY failed");
4601 }
4602
4603 if (ioctl (pip->ctl_fd, PIOCGEXIT, &pip->exitset) < 0)
4604 {
4605 print_sys_errmsg (pip->pathname, errno);
4606 error ("PIOCGEXIT failed");
4607 }
4608 #endif
4609
4610 printf_filtered ("System call tracing information:\n\n");
4611
4612 printf_filtered ("\t%-12s %-8s %-8s\n",
4613 "System call",
4614 "Entry",
4615 "Exit");
4616 for (syscallnum = 0; syscallnum < MAX_SYSCALLS; syscallnum++)
4617 {
4618 QUIT;
4619 if (syscall_table[syscallnum] != NULL)
4620 printf_filtered ("\t%-12s ", syscall_table[syscallnum]);
4621 else
4622 printf_filtered ("\t%-12d ", syscallnum);
4623
4624 #ifdef UNIXWARE
4625 printf_filtered ("%-8s ",
4626 prismember (&pip->prstatus.pr_sysentry, syscallnum)
4627 ? "on" : "off");
4628 printf_filtered ("%-8s ",
4629 prismember (&pip->prstatus.pr_sysexit, syscallnum)
4630 ? "on" : "off");
4631 #else
4632 printf_filtered ("%-8s ",
4633 prismember (&pip->entryset, syscallnum)
4634 ? "on" : "off");
4635 printf_filtered ("%-8s ",
4636 prismember (&pip->exitset, syscallnum)
4637 ? "on" : "off");
4638 #endif
4639 printf_filtered ("\n");
4640 }
4641 printf_filtered ("\n");
4642 }
4643 }
4644
4645 static char *
4646 signalname (signo)
4647 int signo;
4648 {
4649 const char *name;
4650 static char locbuf[32];
4651
4652 name = strsigno (signo);
4653 if (name == NULL)
4654 {
4655 sprintf (locbuf, "Signal %d", signo);
4656 }
4657 else
4658 {
4659 sprintf (locbuf, "%s (%d)", name, signo);
4660 }
4661 return (locbuf);
4662 }
4663
4664 static char *
4665 errnoname (errnum)
4666 int errnum;
4667 {
4668 const char *name;
4669 static char locbuf[32];
4670
4671 name = strerrno (errnum);
4672 if (name == NULL)
4673 {
4674 sprintf (locbuf, "Errno %d", errnum);
4675 }
4676 else
4677 {
4678 sprintf (locbuf, "%s (%d)", name, errnum);
4679 }
4680 return (locbuf);
4681 }
4682
4683 static void
4684 info_proc_signals (pip, summary)
4685 struct procinfo *pip;
4686 int summary;
4687 {
4688 int signo;
4689
4690 if (!summary)
4691 {
4692 #ifndef PROCFS_USE_READ_WRITE
4693 if (ioctl (pip->ctl_fd, PIOCGTRACE, &pip->trace) < 0)
4694 {
4695 print_sys_errmsg (pip->pathname, errno);
4696 error ("PIOCGTRACE failed");
4697 }
4698 #endif
4699
4700 printf_filtered ("Disposition of signals:\n\n");
4701 printf_filtered ("\t%-15s %-8s %-8s %-8s %s\n\n",
4702 "Signal", "Trace", "Hold", "Pending", "Description");
4703 for (signo = 0; signo < NSIG; signo++)
4704 {
4705 QUIT;
4706 printf_filtered ("\t%-15s ", signalname (signo));
4707 #ifdef UNIXWARE
4708 printf_filtered ("%-8s ",
4709 prismember (&pip->prstatus.pr_sigtrace, signo)
4710 ? "on" : "off");
4711 printf_filtered ("%-8s ",
4712 prismember (&pip->prstatus.pr_lwp.pr_context.uc_sigmask, signo)
4713 ? "on" : "off");
4714 #else
4715 printf_filtered ("%-8s ",
4716 prismember (&pip->trace, signo)
4717 ? "on" : "off");
4718 printf_filtered ("%-8s ",
4719 prismember (&pip->prstatus.pr_sighold, signo)
4720 ? "on" : "off");
4721 #endif
4722
4723 #ifdef UNIXWARE
4724 if (prismember (&pip->prstatus.pr_sigpend, signo) ||
4725 prismember (&pip->prstatus.pr_lwp.pr_lwppend, signo))
4726 printf_filtered ("%-8s ", "yes");
4727 else
4728 printf_filtered ("%-8s ", "no");
4729 #else /* UNIXWARE */
4730 #ifdef PROCFS_SIGPEND_OFFSET
4731 /* Alpha OSF/1 numbers the pending signals from 1. */
4732 printf_filtered ("%-8s ",
4733 (signo ? prismember (&pip->prstatus.pr_sigpend,
4734 signo - 1)
4735 : 0)
4736 ? "yes" : "no");
4737 #else
4738 printf_filtered ("%-8s ",
4739 prismember (&pip->prstatus.pr_sigpend, signo)
4740 ? "yes" : "no");
4741 #endif
4742 #endif /* UNIXWARE */
4743 printf_filtered (" %s\n", safe_strsignal (signo));
4744 }
4745 printf_filtered ("\n");
4746 }
4747 }
4748
4749 static void
4750 info_proc_faults (pip, summary)
4751 struct procinfo *pip;
4752 int summary;
4753 {
4754 struct trans *transp;
4755
4756 if (!summary)
4757 {
4758 #ifndef UNIXWARE
4759 if (ioctl (pip->ctl_fd, PIOCGFAULT, &pip->fltset.fltset) < 0)
4760 {
4761 print_sys_errmsg (pip->pathname, errno);
4762 error ("PIOCGFAULT failed");
4763 }
4764 #endif
4765
4766 printf_filtered ("Current traced hardware fault set:\n\n");
4767 printf_filtered ("\t%-12s %-8s\n", "Fault", "Trace");
4768
4769 for (transp = faults_table; transp->name != NULL; transp++)
4770 {
4771 QUIT;
4772 printf_filtered ("\t%-12s ", transp->name);
4773 #ifdef UNIXWARE
4774 printf_filtered ("%-8s", prismember (&pip->prstatus.pr_flttrace, transp->value)
4775 ? "on" : "off");
4776 #else
4777 printf_filtered ("%-8s", prismember (&pip->fltset.fltset, transp->value)
4778 ? "on" : "off");
4779 #endif
4780 printf_filtered ("\n");
4781 }
4782 printf_filtered ("\n");
4783 }
4784 }
4785
4786 static void
4787 info_proc_mappings (pip, summary)
4788 struct procinfo *pip;
4789 int summary;
4790 {
4791 int nmap;
4792 struct prmap *prmaps;
4793 struct prmap *prmap;
4794 struct stat sbuf;
4795
4796 if (!summary)
4797 {
4798 printf_filtered ("Mapped address spaces:\n\n");
4799 #ifdef BFD_HOST_64_BIT
4800 printf_filtered (" %18s %18s %10s %10s %7s\n",
4801 #else
4802 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
4803 #endif
4804 "Start Addr",
4805 " End Addr",
4806 " Size",
4807 " Offset",
4808 "Flags");
4809 #ifdef PROCFS_USE_READ_WRITE
4810 if (fstat (pip->map_fd, &sbuf) == 0)
4811 {
4812 nmap = sbuf.st_size / sizeof (prmap_t);
4813 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
4814 if ((lseek (pip->map_fd, 0, SEEK_SET) == 0) &&
4815 (read (pip->map_fd, (char *) prmaps,
4816 nmap * sizeof (*prmaps)) == (nmap * sizeof (*prmaps))))
4817 {
4818 int i = 0;
4819 for (prmap = prmaps; i < nmap; ++prmap, ++i)
4820 #else
4821 if (ioctl (pip->ctl_fd, PIOCNMAP, &nmap) == 0)
4822 {
4823 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
4824 if (ioctl (pip->ctl_fd, PIOCMAP, prmaps) == 0)
4825 {
4826 for (prmap = prmaps; prmap->pr_size; ++prmap)
4827 #endif /* PROCFS_USE_READ_WRITE */
4828 {
4829 #ifdef BFD_HOST_64_BIT
4830 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
4831 #else
4832 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
4833 #endif
4834 (unsigned long) prmap->pr_vaddr,
4835 (unsigned long) prmap->pr_vaddr
4836 + prmap->pr_size - 1,
4837 prmap->pr_size,
4838 prmap->pr_off,
4839 mappingflags (prmap->pr_mflags));
4840 }
4841 }
4842 }
4843 printf_filtered ("\n");
4844 }
4845 }
4846
4847 /*
4848
4849 LOCAL FUNCTION
4850
4851 info_proc -- implement the "info proc" command
4852
4853 SYNOPSIS
4854
4855 void info_proc (char *args, int from_tty)
4856
4857 DESCRIPTION
4858
4859 Implement gdb's "info proc" command by using the /proc interface
4860 to print status information about any currently running process.
4861
4862 Examples of the use of "info proc" are:
4863
4864 info proc (prints summary info for current inferior)
4865 info proc 123 (prints summary info for process with pid 123)
4866 info proc mappings (prints address mappings)
4867 info proc times (prints process/children times)
4868 info proc id (prints pid, ppid, gid, sid, etc)
4869 FIXME: i proc id not implemented.
4870 info proc status (prints general process state info)
4871 FIXME: i proc status not implemented.
4872 info proc signals (prints info about signal handling)
4873 info proc all (prints all info)
4874
4875 */
4876
4877 static void
4878 info_proc (args, from_tty)
4879 char *args;
4880 int from_tty;
4881 {
4882 int pid;
4883 struct procinfo *pip;
4884 struct cleanup *old_chain;
4885 char **argv;
4886 int argsize;
4887 int summary = 1;
4888 int flags = 0;
4889 int syscalls = 0;
4890 int signals = 0;
4891 int faults = 0;
4892 int mappings = 0;
4893 int times = 0;
4894 int id = 0;
4895 int status = 0;
4896 int all = 0;
4897 int nlwp;
4898 int *lwps;
4899
4900 old_chain = make_cleanup (null_cleanup, 0);
4901
4902 /* Default to using the current inferior if no pid specified. Note
4903 that inferior_pid may be 0, hence we set okerr. */
4904
4905 pid = inferior_pid & 0x7fffffff; /* strip off sol-thread bit */
4906 if (!(pip = find_procinfo (pid, 1))) /* inferior_pid no good? */
4907 pip = procinfo_list; /* take first available */
4908 pid = pid & 0xffff; /* extract "real" pid */
4909
4910 if (args != NULL)
4911 {
4912 if ((argv = buildargv (args)) == NULL)
4913 {
4914 nomem (0);
4915 }
4916 make_cleanup_freeargv (argv);
4917
4918 while (*argv != NULL)
4919 {
4920 argsize = strlen (*argv);
4921 if (argsize >= 1 && strncmp (*argv, "all", argsize) == 0)
4922 {
4923 summary = 0;
4924 all = 1;
4925 }
4926 else if (argsize >= 2 && strncmp (*argv, "faults", argsize) == 0)
4927 {
4928 summary = 0;
4929 faults = 1;
4930 }
4931 else if (argsize >= 2 && strncmp (*argv, "flags", argsize) == 0)
4932 {
4933 summary = 0;
4934 flags = 1;
4935 }
4936 else if (argsize >= 1 && strncmp (*argv, "id", argsize) == 0)
4937 {
4938 summary = 0;
4939 id = 1;
4940 }
4941 else if (argsize >= 1 && strncmp (*argv, "mappings", argsize) == 0)
4942 {
4943 summary = 0;
4944 mappings = 1;
4945 }
4946 else if (argsize >= 2 && strncmp (*argv, "signals", argsize) == 0)
4947 {
4948 summary = 0;
4949 signals = 1;
4950 }
4951 else if (argsize >= 2 && strncmp (*argv, "status", argsize) == 0)
4952 {
4953 summary = 0;
4954 status = 1;
4955 }
4956 else if (argsize >= 2 && strncmp (*argv, "syscalls", argsize) == 0)
4957 {
4958 summary = 0;
4959 syscalls = 1;
4960 }
4961 else if (argsize >= 1 && strncmp (*argv, "times", argsize) == 0)
4962 {
4963 summary = 0;
4964 times = 1;
4965 }
4966 else if ((pid = atoi (*argv)) > 0)
4967 {
4968 pip = (struct procinfo *) xmalloc (sizeof (struct procinfo));
4969 memset (pip, 0, sizeof (*pip));
4970
4971 pip->pid = pid;
4972 if (!open_proc_file (pid, pip, O_RDONLY, 0))
4973 {
4974 perror_with_name (pip->pathname);
4975 /* NOTREACHED */
4976 }
4977 pid = pip->pid;
4978 make_cleanup_close_proc_file (pip);
4979 }
4980 else if (**argv != '\000')
4981 {
4982 error ("Unrecognized or ambiguous keyword `%s'.", *argv);
4983 }
4984 argv++;
4985 }
4986 }
4987
4988 /* If we don't have a valid open process at this point, then we have no
4989 inferior or didn't specify a specific pid. */
4990
4991 if (!pip)
4992 {
4993 error ("\
4994 No process. Start debugging a program or specify an explicit process ID.");
4995 }
4996
4997 if (!procfs_read_status (pip))
4998 {
4999 print_sys_errmsg (pip->pathname, errno);
5000 error ("procfs_read_status failed");
5001 }
5002
5003 #ifndef PROCFS_USE_READ_WRITE
5004 #ifdef PIOCLWPIDS
5005 nlwp = pip->prstatus.pr_nlwp;
5006 lwps = alloca ((2 * nlwp + 2) * sizeof (*lwps));
5007
5008 if (ioctl (pip->ctl_fd, PIOCLWPIDS, lwps))
5009 {
5010 print_sys_errmsg (pip->pathname, errno);
5011 error ("PIOCLWPIDS failed");
5012 }
5013 #else /* PIOCLWPIDS */
5014 nlwp = 1;
5015 lwps = alloca ((2 * nlwp + 2) * sizeof *lwps);
5016 lwps[0] = 0;
5017 #endif /* PIOCLWPIDS */
5018
5019 for (; nlwp > 0; nlwp--, lwps++)
5020 {
5021 pip = find_procinfo ((*lwps << 16) | pid, 1);
5022
5023 if (!pip)
5024 {
5025 pip = (struct procinfo *) xmalloc (sizeof (struct procinfo));
5026 memset (pip, 0, sizeof (*pip));
5027 if (!open_proc_file ((*lwps << 16) | pid, pip, O_RDONLY, 0))
5028 continue;
5029
5030 make_cleanup_close_proc_file (pip);
5031
5032 if (!procfs_read_status (pip))
5033 {
5034 print_sys_errmsg (pip->pathname, errno);
5035 error ("procfs_read_status failed");
5036 }
5037 }
5038
5039 #endif /* PROCFS_USE_READ_WRITE */
5040
5041 /* Print verbose information of the requested type(s), or just a summary
5042 of the information for all types. */
5043
5044 printf_filtered ("\nInformation for %s.%d:\n\n", pip->pathname, *lwps);
5045 if (summary || all || flags)
5046 {
5047 info_proc_flags (pip, summary);
5048 }
5049 if (summary || all)
5050 {
5051 info_proc_stop (pip, summary);
5052 #ifdef UNIXWARE
5053 supply_gregset (&pip->prstatus.pr_lwp.pr_context.uc_mcontext.gregs);
5054 #else
5055 supply_gregset (&pip->prstatus.pr_reg);
5056 #endif
5057 printf_filtered ("PC: ");
5058 print_address (read_pc (), gdb_stdout);
5059 printf_filtered ("\n");
5060 }
5061 if (summary || all || signals || faults)
5062 {
5063 info_proc_siginfo (pip, summary);
5064 }
5065 if (summary || all || syscalls)
5066 {
5067 info_proc_syscalls (pip, summary);
5068 }
5069 if (summary || all || mappings)
5070 {
5071 info_proc_mappings (pip, summary);
5072 }
5073 if (summary || all || signals)
5074 {
5075 info_proc_signals (pip, summary);
5076 }
5077 if (summary || all || faults)
5078 {
5079 info_proc_faults (pip, summary);
5080 }
5081 printf_filtered ("\n");
5082
5083 /* All done, deal with closing any temporary process info structure,
5084 freeing temporary memory , etc. */
5085
5086 do_cleanups (old_chain);
5087 #ifndef PROCFS_USE_READ_WRITE
5088 }
5089 #endif
5090 }
5091
5092 /*
5093
5094 LOCAL FUNCTION
5095
5096 modify_inherit_on_fork_flag - Change the inherit-on-fork flag
5097
5098 SYNOPSIS
5099
5100 void modify_inherit_on_fork_flag (fd, flag)
5101
5102 DESCRIPTION
5103
5104 Call this routine to modify the inherit-on-fork flag. This routine is
5105 just a nice wrapper to hide the #ifdefs needed by various systems to
5106 control this flag.
5107
5108 */
5109
5110 static void
5111 modify_inherit_on_fork_flag (fd, flag)
5112 int fd;
5113 int flag;
5114 {
5115 #if defined (PIOCSET) || defined (PCSET)
5116 long pr_flags;
5117 #endif
5118 int retval = 0;
5119 struct proc_ctl pctl;
5120
5121 #if defined (PIOCSET) || defined (PCSET) /* New method */
5122 pr_flags = PR_FORK;
5123 if (flag)
5124 {
5125 #ifdef PROCFS_USE_READ_WRITE
5126 pctl.cmd = PCSET;
5127 pctl.data = PR_FORK;
5128 if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
5129 retval = -1;
5130 #else
5131 retval = ioctl (fd, PIOCSET, &pr_flags);
5132 #endif
5133 }
5134 else
5135 {
5136 #ifdef PROCFS_USE_READ_WRITE
5137 pctl.cmd = PCRESET;
5138 pctl.data = PR_FORK;
5139 if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
5140 retval = -1;
5141 #else
5142 retval = ioctl (fd, PIOCRESET, &pr_flags);
5143 #endif
5144 }
5145
5146 #else
5147 #ifdef PIOCSFORK /* Original method */
5148 if (flag)
5149 {
5150 retval = ioctl (fd, PIOCSFORK, NULL);
5151 }
5152 else
5153 {
5154 retval = ioctl (fd, PIOCRFORK, NULL);
5155 }
5156 #else
5157 Neither PR_FORK nor PIOCSFORK exist ! !!
5158 #endif
5159 #endif
5160
5161 if (!retval)
5162 return;
5163
5164 print_sys_errmsg ("modify_inherit_on_fork_flag", errno);
5165 error ("PIOCSFORK or PR_FORK modification failed");
5166 }
5167
5168 /*
5169
5170 LOCAL FUNCTION
5171
5172 modify_run_on_last_close_flag - Change the run-on-last-close flag
5173
5174 SYNOPSIS
5175
5176 void modify_run_on_last_close_flag (fd, flag)
5177
5178 DESCRIPTION
5179
5180 Call this routine to modify the run-on-last-close flag. This routine
5181 is just a nice wrapper to hide the #ifdefs needed by various systems to
5182 control this flag.
5183
5184 */
5185
5186 static void
5187 modify_run_on_last_close_flag (fd, flag)
5188 int fd;
5189 int flag;
5190 {
5191 #if defined (PIOCSET) || defined (PCSET)
5192 long pr_flags;
5193 #endif
5194 int retval = 0;
5195 struct proc_ctl pctl;
5196
5197 #if defined (PIOCSET) || defined (PCSET) /* New method */
5198 pr_flags = PR_RLC;
5199 if (flag)
5200 {
5201 #ifdef PROCFS_USE_READ_WRITE
5202 pctl.cmd = PCSET;
5203 pctl.data = PR_RLC;
5204 if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
5205 retval = -1;
5206 #else
5207 retval = ioctl (fd, PIOCSET, &pr_flags);
5208 #endif
5209 }
5210 else
5211 {
5212 #ifdef PROCFS_USE_READ_WRITE
5213 pctl.cmd = PCRESET;
5214 pctl.data = PR_RLC;
5215 if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
5216 retval = -1;
5217 #else
5218 retval = ioctl (fd, PIOCRESET, &pr_flags);
5219 #endif
5220 }
5221
5222 #else
5223 #ifdef PIOCSRLC /* Original method */
5224 if (flag)
5225 retval = ioctl (fd, PIOCSRLC, NULL);
5226 else
5227 retval = ioctl (fd, PIOCRRLC, NULL);
5228 #else
5229 Neither PR_RLC nor PIOCSRLC exist ! !!
5230 #endif
5231 #endif
5232
5233 if (!retval)
5234 return;
5235
5236 print_sys_errmsg ("modify_run_on_last_close_flag", errno);
5237 error ("PIOCSRLC or PR_RLC modification failed");
5238 }
5239
5240 /*
5241
5242 LOCAL FUNCTION
5243
5244 procfs_clear_syscall_trap -- Deletes the trap for the specified system call.
5245
5246 SYNOPSIS
5247
5248 void procfs_clear_syscall_trap (struct procinfo *, int syscall_num, int errok)
5249
5250 DESCRIPTION
5251
5252 This function function disables traps for the specified system call.
5253 errok is non-zero if errors should be ignored.
5254 */
5255
5256 static void
5257 procfs_clear_syscall_trap (pi, syscall_num, errok)
5258 struct procinfo *pi;
5259 int syscall_num;
5260 int errok;
5261 {
5262 sysset_t sysset;
5263 int goterr, i;
5264
5265 #ifndef UNIXWARE
5266 goterr = ioctl (pi->ctl_fd, PIOCGENTRY, &sysset) < 0;
5267
5268 if (goterr && !errok)
5269 {
5270 print_sys_errmsg (pi->pathname, errno);
5271 error ("PIOCGENTRY failed");
5272 }
5273
5274 if (!goterr)
5275 {
5276 prdelset (&sysset, syscall_num);
5277
5278 if ((ioctl (pi->ctl_fd, PIOCSENTRY, &sysset) < 0) && !errok)
5279 {
5280 print_sys_errmsg (pi->pathname, errno);
5281 error ("PIOCSENTRY failed");
5282 }
5283 }
5284
5285 goterr = ioctl (pi->ctl_fd, PIOCGEXIT, &sysset) < 0;
5286
5287 if (goterr && !errok)
5288 {
5289 procfs_clear_syscall_trap (pi, syscall_num, 1);
5290 print_sys_errmsg (pi->pathname, errno);
5291 error ("PIOCGEXIT failed");
5292 }
5293
5294 if (!goterr)
5295 {
5296 praddset (&sysset, syscall_num);
5297
5298 if ((ioctl (pi->ctl_fd, PIOCSEXIT, &sysset) < 0) && !errok)
5299 {
5300 procfs_clear_syscall_trap (pi, syscall_num, 1);
5301 print_sys_errmsg (pi->pathname, errno);
5302 error ("PIOCSEXIT failed");
5303 }
5304 }
5305 #endif
5306
5307 if (!pi->syscall_handlers)
5308 {
5309 if (!errok)
5310 error ("procfs_clear_syscall_trap: syscall_handlers is empty");
5311 return;
5312 }
5313
5314 /* Remove handler func from the handler list */
5315
5316 for (i = 0; i < pi->num_syscall_handlers; i++)
5317 if (pi->syscall_handlers[i].syscall_num == syscall_num)
5318 {
5319 if (i + 1 != pi->num_syscall_handlers)
5320 { /* Not the last entry.
5321 Move subsequent entries fwd. */
5322 memcpy (&pi->syscall_handlers[i], &pi->syscall_handlers[i + 1],
5323 (pi->num_syscall_handlers - i - 1)
5324 * sizeof (struct procfs_syscall_handler));
5325 }
5326
5327 pi->syscall_handlers = xrealloc (pi->syscall_handlers,
5328 (pi->num_syscall_handlers - 1)
5329 * sizeof (struct procfs_syscall_handler));
5330 pi->num_syscall_handlers--;
5331 return;
5332 }
5333
5334 if (!errok)
5335 error ("procfs_clear_syscall_trap: Couldn't find handler for sys call %d",
5336 syscall_num);
5337 }
5338
5339 /*
5340
5341 LOCAL FUNCTION
5342
5343 procfs_set_syscall_trap -- arrange for a function to be called when the
5344 child executes the specified system call.
5345
5346 SYNOPSIS
5347
5348 void procfs_set_syscall_trap (struct procinfo *, int syscall_num, int flags,
5349 syscall_func_t *function)
5350
5351 DESCRIPTION
5352
5353 This function sets up an entry and/or exit trap for the specified system
5354 call. When the child executes the specified system call, your function
5355 will be called with the call #, a flag that indicates entry or exit, and
5356 pointers to rtnval and statval (which are used by procfs_wait). The
5357 function should return non-zero if something interesting happened, zero
5358 otherwise.
5359 */
5360
5361 static void
5362 procfs_set_syscall_trap (pi, syscall_num, flags, func)
5363 struct procinfo *pi;
5364 int syscall_num;
5365 int flags;
5366 syscall_func_t *func;
5367 {
5368 sysset_t sysset;
5369
5370 #ifndef UNIXWARE
5371 if (flags & PROCFS_SYSCALL_ENTRY)
5372 {
5373 if (ioctl (pi->ctl_fd, PIOCGENTRY, &sysset) < 0)
5374 {
5375 print_sys_errmsg (pi->pathname, errno);
5376 error ("PIOCGENTRY failed");
5377 }
5378
5379 praddset (&sysset, syscall_num);
5380
5381 if (ioctl (pi->ctl_fd, PIOCSENTRY, &sysset) < 0)
5382 {
5383 print_sys_errmsg (pi->pathname, errno);
5384 error ("PIOCSENTRY failed");
5385 }
5386 }
5387
5388 if (flags & PROCFS_SYSCALL_EXIT)
5389 {
5390 if (ioctl (pi->ctl_fd, PIOCGEXIT, &sysset) < 0)
5391 {
5392 procfs_clear_syscall_trap (pi, syscall_num, 1);
5393 print_sys_errmsg (pi->pathname, errno);
5394 error ("PIOCGEXIT failed");
5395 }
5396
5397 praddset (&sysset, syscall_num);
5398
5399 if (ioctl (pi->ctl_fd, PIOCSEXIT, &sysset) < 0)
5400 {
5401 procfs_clear_syscall_trap (pi, syscall_num, 1);
5402 print_sys_errmsg (pi->pathname, errno);
5403 error ("PIOCSEXIT failed");
5404 }
5405 }
5406 #endif
5407
5408 if (!pi->syscall_handlers)
5409 {
5410 pi->syscall_handlers = xmalloc (sizeof (struct procfs_syscall_handler));
5411 pi->syscall_handlers[0].syscall_num = syscall_num;
5412 pi->syscall_handlers[0].func = func;
5413 pi->num_syscall_handlers = 1;
5414 }
5415 else
5416 {
5417 int i;
5418
5419 for (i = 0; i < pi->num_syscall_handlers; i++)
5420 if (pi->syscall_handlers[i].syscall_num == syscall_num)
5421 {
5422 pi->syscall_handlers[i].func = func;
5423 return;
5424 }
5425
5426 pi->syscall_handlers = xrealloc (pi->syscall_handlers, (i + 1)
5427 * sizeof (struct procfs_syscall_handler));
5428 pi->syscall_handlers[i].syscall_num = syscall_num;
5429 pi->syscall_handlers[i].func = func;
5430 pi->num_syscall_handlers++;
5431 }
5432 }
5433
5434 #ifdef SYS_lwp_create
5435
5436 /*
5437
5438 LOCAL FUNCTION
5439
5440 procfs_lwp_creation_handler - handle exit from the _lwp_create syscall
5441
5442 SYNOPSIS
5443
5444 int procfs_lwp_creation_handler (pi, syscall_num, why, rtnvalp, statvalp)
5445
5446 DESCRIPTION
5447
5448 This routine is called both when an inferior process and it's new lwp
5449 are about to finish a _lwp_create() system call. This is the system
5450 call that Solaris uses to create a lightweight process. When the
5451 target process gets this event, we can look at sysarg[2] to find the
5452 new childs lwp ID, and create a procinfo struct from that. After that,
5453 we pretend that we got a SIGTRAP, and return non-zero to tell
5454 procfs_wait to wake up. Subsequently, wait_for_inferior gets woken up,
5455 sees the new process and continues it.
5456
5457 When we see the child exiting from lwp_create, we just contine it,
5458 since everything was handled when the parent trapped.
5459
5460 NOTES
5461 In effect, we are only paying attention to the parent's completion of
5462 the lwp_create syscall. If we only paid attention to the child
5463 instead, then we wouldn't detect the creation of a suspended thread.
5464 */
5465
5466 static int
5467 procfs_lwp_creation_handler (pi, syscall_num, why, rtnvalp, statvalp)
5468 struct procinfo *pi;
5469 int syscall_num;
5470 int why;
5471 int *rtnvalp;
5472 int *statvalp;
5473 {
5474 int lwp_id;
5475 struct procinfo *childpi;
5476 struct proc_ctl pctl;
5477
5478 /* We've just detected the completion of an lwp_create system call. Now we
5479 need to setup a procinfo struct for this thread, and notify the thread
5480 system of the new arrival. */
5481
5482 /* If lwp_create failed, then nothing interesting happened. Continue the
5483 process and go back to sleep. */
5484
5485 #ifdef UNIXWARE
5486 /* Joel ... can you check this logic out please? JKJ */
5487 if (pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs[R_EFL] & 1)
5488 { /* _lwp_create failed */
5489 pctl.cmd = PCRUN;
5490 pctl.data = PRCFAULT;
5491
5492 if (write (pi->ctl_fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
5493 perror_with_name (pi->pathname);
5494
5495 return 0;
5496 }
5497 #else /* UNIXWARE */
5498 if (PROCFS_GET_CARRY (pi->prstatus.pr_reg))
5499 { /* _lwp_create failed */
5500 pi->prrun.pr_flags &= PRSTEP;
5501 pi->prrun.pr_flags |= PRCFAULT;
5502
5503 if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
5504 perror_with_name (pi->pathname);
5505
5506 return 0;
5507 }
5508 #endif
5509
5510 /* At this point, the new thread is stopped at it's first instruction, and
5511 the parent is stopped at the exit from lwp_create. */
5512
5513 if (pi->new_child) /* Child? */
5514 { /* Yes, just continue it */
5515 #ifdef UNIXWARE
5516 pctl.cmd = PCRUN;
5517 pctl.data = PRCFAULT;
5518
5519 if (write (pi->ctl_fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
5520 #else /* !UNIXWARE */
5521 pi->prrun.pr_flags &= PRSTEP;
5522 pi->prrun.pr_flags |= PRCFAULT;
5523
5524 if ((pi->prstatus.pr_flags & PR_ISTOP)
5525 && ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
5526 #endif /* !UNIXWARE */
5527 perror_with_name (pi->pathname);
5528
5529 pi->new_child = 0; /* No longer new */
5530
5531 return 0;
5532 }
5533
5534 /* We're the proud parent of a new thread. Setup an exit trap for lwp_create
5535 in the child and continue the parent. */
5536
5537 /* Third arg is pointer to new thread id. */
5538 lwp_id = read_memory_integer (
5539 THE_PR_LWP (pi->prstatus).pr_sysarg[2], sizeof (int));
5540
5541 lwp_id = (lwp_id << 16) | PIDGET (pi->pid);
5542
5543 childpi = create_procinfo (lwp_id);
5544
5545 /* The new process has actually inherited the lwp_create syscall trap from
5546 it's parent, but we still have to call this to register handlers for
5547 that child. */
5548
5549 procfs_set_inferior_syscall_traps (childpi);
5550 add_thread (lwp_id);
5551 printf_filtered ("[New %s]\n", target_pid_to_str (lwp_id));
5552
5553 /* Continue the parent */
5554 #ifdef UNIXWARE
5555 pctl.cmd = PCRUN;
5556 pctl.data = PRCFAULT;
5557
5558 if (write (pi->ctl_fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
5559 #else
5560 pi->prrun.pr_flags &= PRSTEP;
5561 pi->prrun.pr_flags |= PRCFAULT;
5562 if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
5563 #endif
5564 perror_with_name (pi->pathname);
5565
5566 /* The new child may have been created in one of two states:
5567 SUSPENDED or RUNNABLE. If runnable, we will simply signal it to run.
5568 If suspended, we flag it to be continued later, when it has an event. */
5569
5570 if (THE_PR_LWP (childpi->prstatus).pr_why == PR_SUSPENDED)
5571 childpi->new_child = 1; /* Flag this as an unseen child process */
5572 else
5573 {
5574 /* Continue the child */
5575 #ifdef UNIXWARE
5576 pctl.cmd = PCRUN;
5577 pctl.data = PRCFAULT;
5578
5579 if (write (pi->ctl_fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
5580 #else
5581 childpi->prrun.pr_flags &= PRSTEP;
5582 childpi->prrun.pr_flags |= PRCFAULT;
5583
5584 if (ioctl (childpi->ctl_fd, PIOCRUN, &childpi->prrun) != 0)
5585 #endif
5586 perror_with_name (childpi->pathname);
5587 }
5588 return 0;
5589 }
5590 #endif /* SYS_lwp_create */
5591
5592 /* Fork an inferior process, and start debugging it with /proc. */
5593
5594 static void
5595 procfs_create_inferior (exec_file, allargs, env)
5596 char *exec_file;
5597 char *allargs;
5598 char **env;
5599 {
5600 char *shell_file = getenv ("SHELL");
5601 char *tryname;
5602 if (shell_file != NULL && strchr (shell_file, '/') == NULL)
5603 {
5604
5605 /* We will be looking down the PATH to find shell_file. If we
5606 just do this the normal way (via execlp, which operates by
5607 attempting an exec for each element of the PATH until it
5608 finds one which succeeds), then there will be an exec for
5609 each failed attempt, each of which will cause a PR_SYSEXIT
5610 stop, and we won't know how to distinguish the PR_SYSEXIT's
5611 for these failed execs with the ones for successful execs
5612 (whether the exec has succeeded is stored at that time in the
5613 carry bit or some such architecture-specific and
5614 non-ABI-specified place).
5615
5616 So I can't think of anything better than to search the PATH
5617 now. This has several disadvantages: (1) There is a race
5618 condition; if we find a file now and it is deleted before we
5619 exec it, we lose, even if the deletion leaves a valid file
5620 further down in the PATH, (2) there is no way to know exactly
5621 what an executable (in the sense of "capable of being
5622 exec'd") file is. Using access() loses because it may lose
5623 if the caller is the superuser; failing to use it loses if
5624 there are ACLs or some such. */
5625
5626 char *p;
5627 char *p1;
5628 /* FIXME-maybe: might want "set path" command so user can change what
5629 path is used from within GDB. */
5630 char *path = getenv ("PATH");
5631 int len;
5632 struct stat statbuf;
5633
5634 if (path == NULL)
5635 path = "/bin:/usr/bin";
5636
5637 tryname = alloca (strlen (path) + strlen (shell_file) + 2);
5638 for (p = path; p != NULL; p = p1 ? p1 + 1 : NULL)
5639 {
5640 p1 = strchr (p, ':');
5641 if (p1 != NULL)
5642 len = p1 - p;
5643 else
5644 len = strlen (p);
5645 strncpy (tryname, p, len);
5646 tryname[len] = '\0';
5647 strcat (tryname, "/");
5648 strcat (tryname, shell_file);
5649 if (access (tryname, X_OK) < 0)
5650 continue;
5651 if (stat (tryname, &statbuf) < 0)
5652 continue;
5653 if (!S_ISREG (statbuf.st_mode))
5654 /* We certainly need to reject directories. I'm not quite
5655 as sure about FIFOs, sockets, etc., but I kind of doubt
5656 that people want to exec() these things. */
5657 continue;
5658 break;
5659 }
5660 if (p == NULL)
5661 /* Not found. This must be an error rather than merely passing
5662 the file to execlp(), because execlp() would try all the
5663 exec()s, causing GDB to get confused. */
5664 error ("Can't find shell %s in PATH", shell_file);
5665
5666 shell_file = tryname;
5667 }
5668
5669 fork_inferior (exec_file, allargs, env,
5670 proc_set_exec_trap, procfs_init_inferior, NULL, shell_file);
5671
5672 /* We are at the first instruction we care about. */
5673 /* Pedal to the metal... */
5674
5675 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
5676 }
5677
5678 /* Clean up after the inferior dies. */
5679
5680 static void
5681 procfs_mourn_inferior ()
5682 {
5683 struct procinfo *pi;
5684 struct procinfo *next_pi;
5685
5686 for (pi = procinfo_list; pi; pi = next_pi)
5687 {
5688 next_pi = pi->next;
5689 unconditionally_kill_inferior (pi);
5690 }
5691
5692 unpush_target (&procfs_ops);
5693 generic_mourn_inferior ();
5694 }
5695
5696
5697 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
5698 static int
5699 procfs_can_run ()
5700 {
5701 /* This variable is controlled by modules that sit atop procfs that may layer
5702 their own process structure atop that provided here. sol-thread.c does
5703 this because of the Solaris two-level thread model. */
5704
5705 return !procfs_suppress_run;
5706 }
5707 #ifdef TARGET_HAS_HARDWARE_WATCHPOINTS
5708 #ifndef UNIXWARE
5709 \f
5710 /* Insert a watchpoint */
5711 int
5712 procfs_set_watchpoint (pid, addr, len, rw)
5713 int pid;
5714 CORE_ADDR addr;
5715 int len;
5716 int rw;
5717 {
5718 struct procinfo *pi;
5719 prwatch_t wpt;
5720
5721 pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
5722 wpt.pr_vaddr = (caddr_t) addr;
5723 wpt.pr_size = len;
5724 wpt.pr_wflags = ((rw & 1) ? MA_READ : 0) | ((rw & 2) ? MA_WRITE : 0);
5725 if (ioctl (pi->ctl_fd, PIOCSWATCH, &wpt) < 0)
5726 {
5727 if (errno == E2BIG)
5728 return -1;
5729 /* Currently it sometimes happens that the same watchpoint gets
5730 deleted twice - don't die in this case (FIXME please) */
5731 if (errno == ESRCH && len == 0)
5732 return 0;
5733 print_sys_errmsg (pi->pathname, errno);
5734 error ("PIOCSWATCH failed");
5735 }
5736 return 0;
5737 }
5738
5739 int
5740 procfs_stopped_by_watchpoint (pid)
5741 int pid;
5742 {
5743 struct procinfo *pi;
5744 short what;
5745 short why;
5746
5747 pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
5748 if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
5749 {
5750 why = pi->prstatus.pr_why;
5751 what = pi->prstatus.pr_what;
5752 if (why == PR_FAULTED
5753 #if defined (FLTWATCH) && defined (FLTKWATCH)
5754 && (what == FLTWATCH || what == FLTKWATCH)
5755 #else
5756 #ifdef FLTWATCH
5757 && (what == FLTWATCH)
5758 #endif
5759 #ifdef FLTKWATCH
5760 && (what == FLTKWATCH)
5761 #endif
5762 #endif
5763 )
5764 return what;
5765 }
5766 return 0;
5767 }
5768 #endif /* !UNIXWARE */
5769 #endif /* TARGET_HAS_HARDWARE_WATCHPOINTS */
5770
5771 /* Why is this necessary? Shouldn't dead threads just be removed from the
5772 thread database? */
5773
5774 static int
5775 procfs_thread_alive (pid)
5776 int pid;
5777 {
5778 struct procinfo *pi, *next_pi;
5779
5780 for (pi = procinfo_list; pi; pi = next_pi)
5781 {
5782 next_pi = pi->next;
5783 if (pi->pid == pid)
5784 if (procfs_read_status (pi)) /* alive */
5785 return 1;
5786 else
5787 /* defunct (exited) */
5788 {
5789 close_proc_file (pi);
5790 return 0;
5791 }
5792 }
5793 return 0;
5794 }
5795
5796 int
5797 procfs_first_available ()
5798 {
5799 struct procinfo *pi;
5800
5801 for (pi = procinfo_list; pi; pi = pi->next)
5802 {
5803 if (procfs_read_status (pi))
5804 return pi->pid;
5805 }
5806 return -1;
5807 }
5808
5809 int
5810 procfs_get_pid_fd (pid)
5811 int pid;
5812 {
5813 struct procinfo *pi = find_procinfo (pid, 1);
5814
5815 if (pi == NULL)
5816 return -1;
5817
5818 return pi->ctl_fd;
5819 }
5820
5821 /* Send a SIGINT to the process group. This acts just like the user typed a
5822 ^C on the controlling terminal.
5823
5824 XXX - This may not be correct for all systems. Some may want to use
5825 killpg() instead of kill (-pgrp). */
5826
5827 static void
5828 procfs_stop ()
5829 {
5830 extern pid_t inferior_process_group;
5831
5832 kill (-inferior_process_group, SIGINT);
5833 }
5834 \f
5835 /* Convert a pid to printable form. */
5836
5837 #ifdef TIDGET
5838 char *
5839 procfs_pid_to_str (pid)
5840 int pid;
5841 {
5842 static char buf[100];
5843
5844 sprintf (buf, "Kernel thread %d", TIDGET (pid));
5845
5846 return buf;
5847 }
5848 #endif /* TIDGET */
5849 \f
5850
5851 static void
5852 init_procfs_ops ()
5853 {
5854 procfs_ops.to_shortname = "procfs";
5855 procfs_ops.to_longname = "Unix /proc child process";
5856 procfs_ops.to_doc = "Unix /proc child process (started by the \"run\" command).";
5857 procfs_ops.to_open = procfs_open;
5858 procfs_ops.to_attach = procfs_attach;
5859 procfs_ops.to_detach = procfs_detach;
5860 procfs_ops.to_resume = procfs_resume;
5861 procfs_ops.to_wait = procfs_wait;
5862 procfs_ops.to_fetch_registers = procfs_fetch_registers;
5863 procfs_ops.to_store_registers = procfs_store_registers;
5864 procfs_ops.to_prepare_to_store = procfs_prepare_to_store;
5865 procfs_ops.to_xfer_memory = procfs_xfer_memory;
5866 procfs_ops.to_files_info = procfs_files_info;
5867 procfs_ops.to_insert_breakpoint = memory_insert_breakpoint;
5868 procfs_ops.to_remove_breakpoint = memory_remove_breakpoint;
5869 procfs_ops.to_terminal_init = terminal_init_inferior;
5870 procfs_ops.to_terminal_inferior = terminal_inferior;
5871 procfs_ops.to_terminal_ours_for_output = terminal_ours_for_output;
5872 procfs_ops.to_terminal_ours = terminal_ours;
5873 procfs_ops.to_terminal_info = child_terminal_info;
5874 procfs_ops.to_kill = procfs_kill_inferior;
5875 procfs_ops.to_create_inferior = procfs_create_inferior;
5876 procfs_ops.to_mourn_inferior = procfs_mourn_inferior;
5877 procfs_ops.to_can_run = procfs_can_run;
5878 procfs_ops.to_notice_signals = procfs_notice_signals;
5879 procfs_ops.to_thread_alive = procfs_thread_alive;
5880 procfs_ops.to_stop = procfs_stop;
5881 procfs_ops.to_stratum = process_stratum;
5882 procfs_ops.to_has_all_memory = 1;
5883 procfs_ops.to_has_memory = 1;
5884 procfs_ops.to_has_stack = 1;
5885 procfs_ops.to_has_registers = 1;
5886 procfs_ops.to_has_execution = 1;
5887 procfs_ops.to_magic = OPS_MAGIC;
5888 }
5889
5890 void
5891 _initialize_procfs ()
5892 {
5893 #ifdef HAVE_OPTIONAL_PROC_FS
5894 char procname[MAX_PROC_NAME_SIZE];
5895 int fd;
5896
5897 /* If we have an optional /proc filesystem (e.g. under OSF/1),
5898 don't add procfs support if we cannot access the running
5899 GDB via /proc. */
5900 sprintf (procname, STATUS_PROC_NAME_FMT, getpid ());
5901 if ((fd = open (procname, O_RDONLY)) < 0)
5902 return;
5903 close (fd);
5904 #endif
5905
5906 init_procfs_ops ();
5907 add_target (&procfs_ops);
5908
5909 add_info ("processes", info_proc,
5910 "Show process status information using /proc entry.\n\
5911 Specify process id or use current inferior by default.\n\
5912 Specify keywords for detailed information; default is summary.\n\
5913 Keywords are: `all', `faults', `flags', `id', `mappings', `signals',\n\
5914 `status', `syscalls', and `times'.\n\
5915 Unambiguous abbreviations may be used.");
5916
5917 init_syscall_table ();
5918 }
GDB Binutils - Deliverables
This page took 0.232296 seconds and 4 git commands to generate.