projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update FSF address.
[deliverable/binutils-gdb.git] / gdb / procfs.c
1 /* Machine independent support for SVR4 /proc (process file system) for GDB.
2 Copyright 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
3 Written by Fred Fish at Cygnus Support.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21
22 /* N O T E S
23
24 For information on the details of using /proc consult section proc(4)
25 in the UNIX System V Release 4 System Administrator's Reference Manual.
26
27 The general register and floating point register sets are manipulated by
28 separate ioctl's. This file makes the assumption that if FP0_REGNUM is
29 defined, then support for the floating point register set is desired,
30 regardless of whether or not the actual target has floating point hardware.
31
32 */
33
34
35 #include "defs.h"
36
37 #include <sys/types.h>
38 #include <time.h>
39 #include <sys/fault.h>
40 #include <sys/syscall.h>
41 #include <sys/procfs.h>
42 #include <fcntl.h>
43 #include <errno.h>
44 #include "gdb_string.h"
45 #include <stropts.h>
46 #include <poll.h>
47 #include <unistd.h>
48 #include "gdb_stat.h"
49
50 #include "inferior.h"
51 #include "target.h"
52 #include "command.h"
53 #include "gdbcore.h"
54 #include "thread.h"
55
56 #define MAX_SYSCALLS 256 /* Maximum number of syscalls for table */
57
58 #ifndef PROC_NAME_FMT
59 #define PROC_NAME_FMT "/proc/%05d"
60 #endif
61
62 extern struct target_ops procfs_ops; /* Forward declaration */
63
64 #if 1 /* FIXME: Gross and ugly hack to resolve coredep.c global */
65 CORE_ADDR kernel_u_addr;
66 #endif
67
68 #ifdef BROKEN_SIGINFO_H /* Workaround broken SGS <sys/siginfo.h> */
69 #undef si_pid
70 #define si_pid _data._proc.pid
71 #undef si_uid
72 #define si_uid _data._proc._pdata._kill.uid
73 #endif /* BROKEN_SIGINFO_H */
74
75 /* All access to the inferior, either one started by gdb or one that has
76 been attached to, is controlled by an instance of a procinfo structure,
77 defined below. Since gdb currently only handles one inferior at a time,
78 the procinfo structure for the inferior is statically allocated and
79 only one exists at any given time. There is a separate procinfo
80 structure for use by the "info proc" command, so that we can print
81 useful information about any random process without interfering with
82 the inferior's procinfo information. */
83
84 struct procinfo {
85 struct procinfo *next;
86 int pid; /* Process ID of inferior */
87 int fd; /* File descriptor for /proc entry */
88 char *pathname; /* Pathname to /proc entry */
89 int had_event; /* poll/select says something happened */
90 int was_stopped; /* Nonzero if was stopped prior to attach */
91 int nopass_next_sigstop; /* Don't pass a sigstop on next resume */
92 prrun_t prrun; /* Control state when it is run */
93 prstatus_t prstatus; /* Current process status info */
94 gregset_t gregset; /* General register set */
95 fpregset_t fpregset; /* Floating point register set */
96 fltset_t fltset; /* Current traced hardware fault set */
97 sigset_t trace; /* Current traced signal set */
98 sysset_t exitset; /* Current traced system call exit set */
99 sysset_t entryset; /* Current traced system call entry set */
100 fltset_t saved_fltset; /* Saved traced hardware fault set */
101 sigset_t saved_trace; /* Saved traced signal set */
102 sigset_t saved_sighold; /* Saved held signal set */
103 sysset_t saved_exitset; /* Saved traced system call exit set */
104 sysset_t saved_entryset; /* Saved traced system call entry set */
105 };
106
107 /* List of inferior process information */
108 static struct procinfo *procinfo_list = NULL;
109
110 static struct pollfd *poll_list; /* pollfds used for waiting on /proc */
111
112 static int num_poll_list = 0; /* Number of entries in poll_list */
113
114 static int last_resume_pid = -1; /* Last pid used with procfs_resume */
115
116 /* Much of the information used in the /proc interface, particularly for
117 printing status information, is kept as tables of structures of the
118 following form. These tables can be used to map numeric values to
119 their symbolic names and to a string that describes their specific use. */
120
121 struct trans {
122 int value; /* The numeric value */
123 char *name; /* The equivalent symbolic value */
124 char *desc; /* Short description of value */
125 };
126
127 /* Translate bits in the pr_flags member of the prstatus structure, into the
128 names and desc information. */
129
130 static struct trans pr_flag_table[] =
131 {
132 #if defined (PR_STOPPED)
133 { PR_STOPPED, "PR_STOPPED", "Process is stopped" },
134 #endif
135 #if defined (PR_ISTOP)
136 { PR_ISTOP, "PR_ISTOP", "Stopped on an event of interest" },
137 #endif
138 #if defined (PR_DSTOP)
139 { PR_DSTOP, "PR_DSTOP", "A stop directive is in effect" },
140 #endif
141 #if defined (PR_ASLEEP)
142 { PR_ASLEEP, "PR_ASLEEP", "Sleeping in an interruptible system call" },
143 #endif
144 #if defined (PR_FORK)
145 { PR_FORK, "PR_FORK", "Inherit-on-fork is in effect" },
146 #endif
147 #if defined (PR_RLC)
148 { PR_RLC, "PR_RLC", "Run-on-last-close is in effect" },
149 #endif
150 #if defined (PR_PTRACE)
151 { PR_PTRACE, "PR_PTRACE", "Process is being controlled by ptrace" },
152 #endif
153 #if defined (PR_PCINVAL)
154 { PR_PCINVAL, "PR_PCINVAL", "PC refers to an invalid virtual address" },
155 #endif
156 #if defined (PR_ISSYS)
157 { PR_ISSYS, "PR_ISSYS", "Is a system process" },
158 #endif
159 #if defined (PR_STEP)
160 { PR_STEP, "PR_STEP", "Process has single step pending" },
161 #endif
162 #if defined (PR_KLC)
163 { PR_KLC, "PR_KLC", "Kill-on-last-close is in effect" },
164 #endif
165 #if defined (PR_ASYNC)
166 { PR_ASYNC, "PR_ASYNC", "Asynchronous stop is in effect" },
167 #endif
168 #if defined (PR_PCOMPAT)
169 { PR_PCOMPAT, "PR_PCOMPAT", "Ptrace compatibility mode in effect" },
170 #endif
171 { 0, NULL, NULL }
172 };
173
174 /* Translate values in the pr_why field of the prstatus struct. */
175
176 static struct trans pr_why_table[] =
177 {
178 #if defined (PR_REQUESTED)
179 { PR_REQUESTED, "PR_REQUESTED", "Directed to stop via PIOCSTOP/PIOCWSTOP" },
180 #endif
181 #if defined (PR_SIGNALLED)
182 { PR_SIGNALLED, "PR_SIGNALLED", "Receipt of a traced signal" },
183 #endif
184 #if defined (PR_FAULTED)
185 { PR_FAULTED, "PR_FAULTED", "Incurred a traced hardware fault" },
186 #endif
187 #if defined (PR_SYSENTRY)
188 { PR_SYSENTRY, "PR_SYSENTRY", "Entry to a traced system call" },
189 #endif
190 #if defined (PR_SYSEXIT)
191 { PR_SYSEXIT, "PR_SYSEXIT", "Exit from a traced system call" },
192 #endif
193 #if defined (PR_JOBCONTROL)
194 { PR_JOBCONTROL, "PR_JOBCONTROL", "Default job control stop signal action" },
195 #endif
196 #if defined (PR_SUSPENDED)
197 { PR_SUSPENDED, "PR_SUSPENDED", "Process suspended" },
198 #endif
199 { 0, NULL, NULL }
200 };
201
202 /* Hardware fault translation table. */
203
204 static struct trans faults_table[] =
205 {
206 #if defined (FLTILL)
207 { FLTILL, "FLTILL", "Illegal instruction" },
208 #endif
209 #if defined (FLTPRIV)
210 { FLTPRIV, "FLTPRIV", "Privileged instruction" },
211 #endif
212 #if defined (FLTBPT)
213 { FLTBPT, "FLTBPT", "Breakpoint trap" },
214 #endif
215 #if defined (FLTTRACE)
216 { FLTTRACE, "FLTTRACE", "Trace trap" },
217 #endif
218 #if defined (FLTACCESS)
219 { FLTACCESS, "FLTACCESS", "Memory access fault" },
220 #endif
221 #if defined (FLTBOUNDS)
222 { FLTBOUNDS, "FLTBOUNDS", "Memory bounds violation" },
223 #endif
224 #if defined (FLTIOVF)
225 { FLTIOVF, "FLTIOVF", "Integer overflow" },
226 #endif
227 #if defined (FLTIZDIV)
228 { FLTIZDIV, "FLTIZDIV", "Integer zero divide" },
229 #endif
230 #if defined (FLTFPE)
231 { FLTFPE, "FLTFPE", "Floating-point exception" },
232 #endif
233 #if defined (FLTSTACK)
234 { FLTSTACK, "FLTSTACK", "Unrecoverable stack fault" },
235 #endif
236 #if defined (FLTPAGE)
237 { FLTPAGE, "FLTPAGE", "Recoverable page fault" },
238 #endif
239 { 0, NULL, NULL }
240 };
241
242 /* Translation table for signal generation information. See UNIX System
243 V Release 4 Programmer's Reference Manual, siginfo(5). */
244
245 static struct sigcode {
246 int signo;
247 int code;
248 char *codename;
249 char *desc;
250 } siginfo_table[] = {
251 #if defined (SIGILL) && defined (ILL_ILLOPC)
252 { SIGILL, ILL_ILLOPC, "ILL_ILLOPC", "Illegal opcode" },
253 #endif
254 #if defined (SIGILL) && defined (ILL_ILLOPN)
255 { SIGILL, ILL_ILLOPN, "ILL_ILLOPN", "Illegal operand", },
256 #endif
257 #if defined (SIGILL) && defined (ILL_ILLADR)
258 { SIGILL, ILL_ILLADR, "ILL_ILLADR", "Illegal addressing mode" },
259 #endif
260 #if defined (SIGILL) && defined (ILL_ILLTRP)
261 { SIGILL, ILL_ILLTRP, "ILL_ILLTRP", "Illegal trap" },
262 #endif
263 #if defined (SIGILL) && defined (ILL_PRVOPC)
264 { SIGILL, ILL_PRVOPC, "ILL_PRVOPC", "Privileged opcode" },
265 #endif
266 #if defined (SIGILL) && defined (ILL_PRVREG)
267 { SIGILL, ILL_PRVREG, "ILL_PRVREG", "Privileged register" },
268 #endif
269 #if defined (SIGILL) && defined (ILL_COPROC)
270 { SIGILL, ILL_COPROC, "ILL_COPROC", "Coprocessor error" },
271 #endif
272 #if defined (SIGILL) && defined (ILL_BADSTK)
273 { SIGILL, ILL_BADSTK, "ILL_BADSTK", "Internal stack error" },
274 #endif
275 #if defined (SIGFPE) && defined (FPE_INTDIV)
276 { SIGFPE, FPE_INTDIV, "FPE_INTDIV", "Integer divide by zero" },
277 #endif
278 #if defined (SIGFPE) && defined (FPE_INTOVF)
279 { SIGFPE, FPE_INTOVF, "FPE_INTOVF", "Integer overflow" },
280 #endif
281 #if defined (SIGFPE) && defined (FPE_FLTDIV)
282 { SIGFPE, FPE_FLTDIV, "FPE_FLTDIV", "Floating point divide by zero" },
283 #endif
284 #if defined (SIGFPE) && defined (FPE_FLTOVF)
285 { SIGFPE, FPE_FLTOVF, "FPE_FLTOVF", "Floating point overflow" },
286 #endif
287 #if defined (SIGFPE) && defined (FPE_FLTUND)
288 { SIGFPE, FPE_FLTUND, "FPE_FLTUND", "Floating point underflow" },
289 #endif
290 #if defined (SIGFPE) && defined (FPE_FLTRES)
291 { SIGFPE, FPE_FLTRES, "FPE_FLTRES", "Floating point inexact result" },
292 #endif
293 #if defined (SIGFPE) && defined (FPE_FLTINV)
294 { SIGFPE, FPE_FLTINV, "FPE_FLTINV", "Invalid floating point operation" },
295 #endif
296 #if defined (SIGFPE) && defined (FPE_FLTSUB)
297 { SIGFPE, FPE_FLTSUB, "FPE_FLTSUB", "Subscript out of range" },
298 #endif
299 #if defined (SIGSEGV) && defined (SEGV_MAPERR)
300 { SIGSEGV, SEGV_MAPERR, "SEGV_MAPERR", "Address not mapped to object" },
301 #endif
302 #if defined (SIGSEGV) && defined (SEGV_ACCERR)
303 { SIGSEGV, SEGV_ACCERR, "SEGV_ACCERR", "Invalid permissions for object" },
304 #endif
305 #if defined (SIGBUS) && defined (BUS_ADRALN)
306 { SIGBUS, BUS_ADRALN, "BUS_ADRALN", "Invalid address alignment" },
307 #endif
308 #if defined (SIGBUS) && defined (BUS_ADRERR)
309 { SIGBUS, BUS_ADRERR, "BUS_ADRERR", "Non-existent physical address" },
310 #endif
311 #if defined (SIGBUS) && defined (BUS_OBJERR)
312 { SIGBUS, BUS_OBJERR, "BUS_OBJERR", "Object specific hardware error" },
313 #endif
314 #if defined (SIGTRAP) && defined (TRAP_BRKPT)
315 { SIGTRAP, TRAP_BRKPT, "TRAP_BRKPT", "Process breakpoint" },
316 #endif
317 #if defined (SIGTRAP) && defined (TRAP_TRACE)
318 { SIGTRAP, TRAP_TRACE, "TRAP_TRACE", "Process trace trap" },
319 #endif
320 #if defined (SIGCLD) && defined (CLD_EXITED)
321 { SIGCLD, CLD_EXITED, "CLD_EXITED", "Child has exited" },
322 #endif
323 #if defined (SIGCLD) && defined (CLD_KILLED)
324 { SIGCLD, CLD_KILLED, "CLD_KILLED", "Child was killed" },
325 #endif
326 #if defined (SIGCLD) && defined (CLD_DUMPED)
327 { SIGCLD, CLD_DUMPED, "CLD_DUMPED", "Child has terminated abnormally" },
328 #endif
329 #if defined (SIGCLD) && defined (CLD_TRAPPED)
330 { SIGCLD, CLD_TRAPPED, "CLD_TRAPPED", "Traced child has trapped" },
331 #endif
332 #if defined (SIGCLD) && defined (CLD_STOPPED)
333 { SIGCLD, CLD_STOPPED, "CLD_STOPPED", "Child has stopped" },
334 #endif
335 #if defined (SIGCLD) && defined (CLD_CONTINUED)
336 { SIGCLD, CLD_CONTINUED, "CLD_CONTINUED", "Stopped child had continued" },
337 #endif
338 #if defined (SIGPOLL) && defined (POLL_IN)
339 { SIGPOLL, POLL_IN, "POLL_IN", "Input input available" },
340 #endif
341 #if defined (SIGPOLL) && defined (POLL_OUT)
342 { SIGPOLL, POLL_OUT, "POLL_OUT", "Output buffers available" },
343 #endif
344 #if defined (SIGPOLL) && defined (POLL_MSG)
345 { SIGPOLL, POLL_MSG, "POLL_MSG", "Input message available" },
346 #endif
347 #if defined (SIGPOLL) && defined (POLL_ERR)
348 { SIGPOLL, POLL_ERR, "POLL_ERR", "I/O error" },
349 #endif
350 #if defined (SIGPOLL) && defined (POLL_PRI)
351 { SIGPOLL, POLL_PRI, "POLL_PRI", "High priority input available" },
352 #endif
353 #if defined (SIGPOLL) && defined (POLL_HUP)
354 { SIGPOLL, POLL_HUP, "POLL_HUP", "Device disconnected" },
355 #endif
356 { 0, 0, NULL, NULL }
357 };
358
359 static char *syscall_table[MAX_SYSCALLS];
360
361 /* Prototypes for local functions */
362
363 static void set_proc_siginfo PARAMS ((struct procinfo *, int));
364
365 static void init_syscall_table PARAMS ((void));
366
367 static char *syscallname PARAMS ((int));
368
369 static char *signalname PARAMS ((int));
370
371 static char *errnoname PARAMS ((int));
372
373 static int proc_address_to_fd PARAMS ((struct procinfo *, CORE_ADDR, int));
374
375 static int open_proc_file PARAMS ((int, struct procinfo *, int));
376
377 static void close_proc_file PARAMS ((struct procinfo *));
378
379 static void unconditionally_kill_inferior PARAMS ((struct procinfo *));
380
381 static NORETURN void proc_init_failed PARAMS ((struct procinfo *, char *)) ATTR_NORETURN;
382
383 static void info_proc PARAMS ((char *, int));
384
385 static void info_proc_flags PARAMS ((struct procinfo *, int));
386
387 static void info_proc_stop PARAMS ((struct procinfo *, int));
388
389 static void info_proc_siginfo PARAMS ((struct procinfo *, int));
390
391 static void info_proc_syscalls PARAMS ((struct procinfo *, int));
392
393 static void info_proc_mappings PARAMS ((struct procinfo *, int));
394
395 static void info_proc_signals PARAMS ((struct procinfo *, int));
396
397 static void info_proc_faults PARAMS ((struct procinfo *, int));
398
399 static char *mappingflags PARAMS ((long));
400
401 static char *lookupname PARAMS ((struct trans *, unsigned int, char *));
402
403 static char *lookupdesc PARAMS ((struct trans *, unsigned int));
404
405 static int do_attach PARAMS ((int pid));
406
407 static void do_detach PARAMS ((int siggnal));
408
409 static void procfs_create_inferior PARAMS ((char *, char *, char **));
410
411 static void procfs_notice_signals PARAMS ((int pid));
412
413 static struct procinfo *find_procinfo PARAMS ((pid_t pid, int okfail));
414
415 /* External function prototypes that can't be easily included in any
416 header file because the args are typedefs in system include files. */
417
418 extern void supply_gregset PARAMS ((gregset_t *));
419
420 extern void fill_gregset PARAMS ((gregset_t *, int));
421
422 extern void supply_fpregset PARAMS ((fpregset_t *));
423
424 extern void fill_fpregset PARAMS ((fpregset_t *, int));
425
426 /*
427
428 LOCAL FUNCTION
429
430 find_procinfo -- convert a process id to a struct procinfo
431
432 SYNOPSIS
433
434 static struct procinfo * find_procinfo (pid_t pid, int okfail);
435
436 DESCRIPTION
437
438 Given a process id, look it up in the procinfo chain. Returns
439 a struct procinfo *. If can't find pid, then call error(),
440 unless okfail is set, in which case, return NULL;
441 */
442
443 static struct procinfo *
444 find_procinfo (pid, okfail)
445 pid_t pid;
446 int okfail;
447 {
448 struct procinfo *procinfo;
449
450 for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
451 if (procinfo->pid == pid)
452 return procinfo;
453
454 if (okfail)
455 return NULL;
456
457 error ("procfs (find_procinfo): Couldn't locate pid %d", pid);
458 }
459
460 /*
461
462 LOCAL MACRO
463
464 current_procinfo -- convert inferior_pid to a struct procinfo
465
466 SYNOPSIS
467
468 static struct procinfo * current_procinfo;
469
470 DESCRIPTION
471
472 Looks up inferior_pid in the procinfo chain. Always returns a
473 struct procinfo *. If process can't be found, we error() out.
474 */
475
476 #define current_procinfo find_procinfo (inferior_pid, 0)
477
478 /*
479
480 LOCAL FUNCTION
481
482 add_fd -- Add the fd to the poll/select list
483
484 SYNOPSIS
485
486 static void add_fd (struct procinfo *);
487
488 DESCRIPTION
489
490 Add the fd of the supplied procinfo to the list of fds used for
491 poll/select operations.
492 */
493
494 static void
495 add_fd (pi)
496 struct procinfo *pi;
497 {
498 if (num_poll_list <= 0)
499 poll_list = (struct pollfd *) xmalloc (sizeof (struct pollfd));
500 else
501 poll_list = (struct pollfd *) xrealloc (poll_list,
502 (num_poll_list + 1)
503 * sizeof (struct pollfd));
504 poll_list[num_poll_list].fd = pi->fd;
505 poll_list[num_poll_list].events = POLLPRI;
506
507 num_poll_list++;
508 }
509
510 static void
511 remove_fd (pi)
512 struct procinfo *pi;
513 {
514 int i;
515
516 for (i = 0; i < num_poll_list; i++)
517 {
518 if (poll_list[i].fd == pi->fd)
519 {
520 if (i != num_poll_list - 1)
521 memcpy (poll_list, poll_list + i + 1,
522 (num_poll_list - i - 1) * sizeof (struct pollfd));
523
524 num_poll_list--;
525
526 if (num_poll_list == 0)
527 free (poll_list);
528 else
529 poll_list = (struct pollfd *) xrealloc (poll_list,
530 num_poll_list
531 * sizeof (struct pollfd));
532 return;
533 }
534 }
535 }
536
537 #define LOSING_POLL unixware_sux
538
539 static struct procinfo *
540 wait_fd ()
541 {
542 struct procinfo *pi;
543 int num_fds;
544 int i;
545
546 set_sigint_trap (); /* Causes SIGINT to be passed on to the
547 attached process. */
548 set_sigio_trap ();
549
550 #ifndef LOSING_POLL
551 num_fds = poll (poll_list, num_poll_list, -1);
552 #else
553 pi = current_procinfo;
554
555 while (ioctl (pi->fd, PIOCWSTOP, &pi->prstatus) < 0)
556 {
557 if (errno == ENOENT)
558 {
559 /* Process exited. */
560 pi->prstatus.pr_flags = 0;
561 break;
562 }
563 else if (errno != EINTR)
564 {
565 print_sys_errmsg (pi->pathname, errno);
566 error ("PIOCWSTOP failed");
567 }
568 }
569 pi->had_event = 1;
570 #endif
571
572 clear_sigint_trap ();
573 clear_sigio_trap ();
574
575 #ifndef LOSING_POLL
576
577 if (num_fds <= 0)
578 {
579 print_sys_errmsg ("poll failed\n", errno);
580 error ("Poll failed, returned %d", num_fds);
581 }
582
583 for (i = 0; i < num_poll_list && num_fds > 0; i++)
584 {
585 if ((poll_list[i].revents & (POLLPRI|POLLERR|POLLHUP|POLLNVAL)) == 0)
586 continue;
587 for (pi = procinfo_list; pi; pi = pi->next)
588 {
589 if (poll_list[i].fd == pi->fd)
590 {
591 if (ioctl (pi->fd, PIOCSTATUS, &pi->prstatus) < 0)
592 {
593 print_sys_errmsg (pi->pathname, errno);
594 error ("PIOCSTATUS failed");
595 }
596 num_fds--;
597 pi->had_event = 1;
598 break;
599 }
600 }
601 if (!pi)
602 error ("procfs_wait: Couldn't find procinfo for fd %d\n",
603 poll_list[i].fd);
604 }
605 #endif /* LOSING_POLL */
606
607 return pi;
608 }
609
610 /*
611
612 LOCAL FUNCTION
613
614 lookupdesc -- translate a value to a summary desc string
615
616 SYNOPSIS
617
618 static char *lookupdesc (struct trans *transp, unsigned int val);
619
620 DESCRIPTION
621
622 Given a pointer to a translation table and a value to be translated,
623 lookup the desc string and return it.
624 */
625
626 static char *
627 lookupdesc (transp, val)
628 struct trans *transp;
629 unsigned int val;
630 {
631 char *desc;
632
633 for (desc = NULL; transp -> name != NULL; transp++)
634 {
635 if (transp -> value == val)
636 {
637 desc = transp -> desc;
638 break;
639 }
640 }
641
642 /* Didn't find a translation for the specified value, set a default one. */
643
644 if (desc == NULL)
645 {
646 desc = "Unknown";
647 }
648 return (desc);
649 }
650
651 /*
652
653 LOCAL FUNCTION
654
655 lookupname -- translate a value to symbolic name
656
657 SYNOPSIS
658
659 static char *lookupname (struct trans *transp, unsigned int val,
660 char *prefix);
661
662 DESCRIPTION
663
664 Given a pointer to a translation table, a value to be translated,
665 and a default prefix to return if the value can't be translated,
666 match the value with one of the translation table entries and
667 return a pointer to the symbolic name.
668
669 If no match is found it just returns the value as a printable string,
670 with the given prefix. The previous such value, if any, is freed
671 at this time.
672 */
673
674 static char *
675 lookupname (transp, val, prefix)
676 struct trans *transp;
677 unsigned int val;
678 char *prefix;
679 {
680 static char *locbuf;
681 char *name;
682
683 for (name = NULL; transp -> name != NULL; transp++)
684 {
685 if (transp -> value == val)
686 {
687 name = transp -> name;
688 break;
689 }
690 }
691
692 /* Didn't find a translation for the specified value, build a default
693 one using the specified prefix and return it. The lifetime of
694 the value is only until the next one is needed. */
695
696 if (name == NULL)
697 {
698 if (locbuf != NULL)
699 {
700 free (locbuf);
701 }
702 locbuf = xmalloc (strlen (prefix) + 16);
703 sprintf (locbuf, "%s %u", prefix, val);
704 name = locbuf;
705 }
706 return (name);
707 }
708
709 static char *
710 sigcodename (sip)
711 siginfo_t *sip;
712 {
713 struct sigcode *scp;
714 char *name = NULL;
715 static char locbuf[32];
716
717 for (scp = siginfo_table; scp -> codename != NULL; scp++)
718 {
719 if ((scp -> signo == sip -> si_signo) &&
720 (scp -> code == sip -> si_code))
721 {
722 name = scp -> codename;
723 break;
724 }
725 }
726 if (name == NULL)
727 {
728 sprintf (locbuf, "sigcode %u", sip -> si_signo);
729 name = locbuf;
730 }
731 return (name);
732 }
733
734 static char *
735 sigcodedesc (sip)
736 siginfo_t *sip;
737 {
738 struct sigcode *scp;
739 char *desc = NULL;
740
741 for (scp = siginfo_table; scp -> codename != NULL; scp++)
742 {
743 if ((scp -> signo == sip -> si_signo) &&
744 (scp -> code == sip -> si_code))
745 {
746 desc = scp -> desc;
747 break;
748 }
749 }
750 if (desc == NULL)
751 {
752 desc = "Unrecognized signal or trap use";
753 }
754 return (desc);
755 }
756
757 /*
758
759 LOCAL FUNCTION
760
761 syscallname - translate a system call number into a system call name
762
763 SYNOPSIS
764
765 char *syscallname (int syscallnum)
766
767 DESCRIPTION
768
769 Given a system call number, translate it into the printable name
770 of a system call, or into "syscall <num>" if it is an unknown
771 number.
772 */
773
774 static char *
775 syscallname (syscallnum)
776 int syscallnum;
777 {
778 static char locbuf[32];
779 char *rtnval;
780
781 if (syscallnum >= 0 && syscallnum < MAX_SYSCALLS)
782 {
783 rtnval = syscall_table[syscallnum];
784 }
785 else
786 {
787 sprintf (locbuf, "syscall %u", syscallnum);
788 rtnval = locbuf;
789 }
790 return (rtnval);
791 }
792
793 /*
794
795 LOCAL FUNCTION
796
797 init_syscall_table - initialize syscall translation table
798
799 SYNOPSIS
800
801 void init_syscall_table (void)
802
803 DESCRIPTION
804
805 Dynamically initialize the translation table to convert system
806 call numbers into printable system call names. Done once per
807 gdb run, on initialization.
808
809 NOTES
810
811 This is awfully ugly, but preprocessor tricks to make it prettier
812 tend to be nonportable.
813 */
814
815 static void
816 init_syscall_table ()
817 {
818 #if defined (SYS_exit)
819 syscall_table[SYS_exit] = "exit";
820 #endif
821 #if defined (SYS_fork)
822 syscall_table[SYS_fork] = "fork";
823 #endif
824 #if defined (SYS_read)
825 syscall_table[SYS_read] = "read";
826 #endif
827 #if defined (SYS_write)
828 syscall_table[SYS_write] = "write";
829 #endif
830 #if defined (SYS_open)
831 syscall_table[SYS_open] = "open";
832 #endif
833 #if defined (SYS_close)
834 syscall_table[SYS_close] = "close";
835 #endif
836 #if defined (SYS_wait)
837 syscall_table[SYS_wait] = "wait";
838 #endif
839 #if defined (SYS_creat)
840 syscall_table[SYS_creat] = "creat";
841 #endif
842 #if defined (SYS_link)
843 syscall_table[SYS_link] = "link";
844 #endif
845 #if defined (SYS_unlink)
846 syscall_table[SYS_unlink] = "unlink";
847 #endif
848 #if defined (SYS_exec)
849 syscall_table[SYS_exec] = "exec";
850 #endif
851 #if defined (SYS_execv)
852 syscall_table[SYS_execv] = "execv";
853 #endif
854 #if defined (SYS_execve)
855 syscall_table[SYS_execve] = "execve";
856 #endif
857 #if defined (SYS_chdir)
858 syscall_table[SYS_chdir] = "chdir";
859 #endif
860 #if defined (SYS_time)
861 syscall_table[SYS_time] = "time";
862 #endif
863 #if defined (SYS_mknod)
864 syscall_table[SYS_mknod] = "mknod";
865 #endif
866 #if defined (SYS_chmod)
867 syscall_table[SYS_chmod] = "chmod";
868 #endif
869 #if defined (SYS_chown)
870 syscall_table[SYS_chown] = "chown";
871 #endif
872 #if defined (SYS_brk)
873 syscall_table[SYS_brk] = "brk";
874 #endif
875 #if defined (SYS_stat)
876 syscall_table[SYS_stat] = "stat";
877 #endif
878 #if defined (SYS_lseek)
879 syscall_table[SYS_lseek] = "lseek";
880 #endif
881 #if defined (SYS_getpid)
882 syscall_table[SYS_getpid] = "getpid";
883 #endif
884 #if defined (SYS_mount)
885 syscall_table[SYS_mount] = "mount";
886 #endif
887 #if defined (SYS_umount)
888 syscall_table[SYS_umount] = "umount";
889 #endif
890 #if defined (SYS_setuid)
891 syscall_table[SYS_setuid] = "setuid";
892 #endif
893 #if defined (SYS_getuid)
894 syscall_table[SYS_getuid] = "getuid";
895 #endif
896 #if defined (SYS_stime)
897 syscall_table[SYS_stime] = "stime";
898 #endif
899 #if defined (SYS_ptrace)
900 syscall_table[SYS_ptrace] = "ptrace";
901 #endif
902 #if defined (SYS_alarm)
903 syscall_table[SYS_alarm] = "alarm";
904 #endif
905 #if defined (SYS_fstat)
906 syscall_table[SYS_fstat] = "fstat";
907 #endif
908 #if defined (SYS_pause)
909 syscall_table[SYS_pause] = "pause";
910 #endif
911 #if defined (SYS_utime)
912 syscall_table[SYS_utime] = "utime";
913 #endif
914 #if defined (SYS_stty)
915 syscall_table[SYS_stty] = "stty";
916 #endif
917 #if defined (SYS_gtty)
918 syscall_table[SYS_gtty] = "gtty";
919 #endif
920 #if defined (SYS_access)
921 syscall_table[SYS_access] = "access";
922 #endif
923 #if defined (SYS_nice)
924 syscall_table[SYS_nice] = "nice";
925 #endif
926 #if defined (SYS_statfs)
927 syscall_table[SYS_statfs] = "statfs";
928 #endif
929 #if defined (SYS_sync)
930 syscall_table[SYS_sync] = "sync";
931 #endif
932 #if defined (SYS_kill)
933 syscall_table[SYS_kill] = "kill";
934 #endif
935 #if defined (SYS_fstatfs)
936 syscall_table[SYS_fstatfs] = "fstatfs";
937 #endif
938 #if defined (SYS_pgrpsys)
939 syscall_table[SYS_pgrpsys] = "pgrpsys";
940 #endif
941 #if defined (SYS_xenix)
942 syscall_table[SYS_xenix] = "xenix";
943 #endif
944 #if defined (SYS_dup)
945 syscall_table[SYS_dup] = "dup";
946 #endif
947 #if defined (SYS_pipe)
948 syscall_table[SYS_pipe] = "pipe";
949 #endif
950 #if defined (SYS_times)
951 syscall_table[SYS_times] = "times";
952 #endif
953 #if defined (SYS_profil)
954 syscall_table[SYS_profil] = "profil";
955 #endif
956 #if defined (SYS_plock)
957 syscall_table[SYS_plock] = "plock";
958 #endif
959 #if defined (SYS_setgid)
960 syscall_table[SYS_setgid] = "setgid";
961 #endif
962 #if defined (SYS_getgid)
963 syscall_table[SYS_getgid] = "getgid";
964 #endif
965 #if defined (SYS_signal)
966 syscall_table[SYS_signal] = "signal";
967 #endif
968 #if defined (SYS_msgsys)
969 syscall_table[SYS_msgsys] = "msgsys";
970 #endif
971 #if defined (SYS_sys3b)
972 syscall_table[SYS_sys3b] = "sys3b";
973 #endif
974 #if defined (SYS_acct)
975 syscall_table[SYS_acct] = "acct";
976 #endif
977 #if defined (SYS_shmsys)
978 syscall_table[SYS_shmsys] = "shmsys";
979 #endif
980 #if defined (SYS_semsys)
981 syscall_table[SYS_semsys] = "semsys";
982 #endif
983 #if defined (SYS_ioctl)
984 syscall_table[SYS_ioctl] = "ioctl";
985 #endif
986 #if defined (SYS_uadmin)
987 syscall_table[SYS_uadmin] = "uadmin";
988 #endif
989 #if defined (SYS_utssys)
990 syscall_table[SYS_utssys] = "utssys";
991 #endif
992 #if defined (SYS_fsync)
993 syscall_table[SYS_fsync] = "fsync";
994 #endif
995 #if defined (SYS_umask)
996 syscall_table[SYS_umask] = "umask";
997 #endif
998 #if defined (SYS_chroot)
999 syscall_table[SYS_chroot] = "chroot";
1000 #endif
1001 #if defined (SYS_fcntl)
1002 syscall_table[SYS_fcntl] = "fcntl";
1003 #endif
1004 #if defined (SYS_ulimit)
1005 syscall_table[SYS_ulimit] = "ulimit";
1006 #endif
1007 #if defined (SYS_rfsys)
1008 syscall_table[SYS_rfsys] = "rfsys";
1009 #endif
1010 #if defined (SYS_rmdir)
1011 syscall_table[SYS_rmdir] = "rmdir";
1012 #endif
1013 #if defined (SYS_mkdir)
1014 syscall_table[SYS_mkdir] = "mkdir";
1015 #endif
1016 #if defined (SYS_getdents)
1017 syscall_table[SYS_getdents] = "getdents";
1018 #endif
1019 #if defined (SYS_sysfs)
1020 syscall_table[SYS_sysfs] = "sysfs";
1021 #endif
1022 #if defined (SYS_getmsg)
1023 syscall_table[SYS_getmsg] = "getmsg";
1024 #endif
1025 #if defined (SYS_putmsg)
1026 syscall_table[SYS_putmsg] = "putmsg";
1027 #endif
1028 #if defined (SYS_poll)
1029 syscall_table[SYS_poll] = "poll";
1030 #endif
1031 #if defined (SYS_lstat)
1032 syscall_table[SYS_lstat] = "lstat";
1033 #endif
1034 #if defined (SYS_symlink)
1035 syscall_table[SYS_symlink] = "symlink";
1036 #endif
1037 #if defined (SYS_readlink)
1038 syscall_table[SYS_readlink] = "readlink";
1039 #endif
1040 #if defined (SYS_setgroups)
1041 syscall_table[SYS_setgroups] = "setgroups";
1042 #endif
1043 #if defined (SYS_getgroups)
1044 syscall_table[SYS_getgroups] = "getgroups";
1045 #endif
1046 #if defined (SYS_fchmod)
1047 syscall_table[SYS_fchmod] = "fchmod";
1048 #endif
1049 #if defined (SYS_fchown)
1050 syscall_table[SYS_fchown] = "fchown";
1051 #endif
1052 #if defined (SYS_sigprocmask)
1053 syscall_table[SYS_sigprocmask] = "sigprocmask";
1054 #endif
1055 #if defined (SYS_sigsuspend)
1056 syscall_table[SYS_sigsuspend] = "sigsuspend";
1057 #endif
1058 #if defined (SYS_sigaltstack)
1059 syscall_table[SYS_sigaltstack] = "sigaltstack";
1060 #endif
1061 #if defined (SYS_sigaction)
1062 syscall_table[SYS_sigaction] = "sigaction";
1063 #endif
1064 #if defined (SYS_sigpending)
1065 syscall_table[SYS_sigpending] = "sigpending";
1066 #endif
1067 #if defined (SYS_context)
1068 syscall_table[SYS_context] = "context";
1069 #endif
1070 #if defined (SYS_evsys)
1071 syscall_table[SYS_evsys] = "evsys";
1072 #endif
1073 #if defined (SYS_evtrapret)
1074 syscall_table[SYS_evtrapret] = "evtrapret";
1075 #endif
1076 #if defined (SYS_statvfs)
1077 syscall_table[SYS_statvfs] = "statvfs";
1078 #endif
1079 #if defined (SYS_fstatvfs)
1080 syscall_table[SYS_fstatvfs] = "fstatvfs";
1081 #endif
1082 #if defined (SYS_nfssys)
1083 syscall_table[SYS_nfssys] = "nfssys";
1084 #endif
1085 #if defined (SYS_waitsys)
1086 syscall_table[SYS_waitsys] = "waitsys";
1087 #endif
1088 #if defined (SYS_sigsendsys)
1089 syscall_table[SYS_sigsendsys] = "sigsendsys";
1090 #endif
1091 #if defined (SYS_hrtsys)
1092 syscall_table[SYS_hrtsys] = "hrtsys";
1093 #endif
1094 #if defined (SYS_acancel)
1095 syscall_table[SYS_acancel] = "acancel";
1096 #endif
1097 #if defined (SYS_async)
1098 syscall_table[SYS_async] = "async";
1099 #endif
1100 #if defined (SYS_priocntlsys)
1101 syscall_table[SYS_priocntlsys] = "priocntlsys";
1102 #endif
1103 #if defined (SYS_pathconf)
1104 syscall_table[SYS_pathconf] = "pathconf";
1105 #endif
1106 #if defined (SYS_mincore)
1107 syscall_table[SYS_mincore] = "mincore";
1108 #endif
1109 #if defined (SYS_mmap)
1110 syscall_table[SYS_mmap] = "mmap";
1111 #endif
1112 #if defined (SYS_mprotect)
1113 syscall_table[SYS_mprotect] = "mprotect";
1114 #endif
1115 #if defined (SYS_munmap)
1116 syscall_table[SYS_munmap] = "munmap";
1117 #endif
1118 #if defined (SYS_fpathconf)
1119 syscall_table[SYS_fpathconf] = "fpathconf";
1120 #endif
1121 #if defined (SYS_vfork)
1122 syscall_table[SYS_vfork] = "vfork";
1123 #endif
1124 #if defined (SYS_fchdir)
1125 syscall_table[SYS_fchdir] = "fchdir";
1126 #endif
1127 #if defined (SYS_readv)
1128 syscall_table[SYS_readv] = "readv";
1129 #endif
1130 #if defined (SYS_writev)
1131 syscall_table[SYS_writev] = "writev";
1132 #endif
1133 #if defined (SYS_xstat)
1134 syscall_table[SYS_xstat] = "xstat";
1135 #endif
1136 #if defined (SYS_lxstat)
1137 syscall_table[SYS_lxstat] = "lxstat";
1138 #endif
1139 #if defined (SYS_fxstat)
1140 syscall_table[SYS_fxstat] = "fxstat";
1141 #endif
1142 #if defined (SYS_xmknod)
1143 syscall_table[SYS_xmknod] = "xmknod";
1144 #endif
1145 #if defined (SYS_clocal)
1146 syscall_table[SYS_clocal] = "clocal";
1147 #endif
1148 #if defined (SYS_setrlimit)
1149 syscall_table[SYS_setrlimit] = "setrlimit";
1150 #endif
1151 #if defined (SYS_getrlimit)
1152 syscall_table[SYS_getrlimit] = "getrlimit";
1153 #endif
1154 #if defined (SYS_lchown)
1155 syscall_table[SYS_lchown] = "lchown";
1156 #endif
1157 #if defined (SYS_memcntl)
1158 syscall_table[SYS_memcntl] = "memcntl";
1159 #endif
1160 #if defined (SYS_getpmsg)
1161 syscall_table[SYS_getpmsg] = "getpmsg";
1162 #endif
1163 #if defined (SYS_putpmsg)
1164 syscall_table[SYS_putpmsg] = "putpmsg";
1165 #endif
1166 #if defined (SYS_rename)
1167 syscall_table[SYS_rename] = "rename";
1168 #endif
1169 #if defined (SYS_uname)
1170 syscall_table[SYS_uname] = "uname";
1171 #endif
1172 #if defined (SYS_setegid)
1173 syscall_table[SYS_setegid] = "setegid";
1174 #endif
1175 #if defined (SYS_sysconfig)
1176 syscall_table[SYS_sysconfig] = "sysconfig";
1177 #endif
1178 #if defined (SYS_adjtime)
1179 syscall_table[SYS_adjtime] = "adjtime";
1180 #endif
1181 #if defined (SYS_systeminfo)
1182 syscall_table[SYS_systeminfo] = "systeminfo";
1183 #endif
1184 #if defined (SYS_seteuid)
1185 syscall_table[SYS_seteuid] = "seteuid";
1186 #endif
1187 #if defined (SYS_sproc)
1188 syscall_table[SYS_sproc] = "sproc";
1189 #endif
1190 }
1191
1192 /*
1193
1194 LOCAL FUNCTION
1195
1196 procfs_kill_inferior - kill any currently inferior
1197
1198 SYNOPSIS
1199
1200 void procfs_kill_inferior (void)
1201
1202 DESCRIPTION
1203
1204 Kill any current inferior.
1205
1206 NOTES
1207
1208 Kills even attached inferiors. Presumably the user has already
1209 been prompted that the inferior is an attached one rather than
1210 one started by gdb. (FIXME?)
1211
1212 */
1213
1214 static void
1215 procfs_kill_inferior ()
1216 {
1217 target_mourn_inferior ();
1218 }
1219
1220 /*
1221
1222 LOCAL FUNCTION
1223
1224 unconditionally_kill_inferior - terminate the inferior
1225
1226 SYNOPSIS
1227
1228 static void unconditionally_kill_inferior (struct procinfo *)
1229
1230 DESCRIPTION
1231
1232 Kill the specified inferior.
1233
1234 NOTE
1235
1236 A possibly useful enhancement would be to first try sending
1237 the inferior a terminate signal, politely asking it to commit
1238 suicide, before we murder it (we could call that
1239 politely_kill_inferior()).
1240
1241 */
1242
1243 static void
1244 unconditionally_kill_inferior (pi)
1245 struct procinfo *pi;
1246 {
1247 int signo;
1248 int ppid;
1249
1250 ppid = pi->prstatus.pr_ppid;
1251
1252 signo = SIGKILL;
1253
1254 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
1255 /* Alpha OSF/1-3.x procfs needs a clear of the current signal
1256 before the PIOCKILL, otherwise it might generate a corrupted core
1257 file for the inferior. */
1258 ioctl (pi->fd, PIOCSSIG, NULL);
1259 #endif
1260 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
1261 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
1262 to kill the inferior, otherwise it might remain stopped with a
1263 pending SIGKILL.
1264 We do not check the result of the PIOCSSIG, the inferior might have
1265 died already. */
1266 {
1267 struct siginfo newsiginfo;
1268
1269 memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
1270 newsiginfo.si_signo = signo;
1271 newsiginfo.si_code = 0;
1272 newsiginfo.si_errno = 0;
1273 newsiginfo.si_pid = getpid ();
1274 newsiginfo.si_uid = getuid ();
1275 ioctl (pi->fd, PIOCSSIG, &newsiginfo);
1276 }
1277 #else
1278 ioctl (pi->fd, PIOCKILL, &signo);
1279 #endif
1280
1281 close_proc_file (pi);
1282
1283 /* Only wait() for our direct children. Our grandchildren zombies are killed
1284 by the death of their parents. */
1285
1286 if (ppid == getpid())
1287 wait ((int *) 0);
1288 }
1289
1290 /*
1291
1292 LOCAL FUNCTION
1293
1294 procfs_xfer_memory -- copy data to or from inferior memory space
1295
1296 SYNOPSIS
1297
1298 int procfs_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
1299 int dowrite, struct target_ops target)
1300
1301 DESCRIPTION
1302
1303 Copy LEN bytes to/from inferior's memory starting at MEMADDR
1304 from/to debugger memory starting at MYADDR. Copy from inferior
1305 if DOWRITE is zero or to inferior if DOWRITE is nonzero.
1306
1307 Returns the length copied, which is either the LEN argument or
1308 zero. This xfer function does not do partial moves, since procfs_ops
1309 doesn't allow memory operations to cross below us in the target stack
1310 anyway.
1311
1312 NOTES
1313
1314 The /proc interface makes this an almost trivial task.
1315 */
1316
1317 static int
1318 procfs_xfer_memory (memaddr, myaddr, len, dowrite, target)
1319 CORE_ADDR memaddr;
1320 char *myaddr;
1321 int len;
1322 int dowrite;
1323 struct target_ops *target; /* ignored */
1324 {
1325 int nbytes = 0;
1326 struct procinfo *pi;
1327
1328 pi = current_procinfo;
1329
1330 if (lseek(pi->fd, (off_t) memaddr, 0) == (off_t) memaddr)
1331 {
1332 if (dowrite)
1333 {
1334 nbytes = write (pi->fd, myaddr, len);
1335 }
1336 else
1337 {
1338 nbytes = read (pi->fd, myaddr, len);
1339 }
1340 if (nbytes < 0)
1341 {
1342 nbytes = 0;
1343 }
1344 }
1345 return (nbytes);
1346 }
1347
1348 /*
1349
1350 LOCAL FUNCTION
1351
1352 procfs_store_registers -- copy register values back to inferior
1353
1354 SYNOPSIS
1355
1356 void procfs_store_registers (int regno)
1357
1358 DESCRIPTION
1359
1360 Store our current register values back into the inferior. If
1361 REGNO is -1 then store all the register, otherwise store just
1362 the value specified by REGNO.
1363
1364 NOTES
1365
1366 If we are storing only a single register, we first have to get all
1367 the current values from the process, overwrite the desired register
1368 in the gregset with the one we want from gdb's registers, and then
1369 send the whole set back to the process. For writing all the
1370 registers, all we have to do is generate the gregset and send it to
1371 the process.
1372
1373 Also note that the process has to be stopped on an event of interest
1374 for this to work, which basically means that it has to have been
1375 run under the control of one of the other /proc ioctl calls and not
1376 ptrace. Since we don't use ptrace anyway, we don't worry about this
1377 fine point, but it is worth noting for future reference.
1378
1379 Gdb is confused about what this function is supposed to return.
1380 Some versions return a value, others return nothing. Some are
1381 declared to return a value and actually return nothing. Gdb ignores
1382 anything returned. (FIXME)
1383
1384 */
1385
1386 static void
1387 procfs_store_registers (regno)
1388 int regno;
1389 {
1390 struct procinfo *pi;
1391
1392 pi = current_procinfo;
1393
1394 if (regno != -1)
1395 {
1396 ioctl (pi->fd, PIOCGREG, &pi->gregset);
1397 }
1398 fill_gregset (&pi->gregset, regno);
1399 ioctl (pi->fd, PIOCSREG, &pi->gregset);
1400
1401 #if defined (FP0_REGNUM)
1402
1403 /* Now repeat everything using the floating point register set, if the
1404 target has floating point hardware. Since we ignore the returned value,
1405 we'll never know whether it worked or not anyway. */
1406
1407 if (regno != -1)
1408 {
1409 ioctl (pi->fd, PIOCGFPREG, &pi->fpregset);
1410 }
1411 fill_fpregset (&pi->fpregset, regno);
1412 ioctl (pi->fd, PIOCSFPREG, &pi->fpregset);
1413
1414 #endif /* FP0_REGNUM */
1415
1416 }
1417
1418 /*
1419
1420 LOCAL FUNCTION
1421
1422 create_procinfo - initialize access to a /proc entry
1423
1424 SYNOPSIS
1425
1426 struct procinfo * create_procinfo (int pid)
1427
1428 DESCRIPTION
1429
1430 Allocate a procinfo structure, open the /proc file and then set up the
1431 set of signals and faults that are to be traced. Returns a pointer to
1432 the new procinfo structure.
1433
1434 NOTES
1435
1436 If proc_init_failed ever gets called, control returns to the command
1437 processing loop via the standard error handling code.
1438
1439 */
1440
1441 static struct procinfo *
1442 create_procinfo (pid)
1443 int pid;
1444 {
1445 struct procinfo *pi;
1446
1447 pi = find_procinfo (pid, 1);
1448 if (pi != NULL)
1449 return pi; /* All done! It already exists */
1450
1451 pi = (struct procinfo *) xmalloc (sizeof (struct procinfo));
1452
1453 if (!open_proc_file (pid, pi, O_RDWR))
1454 proc_init_failed (pi, "can't open process file");
1455
1456 /* Add new process to process info list */
1457
1458 pi->next = procinfo_list;
1459 procinfo_list = pi;
1460
1461 add_fd (pi); /* Add to list for poll/select */
1462
1463 memset ((char *) &pi->prrun, 0, sizeof (pi->prrun));
1464 prfillset (&pi->prrun.pr_trace);
1465 procfs_notice_signals (pid);
1466 prfillset (&pi->prrun.pr_fault);
1467 prdelset (&pi->prrun.pr_fault, FLTPAGE);
1468
1469 #ifdef PROCFS_DONT_TRACE_FAULTS
1470 premptyset (&pi->prrun.pr_fault);
1471 #endif
1472
1473 if (ioctl (pi->fd, PIOCWSTOP, &pi->prstatus) < 0)
1474 proc_init_failed (pi, "PIOCWSTOP failed");
1475
1476 if (ioctl (pi->fd, PIOCSFAULT, &pi->prrun.pr_fault) < 0)
1477 proc_init_failed (pi, "PIOCSFAULT failed");
1478
1479 return pi;
1480 }
1481
1482 /*
1483
1484 LOCAL FUNCTION
1485
1486 procfs_init_inferior - initialize target vector and access to a
1487 /proc entry
1488
1489 SYNOPSIS
1490
1491 void procfs_init_inferior (int pid)
1492
1493 DESCRIPTION
1494
1495 When gdb starts an inferior, this function is called in the parent
1496 process immediately after the fork. It waits for the child to stop
1497 on the return from the exec system call (the child itself takes care
1498 of ensuring that this is set up), then sets up the set of signals
1499 and faults that are to be traced.
1500
1501 NOTES
1502
1503 If proc_init_failed ever gets called, control returns to the command
1504 processing loop via the standard error handling code.
1505
1506 */
1507
1508 static void
1509 procfs_init_inferior (pid)
1510 int pid;
1511 {
1512 push_target (&procfs_ops);
1513
1514 create_procinfo (pid);
1515 add_thread (pid); /* Setup initial thread */
1516
1517 #ifdef START_INFERIOR_TRAPS_EXPECTED
1518 startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
1519 #else
1520 /* One trap to exec the shell, one to exec the program being debugged. */
1521 startup_inferior (2);
1522 #endif
1523 }
1524
1525 /*
1526
1527 GLOBAL FUNCTION
1528
1529 procfs_notice_signals
1530
1531 SYNOPSIS
1532
1533 static void procfs_notice_signals (int pid);
1534
1535 DESCRIPTION
1536
1537 When the user changes the state of gdb's signal handling via the
1538 "handle" command, this function gets called to see if any change
1539 in the /proc interface is required. It is also called internally
1540 by other /proc interface functions to initialize the state of
1541 the traced signal set.
1542
1543 One thing it does is that signals for which the state is "nostop",
1544 "noprint", and "pass", have their trace bits reset in the pr_trace
1545 field, so that they are no longer traced. This allows them to be
1546 delivered directly to the inferior without the debugger ever being
1547 involved.
1548 */
1549
1550 static void
1551 procfs_notice_signals (pid)
1552 int pid;
1553 {
1554 int signo;
1555 struct procinfo *pi;
1556
1557 pi = find_procinfo (pid, 0);
1558
1559 for (signo = 0; signo < NSIG; signo++)
1560 {
1561 if (signal_stop_state (target_signal_from_host (signo)) == 0 &&
1562 signal_print_state (target_signal_from_host (signo)) == 0 &&
1563 signal_pass_state (target_signal_from_host (signo)) == 1)
1564 {
1565 prdelset (&pi->prrun.pr_trace, signo);
1566 }
1567 else
1568 {
1569 praddset (&pi->prrun.pr_trace, signo);
1570 }
1571 }
1572 if (ioctl (pi->fd, PIOCSTRACE, &pi->prrun.pr_trace))
1573 {
1574 print_sys_errmsg ("PIOCSTRACE failed", errno);
1575 }
1576 }
1577
1578 /*
1579
1580 LOCAL FUNCTION
1581
1582 proc_set_exec_trap -- arrange for exec'd child to halt at startup
1583
1584 SYNOPSIS
1585
1586 void proc_set_exec_trap (void)
1587
1588 DESCRIPTION
1589
1590 This function is called in the child process when starting up
1591 an inferior, prior to doing the exec of the actual inferior.
1592 It sets the child process's exitset to make exit from the exec
1593 system call an event of interest to stop on, and then simply
1594 returns. The child does the exec, the system call returns, and
1595 the child stops at the first instruction, ready for the gdb
1596 parent process to take control of it.
1597
1598 NOTE
1599
1600 We need to use all local variables since the child may be sharing
1601 it's data space with the parent, if vfork was used rather than
1602 fork.
1603
1604 Also note that we want to turn off the inherit-on-fork flag in
1605 the child process so that any grand-children start with all
1606 tracing flags cleared.
1607 */
1608
1609 static void
1610 proc_set_exec_trap ()
1611 {
1612 sysset_t exitset;
1613 sysset_t entryset;
1614 auto char procname[32];
1615 int fd;
1616
1617 sprintf (procname, PROC_NAME_FMT, getpid ());
1618 if ((fd = open (procname, O_RDWR)) < 0)
1619 {
1620 perror (procname);
1621 gdb_flush (gdb_stderr);
1622 _exit (127);
1623 }
1624 premptyset (&exitset);
1625 premptyset (&entryset);
1626
1627 #ifdef PIOCSSPCACT
1628 /* Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
1629 exits from exec system calls because of the user level loader. */
1630 {
1631 int prfs_flags;
1632
1633 if (ioctl (fd, PIOCGSPCACT, &prfs_flags) < 0)
1634 {
1635 perror (procname);
1636 gdb_flush (gdb_stderr);
1637 _exit (127);
1638 }
1639 prfs_flags |= PRFS_STOPEXEC;
1640 if (ioctl (fd, PIOCSSPCACT, &prfs_flags) < 0)
1641 {
1642 perror (procname);
1643 gdb_flush (gdb_stderr);
1644 _exit (127);
1645 }
1646 }
1647 #else
1648 /* GW: Rationale...
1649 Not all systems with /proc have all the exec* syscalls with the same
1650 names. On the SGI, for example, there is no SYS_exec, but there
1651 *is* a SYS_execv. So, we try to account for that. */
1652
1653 #ifdef SYS_exec
1654 praddset (&exitset, SYS_exec);
1655 #endif
1656 #ifdef SYS_execve
1657 praddset (&exitset, SYS_execve);
1658 #endif
1659 #ifdef SYS_execv
1660 praddset (&exitset, SYS_execv);
1661 #endif
1662
1663 if (ioctl (fd, PIOCSEXIT, &exitset) < 0)
1664 {
1665 perror (procname);
1666 gdb_flush (gdb_stderr);
1667 _exit (127);
1668 }
1669 #endif
1670
1671 praddset (&entryset, SYS_exit);
1672
1673 if (ioctl (fd, PIOCSENTRY, &entryset) < 0)
1674 {
1675 perror (procname);
1676 gdb_flush (gdb_stderr);
1677 _exit (126);
1678 }
1679
1680 /* Turn off inherit-on-fork flag so that all grand-children of gdb
1681 start with tracing flags cleared. */
1682
1683 #if defined (PIOCRESET) /* New method */
1684 {
1685 long pr_flags;
1686 pr_flags = PR_FORK;
1687 ioctl (fd, PIOCRESET, &pr_flags);
1688 }
1689 #else
1690 #if defined (PIOCRFORK) /* Original method */
1691 ioctl (fd, PIOCRFORK, NULL);
1692 #endif
1693 #endif
1694
1695 /* Turn on run-on-last-close flag so that this process will not hang
1696 if GDB goes away for some reason. */
1697
1698 #if defined (PIOCSET) /* New method */
1699 {
1700 long pr_flags;
1701 pr_flags = PR_RLC;
1702 (void) ioctl (fd, PIOCSET, &pr_flags);
1703 }
1704 #else
1705 #if defined (PIOCSRLC) /* Original method */
1706 (void) ioctl (fd, PIOCSRLC, 0);
1707 #endif
1708 #endif
1709 }
1710
1711 /*
1712
1713 GLOBAL FUNCTION
1714
1715 proc_iterate_over_mappings -- call function for every mapped space
1716
1717 SYNOPSIS
1718
1719 int proc_iterate_over_mappings (int (*func)())
1720
1721 DESCRIPTION
1722
1723 Given a pointer to a function, call that function for every
1724 mapped address space, passing it an open file descriptor for
1725 the file corresponding to that mapped address space (if any)
1726 and the base address of the mapped space. Quit when we hit
1727 the end of the mappings or the function returns nonzero.
1728 */
1729
1730 int
1731 proc_iterate_over_mappings (func)
1732 int (*func) PARAMS ((int, CORE_ADDR));
1733 {
1734 int nmap;
1735 int fd;
1736 int funcstat = 0;
1737 struct prmap *prmaps;
1738 struct prmap *prmap;
1739 struct procinfo *pi;
1740
1741 pi = current_procinfo;
1742
1743 if (ioctl (pi->fd, PIOCNMAP, &nmap) == 0)
1744 {
1745 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
1746 if (ioctl (pi->fd, PIOCMAP, prmaps) == 0)
1747 {
1748 for (prmap = prmaps; prmap -> pr_size && funcstat == 0; ++prmap)
1749 {
1750 fd = proc_address_to_fd (pi, (CORE_ADDR) prmap -> pr_vaddr, 0);
1751 funcstat = (*func) (fd, (CORE_ADDR) prmap -> pr_vaddr);
1752 close (fd);
1753 }
1754 }
1755 }
1756 return (funcstat);
1757 }
1758
1759 #if 0 /* Currently unused */
1760 /*
1761
1762 GLOBAL FUNCTION
1763
1764 proc_base_address -- find base address for segment containing address
1765
1766 SYNOPSIS
1767
1768 CORE_ADDR proc_base_address (CORE_ADDR addr)
1769
1770 DESCRIPTION
1771
1772 Given an address of a location in the inferior, find and return
1773 the base address of the mapped segment containing that address.
1774
1775 This is used for example, by the shared library support code,
1776 where we have the pc value for some location in the shared library
1777 where we are stopped, and need to know the base address of the
1778 segment containing that address.
1779 */
1780
1781 CORE_ADDR
1782 proc_base_address (addr)
1783 CORE_ADDR addr;
1784 {
1785 int nmap;
1786 struct prmap *prmaps;
1787 struct prmap *prmap;
1788 CORE_ADDR baseaddr = 0;
1789 struct procinfo *pi;
1790
1791 pi = current_procinfo;
1792
1793 if (ioctl (pi->fd, PIOCNMAP, &nmap) == 0)
1794 {
1795 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
1796 if (ioctl (pi->fd, PIOCMAP, prmaps) == 0)
1797 {
1798 for (prmap = prmaps; prmap -> pr_size; ++prmap)
1799 {
1800 if ((prmap -> pr_vaddr <= (caddr_t) addr) &&
1801 (prmap -> pr_vaddr + prmap -> pr_size > (caddr_t) addr))
1802 {
1803 baseaddr = (CORE_ADDR) prmap -> pr_vaddr;
1804 break;
1805 }
1806 }
1807 }
1808 }
1809 return (baseaddr);
1810 }
1811
1812 #endif /* 0 */
1813
1814 /*
1815
1816 LOCAL FUNCTION
1817
1818 proc_address_to_fd -- return open fd for file mapped to address
1819
1820 SYNOPSIS
1821
1822 int proc_address_to_fd (struct procinfo *pi, CORE_ADDR addr, complain)
1823
1824 DESCRIPTION
1825
1826 Given an address in the current inferior's address space, use the
1827 /proc interface to find an open file descriptor for the file that
1828 this address was mapped in from. Return -1 if there is no current
1829 inferior. Print a warning message if there is an inferior but
1830 the address corresponds to no file (IE a bogus address).
1831
1832 */
1833
1834 static int
1835 proc_address_to_fd (pi, addr, complain)
1836 struct procinfo *pi;
1837 CORE_ADDR addr;
1838 int complain;
1839 {
1840 int fd = -1;
1841
1842 if ((fd = ioctl (pi->fd, PIOCOPENM, (caddr_t *) &addr)) < 0)
1843 {
1844 if (complain)
1845 {
1846 print_sys_errmsg (pi->pathname, errno);
1847 warning ("can't find mapped file for address 0x%x", addr);
1848 }
1849 }
1850 return (fd);
1851 }
1852
1853
1854 /* Attach to process PID, then initialize for debugging it
1855 and wait for the trace-trap that results from attaching. */
1856
1857 static void
1858 procfs_attach (args, from_tty)
1859 char *args;
1860 int from_tty;
1861 {
1862 char *exec_file;
1863 int pid;
1864
1865 if (!args)
1866 error_no_arg ("process-id to attach");
1867
1868 pid = atoi (args);
1869
1870 if (pid == getpid()) /* Trying to masturbate? */
1871 error ("I refuse to debug myself!");
1872
1873 if (from_tty)
1874 {
1875 exec_file = (char *) get_exec_file (0);
1876
1877 if (exec_file)
1878 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file, target_pid_to_str (pid));
1879 else
1880 printf_unfiltered ("Attaching to %s\n", target_pid_to_str (pid));
1881
1882 gdb_flush (gdb_stdout);
1883 }
1884
1885 do_attach (pid);
1886 inferior_pid = pid;
1887 push_target (&procfs_ops);
1888 }
1889
1890
1891 /* Take a program previously attached to and detaches it.
1892 The program resumes execution and will no longer stop
1893 on signals, etc. We'd better not have left any breakpoints
1894 in the program or it'll die when it hits one. For this
1895 to work, it may be necessary for the process to have been
1896 previously attached. It *might* work if the program was
1897 started via the normal ptrace (PTRACE_TRACEME). */
1898
1899 static void
1900 procfs_detach (args, from_tty)
1901 char *args;
1902 int from_tty;
1903 {
1904 int siggnal = 0;
1905
1906 if (from_tty)
1907 {
1908 char *exec_file = get_exec_file (0);
1909 if (exec_file == 0)
1910 exec_file = "";
1911 printf_unfiltered ("Detaching from program: %s %s\n",
1912 exec_file, target_pid_to_str (inferior_pid));
1913 gdb_flush (gdb_stdout);
1914 }
1915 if (args)
1916 siggnal = atoi (args);
1917
1918 do_detach (siggnal);
1919 inferior_pid = 0;
1920 unpush_target (&procfs_ops); /* Pop out of handling an inferior */
1921 }
1922
1923 /* Get ready to modify the registers array. On machines which store
1924 individual registers, this doesn't need to do anything. On machines
1925 which store all the registers in one fell swoop, this makes sure
1926 that registers contains all the registers from the program being
1927 debugged. */
1928
1929 static void
1930 procfs_prepare_to_store ()
1931 {
1932 #ifdef CHILD_PREPARE_TO_STORE
1933 CHILD_PREPARE_TO_STORE ();
1934 #endif
1935 }
1936
1937 /* Print status information about what we're accessing. */
1938
1939 static void
1940 procfs_files_info (ignore)
1941 struct target_ops *ignore;
1942 {
1943 printf_unfiltered ("\tUsing the running image of %s %s via /proc.\n",
1944 attach_flag? "attached": "child", target_pid_to_str (inferior_pid));
1945 }
1946
1947 /* ARGSUSED */
1948 static void
1949 procfs_open (arg, from_tty)
1950 char *arg;
1951 int from_tty;
1952 {
1953 error ("Use the \"run\" command to start a Unix child process.");
1954 }
1955
1956 /*
1957
1958 LOCAL FUNCTION
1959
1960 do_attach -- attach to an already existing process
1961
1962 SYNOPSIS
1963
1964 int do_attach (int pid)
1965
1966 DESCRIPTION
1967
1968 Attach to an already existing process with the specified process
1969 id. If the process is not already stopped, query whether to
1970 stop it or not.
1971
1972 NOTES
1973
1974 The option of stopping at attach time is specific to the /proc
1975 versions of gdb. Versions using ptrace force the attachee
1976 to stop. (I have changed this version to do so, too. All you
1977 have to do is "continue" to make it go on. -- gnu@cygnus.com)
1978
1979 */
1980
1981 static int
1982 do_attach (pid)
1983 int pid;
1984 {
1985 int result;
1986 struct procinfo *pi;
1987
1988 pi = (struct procinfo *) xmalloc (sizeof (struct procinfo));
1989
1990 if (!open_proc_file (pid, pi, O_RDWR))
1991 {
1992 free (pi);
1993 perror_with_name (pi->pathname);
1994 /* NOTREACHED */
1995 }
1996
1997 /* Add new process to process info list */
1998
1999 pi->next = procinfo_list;
2000 procinfo_list = pi;
2001
2002 add_fd (pi); /* Add to list for poll/select */
2003
2004 /* Get current status of process and if it is not already stopped,
2005 then stop it. Remember whether or not it was stopped when we first
2006 examined it. */
2007
2008 if (ioctl (pi->fd, PIOCSTATUS, &pi->prstatus) < 0)
2009 {
2010 print_sys_errmsg (pi->pathname, errno);
2011 close_proc_file (pi);
2012 error ("PIOCSTATUS failed");
2013 }
2014 if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
2015 {
2016 pi->was_stopped = 1;
2017 }
2018 else
2019 {
2020 pi->was_stopped = 0;
2021 if (1 || query ("Process is currently running, stop it? "))
2022 {
2023 /* Make it run again when we close it. */
2024 #if defined (PIOCSET) /* New method */
2025 {
2026 long pr_flags;
2027 pr_flags = PR_RLC;
2028 result = ioctl (pi->fd, PIOCSET, &pr_flags);
2029 }
2030 #else
2031 #if defined (PIOCSRLC) /* Original method */
2032 result = ioctl (pi->fd, PIOCSRLC, 0);
2033 #endif
2034 #endif
2035 if (result < 0)
2036 {
2037 print_sys_errmsg (pi->pathname, errno);
2038 close_proc_file (pi);
2039 error ("PIOCSRLC or PIOCSET failed");
2040 }
2041 if (ioctl (pi->fd, PIOCSTOP, &pi->prstatus) < 0)
2042 {
2043 print_sys_errmsg (pi->pathname, errno);
2044 close_proc_file (pi);
2045 error ("PIOCSTOP failed");
2046 }
2047 pi->nopass_next_sigstop = 1;
2048 }
2049 else
2050 {
2051 printf_unfiltered ("Ok, gdb will wait for %s to stop.\n", target_pid_to_str (pid));
2052 }
2053 }
2054
2055 /* Remember some things about the inferior that we will, or might, change
2056 so that we can restore them when we detach. */
2057
2058 ioctl (pi->fd, PIOCGTRACE, &pi->saved_trace);
2059 ioctl (pi->fd, PIOCGHOLD, &pi->saved_sighold);
2060 ioctl (pi->fd, PIOCGFAULT, &pi->saved_fltset);
2061 ioctl (pi->fd, PIOCGENTRY, &pi->saved_entryset);
2062 ioctl (pi->fd, PIOCGEXIT, &pi->saved_exitset);
2063
2064 /* Set up trace and fault sets, as gdb expects them. */
2065
2066 memset (&pi->prrun, 0, sizeof (pi->prrun));
2067 prfillset (&pi->prrun.pr_trace);
2068 procfs_notice_signals (pid);
2069 prfillset (&pi->prrun.pr_fault);
2070 prdelset (&pi->prrun.pr_fault, FLTPAGE);
2071
2072 #ifdef PROCFS_DONT_TRACE_FAULTS
2073 premptyset (&pi->prrun.pr_fault);
2074 #endif
2075
2076 if (ioctl (pi->fd, PIOCSFAULT, &pi->prrun.pr_fault))
2077 {
2078 print_sys_errmsg ("PIOCSFAULT failed", errno);
2079 }
2080 if (ioctl (pi->fd, PIOCSTRACE, &pi->prrun.pr_trace))
2081 {
2082 print_sys_errmsg ("PIOCSTRACE failed", errno);
2083 }
2084 attach_flag = 1;
2085 return (pid);
2086 }
2087
2088 /*
2089
2090 LOCAL FUNCTION
2091
2092 do_detach -- detach from an attached-to process
2093
2094 SYNOPSIS
2095
2096 void do_detach (int signal)
2097
2098 DESCRIPTION
2099
2100 Detach from the current attachee.
2101
2102 If signal is non-zero, the attachee is started running again and sent
2103 the specified signal.
2104
2105 If signal is zero and the attachee was not already stopped when we
2106 attached to it, then we make it runnable again when we detach.
2107
2108 Otherwise, we query whether or not to make the attachee runnable
2109 again, since we may simply want to leave it in the state it was in
2110 when we attached.
2111
2112 We report any problems, but do not consider them errors, since we
2113 MUST detach even if some things don't seem to go right. This may not
2114 be the ideal situation. (FIXME).
2115 */
2116
2117 static void
2118 do_detach (signal)
2119 int signal;
2120 {
2121 int result;
2122 struct procinfo *pi;
2123
2124 pi = current_procinfo;
2125
2126 if (signal)
2127 {
2128 set_proc_siginfo (pi, signal);
2129 }
2130 if (ioctl (pi->fd, PIOCSEXIT, &pi->saved_exitset) < 0)
2131 {
2132 print_sys_errmsg (pi->pathname, errno);
2133 printf_unfiltered ("PIOCSEXIT failed.\n");
2134 }
2135 if (ioctl (pi->fd, PIOCSENTRY, &pi->saved_entryset) < 0)
2136 {
2137 print_sys_errmsg (pi->pathname, errno);
2138 printf_unfiltered ("PIOCSENTRY failed.\n");
2139 }
2140 if (ioctl (pi->fd, PIOCSTRACE, &pi->saved_trace) < 0)
2141 {
2142 print_sys_errmsg (pi->pathname, errno);
2143 printf_unfiltered ("PIOCSTRACE failed.\n");
2144 }
2145 if (ioctl (pi->fd, PIOCSHOLD, &pi->saved_sighold) < 0)
2146 {
2147 print_sys_errmsg (pi->pathname, errno);
2148 printf_unfiltered ("PIOSCHOLD failed.\n");
2149 }
2150 if (ioctl (pi->fd, PIOCSFAULT, &pi->saved_fltset) < 0)
2151 {
2152 print_sys_errmsg (pi->pathname, errno);
2153 printf_unfiltered ("PIOCSFAULT failed.\n");
2154 }
2155 if (ioctl (pi->fd, PIOCSTATUS, &pi->prstatus) < 0)
2156 {
2157 print_sys_errmsg (pi->pathname, errno);
2158 printf_unfiltered ("PIOCSTATUS failed.\n");
2159 }
2160 else
2161 {
2162 if (signal || (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)))
2163 {
2164 if (signal || !pi->was_stopped ||
2165 query ("Was stopped when attached, make it runnable again? "))
2166 {
2167 /* Clear any pending signal if we want to detach without
2168 a signal. */
2169 if (signal == 0)
2170 set_proc_siginfo (pi, signal);
2171
2172 /* Clear any fault that might have stopped it. */
2173 if (ioctl (pi->fd, PIOCCFAULT, 0))
2174 {
2175 print_sys_errmsg (pi->pathname, errno);
2176 printf_unfiltered ("PIOCCFAULT failed.\n");
2177 }
2178
2179 /* Make it run again when we close it. */
2180 #if defined (PIOCSET) /* New method */
2181 {
2182 long pr_flags;
2183 pr_flags = PR_RLC;
2184 result = ioctl (pi->fd, PIOCSET, &pr_flags);
2185 }
2186 #else
2187 #if defined (PIOCSRLC) /* Original method */
2188 result = ioctl (pi->fd, PIOCSRLC, 0);
2189 #endif
2190 #endif
2191 if (result)
2192 {
2193 print_sys_errmsg (pi->pathname, errno);
2194 printf_unfiltered ("PIOCSRLC or PIOCSET failed.\n");
2195 }
2196 }
2197 }
2198 }
2199 close_proc_file (pi);
2200 attach_flag = 0;
2201 }
2202
2203 /* emulate wait() as much as possible.
2204 Wait for child to do something. Return pid of child, or -1 in case
2205 of error; store status in *OURSTATUS.
2206
2207 Not sure why we can't
2208 just use wait(), but it seems to have problems when applied to a
2209 process being controlled with the /proc interface.
2210
2211 We have a race problem here with no obvious solution. We need to let
2212 the inferior run until it stops on an event of interest, which means
2213 that we need to use the PIOCWSTOP ioctl. However, we cannot use this
2214 ioctl if the process is already stopped on something that is not an
2215 event of interest, or the call will hang indefinitely. Thus we first
2216 use PIOCSTATUS to see if the process is not stopped. If not, then we
2217 use PIOCWSTOP. But during the window between the two, if the process
2218 stops for any reason that is not an event of interest (such as a job
2219 control signal) then gdb will hang. One possible workaround is to set
2220 an alarm to wake up every minute of so and check to see if the process
2221 is still running, and if so, then reissue the PIOCWSTOP. But this is
2222 a real kludge, so has not been implemented. FIXME: investigate
2223 alternatives.
2224
2225 FIXME: Investigate why wait() seems to have problems with programs
2226 being control by /proc routines. */
2227
2228 static int
2229 procfs_wait (pid, ourstatus)
2230 int pid;
2231 struct target_waitstatus *ourstatus;
2232 {
2233 short what;
2234 short why;
2235 int statval = 0;
2236 int checkerr = 0;
2237 int rtnval = -1;
2238 struct procinfo *pi;
2239
2240 if (pid != -1) /* Non-specific process? */
2241 pi = NULL;
2242 else
2243 for (pi = procinfo_list; pi; pi = pi->next)
2244 if (pi->had_event)
2245 break;
2246
2247 if (!pi)
2248 {
2249 wait_again:
2250
2251 pi = wait_fd ();
2252 }
2253
2254 if (pid != -1)
2255 for (pi = procinfo_list; pi; pi = pi->next)
2256 if (pi->pid == pid && pi->had_event)
2257 break;
2258
2259 if (!pi && !checkerr)
2260 goto wait_again;
2261
2262 if (!checkerr && !(pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)))
2263 {
2264 if (ioctl (pi->fd, PIOCWSTOP, &pi->prstatus) < 0)
2265 {
2266 checkerr++;
2267 }
2268 }
2269 if (checkerr)
2270 {
2271 if (errno == ENOENT)
2272 {
2273 rtnval = wait (&statval);
2274 if (rtnval != inferior_pid)
2275 {
2276 print_sys_errmsg (pi->pathname, errno);
2277 error ("PIOCWSTOP, wait failed, returned %d", rtnval);
2278 /* NOTREACHED */
2279 }
2280 }
2281 else
2282 {
2283 print_sys_errmsg (pi->pathname, errno);
2284 error ("PIOCSTATUS or PIOCWSTOP failed.");
2285 /* NOTREACHED */
2286 }
2287 }
2288 else if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
2289 {
2290 rtnval = pi->prstatus.pr_pid;
2291 why = pi->prstatus.pr_why;
2292 what = pi->prstatus.pr_what;
2293
2294 switch (why)
2295 {
2296 case PR_SIGNALLED:
2297 statval = (what << 8) | 0177;
2298 break;
2299 case PR_SYSENTRY:
2300 if (what != SYS_exit)
2301 error ("PR_SYSENTRY, unknown system call %d", what);
2302
2303 pi->prrun.pr_flags = PRCFAULT;
2304
2305 if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
2306 perror_with_name (pi->pathname);
2307
2308 rtnval = wait (&statval);
2309
2310 break;
2311 case PR_SYSEXIT:
2312 switch (what)
2313 {
2314 #ifdef SYS_exec
2315 case SYS_exec:
2316 #endif
2317 #ifdef SYS_execve
2318 case SYS_execve:
2319 #endif
2320 #ifdef SYS_execv
2321 case SYS_execv:
2322 #endif
2323 statval = (SIGTRAP << 8) | 0177;
2324 break;
2325 #ifdef SYS_sproc
2326 case SYS_sproc:
2327 /* We've just detected the completion of an sproc system call. Now we need to
2328 setup a procinfo struct for this thread, and notify the thread system of the
2329 new arrival. */
2330
2331 /* If sproc failed, then nothing interesting happened. Continue the process and
2332 go back to sleep. */
2333
2334 if (pi->prstatus.pr_errno != 0)
2335 {
2336 pi->prrun.pr_flags &= PRSTEP;
2337 pi->prrun.pr_flags |= PRCFAULT;
2338
2339 if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
2340 perror_with_name (pi->pathname);
2341
2342 goto wait_again;
2343 }
2344
2345 /* At this point, the new thread is stopped at it's first instruction, and
2346 the parent is stopped at the exit from sproc. */
2347
2348 /* Notify the caller of the arrival of a new thread. */
2349 create_procinfo (pi->prstatus.pr_rval1);
2350
2351 rtnval = pi->prstatus.pr_rval1;
2352 statval = (SIGTRAP << 8) | 0177;
2353
2354 break;
2355 case SYS_fork:
2356 #ifdef SYS_vfork
2357 case SYS_vfork:
2358 #endif
2359 /* At this point, we've detected the completion of a fork (or vfork) call in
2360 our child. The grandchild is also stopped because we set inherit-on-fork
2361 earlier. (Note that nobody has the grandchilds' /proc file open at this
2362 point.) We will release the grandchild from the debugger by opening it's
2363 /proc file and then closing it. Since run-on-last-close is set, the
2364 grandchild continues on its' merry way. */
2365
2366 {
2367 struct procinfo *pitemp;
2368
2369 pitemp = create_procinfo (pi->prstatus.pr_rval1);
2370 if (pitemp)
2371 close_proc_file (pitemp);
2372
2373 if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
2374 perror_with_name (pi->pathname);
2375 }
2376 goto wait_again;
2377 #endif /* SYS_sproc */
2378
2379 default:
2380 error ("PIOCSTATUS (PR_SYSEXIT): Unknown system call %d", what);
2381 }
2382 break;
2383 case PR_REQUESTED:
2384 statval = (SIGSTOP << 8) | 0177;
2385 break;
2386 case PR_JOBCONTROL:
2387 statval = (what << 8) | 0177;
2388 break;
2389 case PR_FAULTED:
2390 switch (what)
2391 {
2392 #ifdef FLTWATCH
2393 case FLTWATCH:
2394 statval = (SIGTRAP << 8) | 0177;
2395 break;
2396 #endif
2397 #ifdef FLTKWATCH
2398 case FLTKWATCH:
2399 statval = (SIGTRAP << 8) | 0177;
2400 break;
2401 #endif
2402 #ifndef FAULTED_USE_SIGINFO
2403 /* Irix, contrary to the documentation, fills in 0 for si_signo.
2404 Solaris fills in si_signo. I'm not sure about others. */
2405 case FLTPRIV:
2406 case FLTILL:
2407 statval = (SIGILL << 8) | 0177;
2408 break;
2409 case FLTBPT:
2410 case FLTTRACE:
2411 statval = (SIGTRAP << 8) | 0177;
2412 break;
2413 case FLTSTACK:
2414 case FLTACCESS:
2415 case FLTBOUNDS:
2416 statval = (SIGSEGV << 8) | 0177;
2417 break;
2418 case FLTIOVF:
2419 case FLTIZDIV:
2420 case FLTFPE:
2421 statval = (SIGFPE << 8) | 0177;
2422 break;
2423 case FLTPAGE: /* Recoverable page fault */
2424 #endif /* not FAULTED_USE_SIGINFO */
2425 default:
2426 /* Use the signal which the kernel assigns. This is better than
2427 trying to second-guess it from the fault. In fact, I suspect
2428 that FLTACCESS can be either SIGSEGV or SIGBUS. */
2429 statval = ((pi->prstatus.pr_info.si_signo) << 8) | 0177;
2430 break;
2431 }
2432 break;
2433 default:
2434 error ("PIOCWSTOP, unknown why %d, what %d", why, what);
2435 }
2436 /* Stop all the other threads when any of them stops. */
2437
2438 {
2439 struct procinfo *procinfo;
2440
2441 for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
2442 {
2443 if (!procinfo->had_event)
2444 if (ioctl (procinfo->fd, PIOCSTOP, &procinfo->prstatus) < 0)
2445 {
2446 print_sys_errmsg (procinfo->pathname, errno);
2447 error ("PIOCSTOP failed");
2448 }
2449 }
2450 }
2451 }
2452 else
2453 {
2454 error ("PIOCWSTOP, stopped for unknown/unhandled reason, flags %#x",
2455 pi->prstatus.pr_flags);
2456 }
2457
2458 store_waitstatus (ourstatus, statval);
2459
2460 if (rtnval == -1) /* No more children to wait for */
2461 {
2462 fprintf_unfiltered (gdb_stderr, "Child process unexpectedly missing.\n");
2463 /* Claim it exited with unknown signal. */
2464 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
2465 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
2466 return rtnval;
2467 }
2468
2469 pi->had_event = 0; /* Indicate that we've seen this one */
2470 return (rtnval);
2471 }
2472
2473 /*
2474
2475 LOCAL FUNCTION
2476
2477 set_proc_siginfo - set a process's current signal info
2478
2479 SYNOPSIS
2480
2481 void set_proc_siginfo (struct procinfo *pip, int signo);
2482
2483 DESCRIPTION
2484
2485 Given a pointer to a process info struct in PIP and a signal number
2486 in SIGNO, set the process's current signal and its associated signal
2487 information. The signal will be delivered to the process immediately
2488 after execution is resumed, even if it is being held. In addition,
2489 this particular delivery will not cause another PR_SIGNALLED stop
2490 even if the signal is being traced.
2491
2492 If we are not delivering the same signal that the prstatus siginfo
2493 struct contains information about, then synthesize a siginfo struct
2494 to match the signal we are doing to deliver, make it of the type
2495 "generated by a user process", and send this synthesized copy. When
2496 used to set the inferior's signal state, this will be required if we
2497 are not currently stopped because of a traced signal, or if we decide
2498 to continue with a different signal.
2499
2500 Note that when continuing the inferior from a stop due to receipt
2501 of a traced signal, we either have set PRCSIG to clear the existing
2502 signal, or we have to call this function to do a PIOCSSIG with either
2503 the existing siginfo struct from pr_info, or one we have synthesized
2504 appropriately for the signal we want to deliver. Otherwise if the
2505 signal is still being traced, the inferior will immediately stop
2506 again.
2507
2508 See siginfo(5) for more details.
2509 */
2510
2511 static void
2512 set_proc_siginfo (pip, signo)
2513 struct procinfo *pip;
2514 int signo;
2515 {
2516 struct siginfo newsiginfo;
2517 struct siginfo *sip;
2518
2519 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
2520 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
2521 receives a PIOCSSIG with a signal identical to the current signal,
2522 it messes up the current signal. Work around the kernel bug. */
2523 if (signo == pip -> prstatus.pr_cursig)
2524 return;
2525 #endif
2526
2527 if (signo == pip -> prstatus.pr_info.si_signo)
2528 {
2529 sip = &pip -> prstatus.pr_info;
2530 }
2531 else
2532 {
2533 memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
2534 sip = &newsiginfo;
2535 sip -> si_signo = signo;
2536 sip -> si_code = 0;
2537 sip -> si_errno = 0;
2538 sip -> si_pid = getpid ();
2539 sip -> si_uid = getuid ();
2540 }
2541 if (ioctl (pip -> fd, PIOCSSIG, sip) < 0)
2542 {
2543 print_sys_errmsg (pip -> pathname, errno);
2544 warning ("PIOCSSIG failed");
2545 }
2546 }
2547
2548 /* Resume execution of process PID. If STEP is nozero, then
2549 just single step it. If SIGNAL is nonzero, restart it with that
2550 signal activated. */
2551
2552 static void
2553 procfs_resume (pid, step, signo)
2554 int pid;
2555 int step;
2556 enum target_signal signo;
2557 {
2558 int signal_to_pass;
2559 struct procinfo *pi, *procinfo;
2560
2561 pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
2562
2563 errno = 0;
2564 pi->prrun.pr_flags = PRSTRACE | PRSFAULT | PRCFAULT;
2565
2566 #if 0
2567 /* It should not be necessary. If the user explicitly changes the value,
2568 value_assign calls write_register_bytes, which writes it. */
2569 /* It may not be absolutely necessary to specify the PC value for
2570 restarting, but to be safe we use the value that gdb considers
2571 to be current. One case where this might be necessary is if the
2572 user explicitly changes the PC value that gdb considers to be
2573 current. FIXME: Investigate if this is necessary or not. */
2574
2575 #ifdef PRSVADDR_BROKEN
2576 /* Can't do this under Solaris running on a Sparc, as there seems to be no
2577 place to put nPC. In fact, if you use this, nPC seems to be set to some
2578 random garbage. We have to rely on the fact that PC and nPC have been
2579 written previously via PIOCSREG during a register flush. */
2580
2581 pi->prrun.pr_vaddr = (caddr_t) *(int *) &registers[REGISTER_BYTE (PC_REGNUM)];
2582 pi->prrun.pr_flags != PRSVADDR;
2583 #endif
2584 #endif
2585
2586 if (signo == TARGET_SIGNAL_STOP && pi->nopass_next_sigstop)
2587 /* When attaching to a child process, if we forced it to stop with
2588 a PIOCSTOP, then we will have set the nopass_next_sigstop flag.
2589 Upon resuming the first time after such a stop, we explicitly
2590 inhibit sending it another SIGSTOP, which would be the normal
2591 result of default signal handling. One potential drawback to
2592 this is that we will also ignore any attempt to by the user
2593 to explicitly continue after the attach with a SIGSTOP. Ultimately
2594 this problem should be dealt with by making the routines that
2595 deal with the inferior a little smarter, and possibly even allow
2596 an inferior to continue running at the same time as gdb. (FIXME?) */
2597 signal_to_pass = 0;
2598 else if (signo == TARGET_SIGNAL_TSTP
2599 && pi->prstatus.pr_cursig == SIGTSTP
2600 && pi->prstatus.pr_action.sa_handler == SIG_DFL)
2601
2602 /* We are about to pass the inferior a SIGTSTP whose action is
2603 SIG_DFL. The SIG_DFL action for a SIGTSTP is to stop
2604 (notifying the parent via wait()), and then keep going from the
2605 same place when the parent is ready for you to keep going. So
2606 under the debugger, it should do nothing (as if the program had
2607 been stopped and then later resumed. Under ptrace, this
2608 happens for us, but under /proc, the system obligingly stops
2609 the process, and wait_for_inferior would have no way of
2610 distinguishing that type of stop (which indicates that we
2611 should just start it again), with a stop due to the pr_trace
2612 field of the prrun_t struct.
2613
2614 Note that if the SIGTSTP is being caught, we *do* need to pass it,
2615 because the handler needs to get executed. */
2616 signal_to_pass = 0;
2617 else
2618 signal_to_pass = target_signal_to_host (signo);
2619
2620 if (signal_to_pass)
2621 {
2622 set_proc_siginfo (pi, signal_to_pass);
2623 }
2624 else
2625 {
2626 pi->prrun.pr_flags |= PRCSIG;
2627 }
2628 pi->nopass_next_sigstop = 0;
2629 if (step)
2630 {
2631 pi->prrun.pr_flags |= PRSTEP;
2632 }
2633 if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
2634 {
2635 perror_with_name (pi->pathname);
2636 /* NOTREACHED */
2637 }
2638
2639 pi->had_event = 0;
2640
2641 /* Continue all the other threads that haven't had an event of
2642 interest. */
2643
2644 if (pid == -1)
2645 for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
2646 {
2647 if (pi != procinfo && !procinfo->had_event)
2648 {
2649 procinfo->prrun.pr_flags &= PRSTEP;
2650 procinfo->prrun.pr_flags |= PRCFAULT | PRCSIG;
2651 ioctl (procinfo->fd, PIOCSTATUS, &procinfo->prstatus);
2652 if (ioctl (procinfo->fd, PIOCRUN, &procinfo->prrun) < 0)
2653 {
2654 if (ioctl (procinfo->fd, PIOCSTATUS, &procinfo->prstatus) < 0)
2655 {
2656 fprintf_unfiltered(gdb_stderr, "PIOCSTATUS failed, errno=%d\n", errno);
2657 }
2658 print_sys_errmsg (procinfo->pathname, errno);
2659 error ("PIOCRUN failed");
2660 }
2661 ioctl (procinfo->fd, PIOCSTATUS, &procinfo->prstatus);
2662 }
2663 }
2664 }
2665
2666 /*
2667
2668 LOCAL FUNCTION
2669
2670 procfs_fetch_registers -- fetch current registers from inferior
2671
2672 SYNOPSIS
2673
2674 void procfs_fetch_registers (int regno)
2675
2676 DESCRIPTION
2677
2678 Read the current values of the inferior's registers, both the
2679 general register set and floating point registers (if supported)
2680 and update gdb's idea of their current values.
2681
2682 */
2683
2684 static void
2685 procfs_fetch_registers (regno)
2686 int regno;
2687 {
2688 struct procinfo *pi;
2689
2690 pi = current_procinfo;
2691
2692 if (ioctl (pi->fd, PIOCGREG, &pi->gregset) != -1)
2693 {
2694 supply_gregset (&pi->gregset);
2695 }
2696 #if defined (FP0_REGNUM)
2697 if (ioctl (pi->fd, PIOCGFPREG, &pi->fpregset) != -1)
2698 {
2699 supply_fpregset (&pi->fpregset);
2700 }
2701 #endif
2702 }
2703
2704 /*
2705
2706 LOCAL FUNCTION
2707
2708 proc_init_failed - called whenever /proc access initialization
2709 fails
2710
2711 SYNOPSIS
2712
2713 static void proc_init_failed (struct procinfo *pi, char *why)
2714
2715 DESCRIPTION
2716
2717 This function is called whenever initialization of access to a /proc
2718 entry fails. It prints a suitable error message, does some cleanup,
2719 and then invokes the standard error processing routine which dumps
2720 us back into the command loop.
2721 */
2722
2723 static void
2724 proc_init_failed (pi, why)
2725 struct procinfo *pi;
2726 char *why;
2727 {
2728 print_sys_errmsg (pi->pathname, errno);
2729 kill (pi->pid, SIGKILL);
2730 close_proc_file (pi);
2731 error (why);
2732 /* NOTREACHED */
2733 }
2734
2735 /*
2736
2737 LOCAL FUNCTION
2738
2739 close_proc_file - close any currently open /proc entry
2740
2741 SYNOPSIS
2742
2743 static void close_proc_file (struct procinfo *pip)
2744
2745 DESCRIPTION
2746
2747 Close any currently open /proc entry and mark the process information
2748 entry as invalid. In order to ensure that we don't try to reuse any
2749 stale information, the pid, fd, and pathnames are explicitly
2750 invalidated, which may be overkill.
2751
2752 */
2753
2754 static void
2755 close_proc_file (pip)
2756 struct procinfo *pip;
2757 {
2758 struct procinfo *procinfo;
2759
2760 remove_fd (pip); /* Remove fd from poll/select list */
2761
2762 close (pip -> fd);
2763
2764 free (pip -> pathname);
2765
2766 /* Unlink pip from the procinfo chain. Note pip might not be on the list. */
2767
2768 if (procinfo_list == pip)
2769 procinfo_list = pip->next;
2770 else
2771 for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
2772 if (procinfo->next == pip)
2773 procinfo->next = pip->next;
2774
2775 free (pip);
2776 }
2777
2778 /*
2779
2780 LOCAL FUNCTION
2781
2782 open_proc_file - open a /proc entry for a given process id
2783
2784 SYNOPSIS
2785
2786 static int open_proc_file (int pid, struct procinfo *pip, int mode)
2787
2788 DESCRIPTION
2789
2790 Given a process id and a mode, close the existing open /proc
2791 entry (if any) and open one for the new process id, in the
2792 specified mode. Once it is open, then mark the local process
2793 information structure as valid, which guarantees that the pid,
2794 fd, and pathname fields match an open /proc entry. Returns
2795 zero if the open fails, nonzero otherwise.
2796
2797 Note that the pathname is left intact, even when the open fails,
2798 so that callers can use it to construct meaningful error messages
2799 rather than just "file open failed".
2800 */
2801
2802 static int
2803 open_proc_file (pid, pip, mode)
2804 int pid;
2805 struct procinfo *pip;
2806 int mode;
2807 {
2808 pip -> next = NULL;
2809 pip -> had_event = 0;
2810 pip -> pathname = xmalloc (32);
2811 pip -> pid = pid;
2812
2813 sprintf (pip -> pathname, PROC_NAME_FMT, pid);
2814 if ((pip -> fd = open (pip -> pathname, mode)) < 0)
2815 return 0;
2816
2817 return 1;
2818 }
2819
2820 static char *
2821 mappingflags (flags)
2822 long flags;
2823 {
2824 static char asciiflags[8];
2825
2826 strcpy (asciiflags, "-------");
2827 #if defined (MA_PHYS)
2828 if (flags & MA_PHYS) asciiflags[0] = 'd';
2829 #endif
2830 if (flags & MA_STACK) asciiflags[1] = 's';
2831 if (flags & MA_BREAK) asciiflags[2] = 'b';
2832 if (flags & MA_SHARED) asciiflags[3] = 's';
2833 if (flags & MA_READ) asciiflags[4] = 'r';
2834 if (flags & MA_WRITE) asciiflags[5] = 'w';
2835 if (flags & MA_EXEC) asciiflags[6] = 'x';
2836 return (asciiflags);
2837 }
2838
2839 static void
2840 info_proc_flags (pip, summary)
2841 struct procinfo *pip;
2842 int summary;
2843 {
2844 struct trans *transp;
2845
2846 printf_filtered ("%-32s", "Process status flags:");
2847 if (!summary)
2848 {
2849 printf_filtered ("\n\n");
2850 }
2851 for (transp = pr_flag_table; transp -> name != NULL; transp++)
2852 {
2853 if (pip -> prstatus.pr_flags & transp -> value)
2854 {
2855 if (summary)
2856 {
2857 printf_filtered ("%s ", transp -> name);
2858 }
2859 else
2860 {
2861 printf_filtered ("\t%-16s %s.\n", transp -> name, transp -> desc);
2862 }
2863 }
2864 }
2865 printf_filtered ("\n");
2866 }
2867
2868 static void
2869 info_proc_stop (pip, summary)
2870 struct procinfo *pip;
2871 int summary;
2872 {
2873 struct trans *transp;
2874 int why;
2875 int what;
2876
2877 why = pip -> prstatus.pr_why;
2878 what = pip -> prstatus.pr_what;
2879
2880 if (pip -> prstatus.pr_flags & PR_STOPPED)
2881 {
2882 printf_filtered ("%-32s", "Reason for stopping:");
2883 if (!summary)
2884 {
2885 printf_filtered ("\n\n");
2886 }
2887 for (transp = pr_why_table; transp -> name != NULL; transp++)
2888 {
2889 if (why == transp -> value)
2890 {
2891 if (summary)
2892 {
2893 printf_filtered ("%s ", transp -> name);
2894 }
2895 else
2896 {
2897 printf_filtered ("\t%-16s %s.\n",
2898 transp -> name, transp -> desc);
2899 }
2900 break;
2901 }
2902 }
2903
2904 /* Use the pr_why field to determine what the pr_what field means, and
2905 print more information. */
2906
2907 switch (why)
2908 {
2909 case PR_REQUESTED:
2910 /* pr_what is unused for this case */
2911 break;
2912 case PR_JOBCONTROL:
2913 case PR_SIGNALLED:
2914 if (summary)
2915 {
2916 printf_filtered ("%s ", signalname (what));
2917 }
2918 else
2919 {
2920 printf_filtered ("\t%-16s %s.\n", signalname (what),
2921 safe_strsignal (what));
2922 }
2923 break;
2924 case PR_SYSENTRY:
2925 if (summary)
2926 {
2927 printf_filtered ("%s ", syscallname (what));
2928 }
2929 else
2930 {
2931 printf_filtered ("\t%-16s %s.\n", syscallname (what),
2932 "Entered this system call");
2933 }
2934 break;
2935 case PR_SYSEXIT:
2936 if (summary)
2937 {
2938 printf_filtered ("%s ", syscallname (what));
2939 }
2940 else
2941 {
2942 printf_filtered ("\t%-16s %s.\n", syscallname (what),
2943 "Returned from this system call");
2944 }
2945 break;
2946 case PR_FAULTED:
2947 if (summary)
2948 {
2949 printf_filtered ("%s ",
2950 lookupname (faults_table, what, "fault"));
2951 }
2952 else
2953 {
2954 printf_filtered ("\t%-16s %s.\n",
2955 lookupname (faults_table, what, "fault"),
2956 lookupdesc (faults_table, what));
2957 }
2958 break;
2959 }
2960 printf_filtered ("\n");
2961 }
2962 }
2963
2964 static void
2965 info_proc_siginfo (pip, summary)
2966 struct procinfo *pip;
2967 int summary;
2968 {
2969 struct siginfo *sip;
2970
2971 if ((pip -> prstatus.pr_flags & PR_STOPPED) &&
2972 (pip -> prstatus.pr_why == PR_SIGNALLED ||
2973 pip -> prstatus.pr_why == PR_FAULTED))
2974 {
2975 printf_filtered ("%-32s", "Additional signal/fault info:");
2976 sip = &pip -> prstatus.pr_info;
2977 if (summary)
2978 {
2979 printf_filtered ("%s ", signalname (sip -> si_signo));
2980 if (sip -> si_errno > 0)
2981 {
2982 printf_filtered ("%s ", errnoname (sip -> si_errno));
2983 }
2984 if (sip -> si_code <= 0)
2985 {
2986 printf_filtered ("sent by %s, uid %d ",
2987 target_pid_to_str (sip -> si_pid),
2988 sip -> si_uid);
2989 }
2990 else
2991 {
2992 printf_filtered ("%s ", sigcodename (sip));
2993 if ((sip -> si_signo == SIGILL) ||
2994 (sip -> si_signo == SIGFPE) ||
2995 (sip -> si_signo == SIGSEGV) ||
2996 (sip -> si_signo == SIGBUS))
2997 {
2998 printf_filtered ("addr=%#lx ",
2999 (unsigned long) sip -> si_addr);
3000 }
3001 else if ((sip -> si_signo == SIGCHLD))
3002 {
3003 printf_filtered ("child %s, status %u ",
3004 target_pid_to_str (sip -> si_pid),
3005 sip -> si_status);
3006 }
3007 else if ((sip -> si_signo == SIGPOLL))
3008 {
3009 printf_filtered ("band %u ", sip -> si_band);
3010 }
3011 }
3012 }
3013 else
3014 {
3015 printf_filtered ("\n\n");
3016 printf_filtered ("\t%-16s %s.\n", signalname (sip -> si_signo),
3017 safe_strsignal (sip -> si_signo));
3018 if (sip -> si_errno > 0)
3019 {
3020 printf_filtered ("\t%-16s %s.\n",
3021 errnoname (sip -> si_errno),
3022 safe_strerror (sip -> si_errno));
3023 }
3024 if (sip -> si_code <= 0)
3025 {
3026 printf_filtered ("\t%-16u %s\n", sip -> si_pid, /* XXX need target_pid_to_str() */
3027 "PID of process sending signal");
3028 printf_filtered ("\t%-16u %s\n", sip -> si_uid,
3029 "UID of process sending signal");
3030 }
3031 else
3032 {
3033 printf_filtered ("\t%-16s %s.\n", sigcodename (sip),
3034 sigcodedesc (sip));
3035 if ((sip -> si_signo == SIGILL) ||
3036 (sip -> si_signo == SIGFPE))
3037 {
3038 printf_filtered ("\t%#-16lx %s.\n",
3039 (unsigned long) sip -> si_addr,
3040 "Address of faulting instruction");
3041 }
3042 else if ((sip -> si_signo == SIGSEGV) ||
3043 (sip -> si_signo == SIGBUS))
3044 {
3045 printf_filtered ("\t%#-16lx %s.\n",
3046 (unsigned long) sip -> si_addr,
3047 "Address of faulting memory reference");
3048 }
3049 else if ((sip -> si_signo == SIGCHLD))
3050 {
3051 printf_filtered ("\t%-16u %s.\n", sip -> si_pid, /* XXX need target_pid_to_str() */
3052 "Child process ID");
3053 printf_filtered ("\t%-16u %s.\n", sip -> si_status,
3054 "Child process exit value or signal");
3055 }
3056 else if ((sip -> si_signo == SIGPOLL))
3057 {
3058 printf_filtered ("\t%-16u %s.\n", sip -> si_band,
3059 "Band event for POLL_{IN,OUT,MSG}");
3060 }
3061 }
3062 }
3063 printf_filtered ("\n");
3064 }
3065 }
3066
3067 static void
3068 info_proc_syscalls (pip, summary)
3069 struct procinfo *pip;
3070 int summary;
3071 {
3072 int syscallnum;
3073
3074 if (!summary)
3075 {
3076
3077 #if 0 /* FIXME: Needs to use gdb-wide configured info about system calls. */
3078 if (pip -> prstatus.pr_flags & PR_ASLEEP)
3079 {
3080 int syscallnum = pip -> prstatus.pr_reg[R_D0];
3081 if (summary)
3082 {
3083 printf_filtered ("%-32s", "Sleeping in system call:");
3084 printf_filtered ("%s", syscallname (syscallnum));
3085 }
3086 else
3087 {
3088 printf_filtered ("Sleeping in system call '%s'.\n",
3089 syscallname (syscallnum));
3090 }
3091 }
3092 #endif
3093
3094 if (ioctl (pip -> fd, PIOCGENTRY, &pip -> entryset) < 0)
3095 {
3096 print_sys_errmsg (pip -> pathname, errno);
3097 error ("PIOCGENTRY failed");
3098 }
3099
3100 if (ioctl (pip -> fd, PIOCGEXIT, &pip -> exitset) < 0)
3101 {
3102 print_sys_errmsg (pip -> pathname, errno);
3103 error ("PIOCGEXIT failed");
3104 }
3105
3106 printf_filtered ("System call tracing information:\n\n");
3107
3108 printf_filtered ("\t%-12s %-8s %-8s\n",
3109 "System call",
3110 "Entry",
3111 "Exit");
3112 for (syscallnum = 0; syscallnum < MAX_SYSCALLS; syscallnum++)
3113 {
3114 QUIT;
3115 if (syscall_table[syscallnum] != NULL)
3116 {
3117 printf_filtered ("\t%-12s ", syscall_table[syscallnum]);
3118 printf_filtered ("%-8s ",
3119 prismember (&pip -> entryset, syscallnum)
3120 ? "on" : "off");
3121 printf_filtered ("%-8s ",
3122 prismember (&pip -> exitset, syscallnum)
3123 ? "on" : "off");
3124 printf_filtered ("\n");
3125 }
3126 }
3127 printf_filtered ("\n");
3128 }
3129 }
3130
3131 static char *
3132 signalname (signo)
3133 int signo;
3134 {
3135 const char *name;
3136 static char locbuf[32];
3137
3138 name = strsigno (signo);
3139 if (name == NULL)
3140 {
3141 sprintf (locbuf, "Signal %d", signo);
3142 }
3143 else
3144 {
3145 sprintf (locbuf, "%s (%d)", name, signo);
3146 }
3147 return (locbuf);
3148 }
3149
3150 static char *
3151 errnoname (errnum)
3152 int errnum;
3153 {
3154 const char *name;
3155 static char locbuf[32];
3156
3157 name = strerrno (errnum);
3158 if (name == NULL)
3159 {
3160 sprintf (locbuf, "Errno %d", errnum);
3161 }
3162 else
3163 {
3164 sprintf (locbuf, "%s (%d)", name, errnum);
3165 }
3166 return (locbuf);
3167 }
3168
3169 static void
3170 info_proc_signals (pip, summary)
3171 struct procinfo *pip;
3172 int summary;
3173 {
3174 int signo;
3175
3176 if (!summary)
3177 {
3178 if (ioctl (pip -> fd, PIOCGTRACE, &pip -> trace) < 0)
3179 {
3180 print_sys_errmsg (pip -> pathname, errno);
3181 error ("PIOCGTRACE failed");
3182 }
3183
3184 printf_filtered ("Disposition of signals:\n\n");
3185 printf_filtered ("\t%-15s %-8s %-8s %-8s %s\n\n",
3186 "Signal", "Trace", "Hold", "Pending", "Description");
3187 for (signo = 0; signo < NSIG; signo++)
3188 {
3189 QUIT;
3190 printf_filtered ("\t%-15s ", signalname (signo));
3191 printf_filtered ("%-8s ",
3192 prismember (&pip -> trace, signo)
3193 ? "on" : "off");
3194 printf_filtered ("%-8s ",
3195 prismember (&pip -> prstatus.pr_sighold, signo)
3196 ? "on" : "off");
3197
3198 #ifdef PROCFS_SIGPEND_OFFSET
3199 /* Alpha OSF/1 numbers the pending signals from 1. */
3200 printf_filtered ("%-8s ",
3201 (signo ? prismember (&pip -> prstatus.pr_sigpend,
3202 signo - 1)
3203 : 0)
3204 ? "yes" : "no");
3205 #else
3206 printf_filtered ("%-8s ",
3207 prismember (&pip -> prstatus.pr_sigpend, signo)
3208 ? "yes" : "no");
3209 #endif
3210 printf_filtered (" %s\n", safe_strsignal (signo));
3211 }
3212 printf_filtered ("\n");
3213 }
3214 }
3215
3216 static void
3217 info_proc_faults (pip, summary)
3218 struct procinfo *pip;
3219 int summary;
3220 {
3221 struct trans *transp;
3222
3223 if (!summary)
3224 {
3225 if (ioctl (pip -> fd, PIOCGFAULT, &pip -> fltset) < 0)
3226 {
3227 print_sys_errmsg (pip -> pathname, errno);
3228 error ("PIOCGFAULT failed");
3229 }
3230
3231 printf_filtered ("Current traced hardware fault set:\n\n");
3232 printf_filtered ("\t%-12s %-8s\n", "Fault", "Trace");
3233
3234 for (transp = faults_table; transp -> name != NULL; transp++)
3235 {
3236 QUIT;
3237 printf_filtered ("\t%-12s ", transp -> name);
3238 printf_filtered ("%-8s", prismember (&pip -> fltset, transp -> value)
3239 ? "on" : "off");
3240 printf_filtered ("\n");
3241 }
3242 printf_filtered ("\n");
3243 }
3244 }
3245
3246 static void
3247 info_proc_mappings (pip, summary)
3248 struct procinfo *pip;
3249 int summary;
3250 {
3251 int nmap;
3252 struct prmap *prmaps;
3253 struct prmap *prmap;
3254
3255 if (!summary)
3256 {
3257 printf_filtered ("Mapped address spaces:\n\n");
3258 #ifdef BFD_HOST_64_BIT
3259 printf_filtered (" %18s %18s %10s %10s %7s\n",
3260 #else
3261 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
3262 #endif
3263 "Start Addr",
3264 " End Addr",
3265 " Size",
3266 " Offset",
3267 "Flags");
3268 if (ioctl (pip -> fd, PIOCNMAP, &nmap) == 0)
3269 {
3270 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
3271 if (ioctl (pip -> fd, PIOCMAP, prmaps) == 0)
3272 {
3273 for (prmap = prmaps; prmap -> pr_size; ++prmap)
3274 {
3275 #ifdef BFD_HOST_64_BIT
3276 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
3277 #else
3278 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
3279 #endif
3280 (unsigned long)prmap -> pr_vaddr,
3281 (unsigned long)prmap -> pr_vaddr
3282 + prmap -> pr_size - 1,
3283 prmap -> pr_size,
3284 prmap -> pr_off,
3285 mappingflags (prmap -> pr_mflags));
3286 }
3287 }
3288 }
3289 printf_filtered ("\n");
3290 }
3291 }
3292
3293 /*
3294
3295 LOCAL FUNCTION
3296
3297 info_proc -- implement the "info proc" command
3298
3299 SYNOPSIS
3300
3301 void info_proc (char *args, int from_tty)
3302
3303 DESCRIPTION
3304
3305 Implement gdb's "info proc" command by using the /proc interface
3306 to print status information about any currently running process.
3307
3308 Examples of the use of "info proc" are:
3309
3310 info proc (prints summary info for current inferior)
3311 info proc 123 (prints summary info for process with pid 123)
3312 info proc mappings (prints address mappings)
3313 info proc times (prints process/children times)
3314 info proc id (prints pid, ppid, gid, sid, etc)
3315 FIXME: i proc id not implemented.
3316 info proc status (prints general process state info)
3317 FIXME: i proc status not implemented.
3318 info proc signals (prints info about signal handling)
3319 info proc all (prints all info)
3320
3321 */
3322
3323 static void
3324 info_proc (args, from_tty)
3325 char *args;
3326 int from_tty;
3327 {
3328 int pid;
3329 struct procinfo *pip;
3330 struct cleanup *old_chain;
3331 char **argv;
3332 int argsize;
3333 int summary = 1;
3334 int flags = 0;
3335 int syscalls = 0;
3336 int signals = 0;
3337 int faults = 0;
3338 int mappings = 0;
3339 int times = 0;
3340 int id = 0;
3341 int status = 0;
3342 int all = 0;
3343
3344 old_chain = make_cleanup (null_cleanup, 0);
3345
3346 /* Default to using the current inferior if no pid specified. Note
3347 that inferior_pid may be 0, hence we set okerr. */
3348
3349 pip = find_procinfo (inferior_pid, 1);
3350
3351 if (args != NULL)
3352 {
3353 if ((argv = buildargv (args)) == NULL)
3354 {
3355 nomem (0);
3356 }
3357 make_cleanup (freeargv, (char *) argv);
3358
3359 while (*argv != NULL)
3360 {
3361 argsize = strlen (*argv);
3362 if (argsize >= 1 && strncmp (*argv, "all", argsize) == 0)
3363 {
3364 summary = 0;
3365 all = 1;
3366 }
3367 else if (argsize >= 2 && strncmp (*argv, "faults", argsize) == 0)
3368 {
3369 summary = 0;
3370 faults = 1;
3371 }
3372 else if (argsize >= 2 && strncmp (*argv, "flags", argsize) == 0)
3373 {
3374 summary = 0;
3375 flags = 1;
3376 }
3377 else if (argsize >= 1 && strncmp (*argv, "id", argsize) == 0)
3378 {
3379 summary = 0;
3380 id = 1;
3381 }
3382 else if (argsize >= 1 && strncmp (*argv, "mappings", argsize) == 0)
3383 {
3384 summary = 0;
3385 mappings = 1;
3386 }
3387 else if (argsize >= 2 && strncmp (*argv, "signals", argsize) == 0)
3388 {
3389 summary = 0;
3390 signals = 1;
3391 }
3392 else if (argsize >= 2 && strncmp (*argv, "status", argsize) == 0)
3393 {
3394 summary = 0;
3395 status = 1;
3396 }
3397 else if (argsize >= 2 && strncmp (*argv, "syscalls", argsize) == 0)
3398 {
3399 summary = 0;
3400 syscalls = 1;
3401 }
3402 else if (argsize >= 1 && strncmp (*argv, "times", argsize) == 0)
3403 {
3404 summary = 0;
3405 times = 1;
3406 }
3407 else if ((pid = atoi (*argv)) > 0)
3408 {
3409 pip = (struct procinfo *) xmalloc (sizeof (struct procinfo));
3410 memset (pip, 0, sizeof (*pip));
3411
3412 pip->pid = pid;
3413 if (!open_proc_file (pid, pip, O_RDONLY))
3414 {
3415 perror_with_name (pip -> pathname);
3416 /* NOTREACHED */
3417 }
3418 make_cleanup (close_proc_file, pip);
3419 }
3420 else if (**argv != '\000')
3421 {
3422 error ("Unrecognized or ambiguous keyword `%s'.", *argv);
3423 }
3424 argv++;
3425 }
3426 }
3427
3428 /* If we don't have a valid open process at this point, then we have no
3429 inferior or didn't specify a specific pid. */
3430
3431 if (!pip)
3432 {
3433 error ("\
3434 No process. Start debugging a program or specify an explicit process ID.");
3435 }
3436 if (ioctl (pip -> fd, PIOCSTATUS, &(pip -> prstatus)) < 0)
3437 {
3438 print_sys_errmsg (pip -> pathname, errno);
3439 error ("PIOCSTATUS failed");
3440 }
3441
3442 /* Print verbose information of the requested type(s), or just a summary
3443 of the information for all types. */
3444
3445 printf_filtered ("\nInformation for %s:\n\n", pip -> pathname);
3446 if (summary || all || flags)
3447 {
3448 info_proc_flags (pip, summary);
3449 }
3450 if (summary || all)
3451 {
3452 info_proc_stop (pip, summary);
3453 }
3454 if (summary || all || signals || faults)
3455 {
3456 info_proc_siginfo (pip, summary);
3457 }
3458 if (summary || all || syscalls)
3459 {
3460 info_proc_syscalls (pip, summary);
3461 }
3462 if (summary || all || mappings)
3463 {
3464 info_proc_mappings (pip, summary);
3465 }
3466 if (summary || all || signals)
3467 {
3468 info_proc_signals (pip, summary);
3469 }
3470 if (summary || all || faults)
3471 {
3472 info_proc_faults (pip, summary);
3473 }
3474 printf_filtered ("\n");
3475
3476 /* All done, deal with closing any temporary process info structure,
3477 freeing temporary memory , etc. */
3478
3479 do_cleanups (old_chain);
3480 }
3481
3482 /*
3483
3484 LOCAL FUNCTION
3485
3486 procfs_set_sproc_trap -- arrange for child to stop on sproc().
3487
3488 SYNOPSIS
3489
3490 void procfs_set_sproc_trap (struct procinfo *)
3491
3492 DESCRIPTION
3493
3494 This function sets up a trap on sproc system call exits so that we can
3495 detect the arrival of a new thread. We are called with the new thread
3496 stopped prior to it's first instruction.
3497
3498 Also note that we turn on the inherit-on-fork flag in the child process
3499 so that any grand-children start with all tracing flags set.
3500 */
3501
3502 #ifdef SYS_sproc
3503
3504 static void
3505 procfs_set_sproc_trap (pi)
3506 struct procinfo *pi;
3507 {
3508 sysset_t exitset;
3509
3510 if (ioctl (pi->fd, PIOCGEXIT, &exitset) < 0)
3511 {
3512 print_sys_errmsg (pi->pathname, errno);
3513 error ("PIOCGEXIT failed");
3514 }
3515
3516 praddset (&exitset, SYS_sproc);
3517
3518 /* We trap on fork() and vfork() in order to disable debugging in our grand-
3519 children and descendant processes. At this time, GDB can only handle
3520 threads (multiple processes, one address space). forks (and execs) result
3521 in the creation of multiple address spaces, which GDB can't handle yet. */
3522
3523 praddset (&exitset, SYS_fork);
3524 #ifdef SYS_vfork
3525 praddset (&exitset, SYS_vfork);
3526 #endif
3527
3528 if (ioctl (pi->fd, PIOCSEXIT, &exitset) < 0)
3529 {
3530 print_sys_errmsg (pi->pathname, errno);
3531 error ("PIOCSEXIT failed");
3532 }
3533
3534 /* Turn on inherit-on-fork flag so that all grand-children of gdb start with
3535 tracing flags set. */
3536
3537 #ifdef PIOCSET /* New method */
3538 {
3539 long pr_flags;
3540 pr_flags = PR_FORK;
3541 ioctl (pi->fd, PIOCSET, &pr_flags);
3542 }
3543 #else
3544 #ifdef PIOCSFORK /* Original method */
3545 ioctl (pi->fd, PIOCSFORK, NULL);
3546 #endif
3547 #endif
3548 }
3549 #endif /* SYS_sproc */
3550
3551 /* Fork an inferior process, and start debugging it with /proc. */
3552
3553 static void
3554 procfs_create_inferior (exec_file, allargs, env)
3555 char *exec_file;
3556 char *allargs;
3557 char **env;
3558 {
3559 char *shell_file = getenv ("SHELL");
3560 char *tryname;
3561 if (shell_file != NULL && strchr (shell_file, '/') == NULL)
3562 {
3563
3564 /* We will be looking down the PATH to find shell_file. If we
3565 just do this the normal way (via execlp, which operates by
3566 attempting an exec for each element of the PATH until it
3567 finds one which succeeds), then there will be an exec for
3568 each failed attempt, each of which will cause a PR_SYSEXIT
3569 stop, and we won't know how to distinguish the PR_SYSEXIT's
3570 for these failed execs with the ones for successful execs
3571 (whether the exec has succeeded is stored at that time in the
3572 carry bit or some such architecture-specific and
3573 non-ABI-specified place).
3574
3575 So I can't think of anything better than to search the PATH
3576 now. This has several disadvantages: (1) There is a race
3577 condition; if we find a file now and it is deleted before we
3578 exec it, we lose, even if the deletion leaves a valid file
3579 further down in the PATH, (2) there is no way to know exactly
3580 what an executable (in the sense of "capable of being
3581 exec'd") file is. Using access() loses because it may lose
3582 if the caller is the superuser; failing to use it loses if
3583 there are ACLs or some such. */
3584
3585 char *p;
3586 char *p1;
3587 /* FIXME-maybe: might want "set path" command so user can change what
3588 path is used from within GDB. */
3589 char *path = getenv ("PATH");
3590 int len;
3591 struct stat statbuf;
3592
3593 if (path == NULL)
3594 path = "/bin:/usr/bin";
3595
3596 tryname = alloca (strlen (path) + strlen (shell_file) + 2);
3597 for (p = path; p != NULL; p = p1 ? p1 + 1: NULL)
3598 {
3599 p1 = strchr (p, ':');
3600 if (p1 != NULL)
3601 len = p1 - p;
3602 else
3603 len = strlen (p);
3604 strncpy (tryname, p, len);
3605 tryname[len] = '\0';
3606 strcat (tryname, "/");
3607 strcat (tryname, shell_file);
3608 if (access (tryname, X_OK) < 0)
3609 continue;
3610 if (stat (tryname, &statbuf) < 0)
3611 continue;
3612 if (!S_ISREG (statbuf.st_mode))
3613 /* We certainly need to reject directories. I'm not quite
3614 as sure about FIFOs, sockets, etc., but I kind of doubt
3615 that people want to exec() these things. */
3616 continue;
3617 break;
3618 }
3619 if (p == NULL)
3620 /* Not found. This must be an error rather than merely passing
3621 the file to execlp(), because execlp() would try all the
3622 exec()s, causing GDB to get confused. */
3623 error ("Can't find shell %s in PATH", shell_file);
3624
3625 shell_file = tryname;
3626 }
3627
3628 fork_inferior (exec_file, allargs, env,
3629 proc_set_exec_trap, procfs_init_inferior, shell_file);
3630
3631 /* We are at the first instruction we care about. */
3632 /* Pedal to the metal... */
3633
3634 /* Setup traps on exit from sproc() */
3635
3636 #ifdef SYS_sproc
3637 procfs_set_sproc_trap (current_procinfo);
3638 #endif
3639
3640 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
3641 }
3642
3643 /* Clean up after the inferior dies. */
3644
3645 static void
3646 procfs_mourn_inferior ()
3647 {
3648 struct procinfo *pi;
3649 struct procinfo *next_pi;
3650
3651 for (pi = procinfo_list; pi; pi = next_pi)
3652 {
3653 next_pi = pi->next;
3654 unconditionally_kill_inferior (pi);
3655 }
3656
3657 unpush_target (&procfs_ops);
3658 generic_mourn_inferior ();
3659 }
3660
3661
3662 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
3663 static int
3664 procfs_can_run ()
3665 {
3666 return(1);
3667 }
3668 #ifdef TARGET_HAS_HARDWARE_WATCHPOINTS
3669 \f
3670 /* Insert a watchpoint */
3671 int
3672 procfs_set_watchpoint(pid, addr, len, rw)
3673 int pid;
3674 CORE_ADDR addr;
3675 int len;
3676 int rw;
3677 {
3678 struct procinfo *pi;
3679 prwatch_t wpt;
3680
3681 pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
3682 wpt.pr_vaddr = (caddr_t)addr;
3683 wpt.pr_size = len;
3684 wpt.pr_wflags = ((rw & 1) ? MA_READ : 0) | ((rw & 2) ? MA_WRITE : 0);
3685 if (ioctl (pi->fd, PIOCSWATCH, &wpt) < 0)
3686 {
3687 if (errno == E2BIG)
3688 return -1;
3689 /* Currently it sometimes happens that the same watchpoint gets
3690 deleted twice - don't die in this case (FIXME please) */
3691 if (errno == ESRCH && len == 0)
3692 return 0;
3693 print_sys_errmsg (pi->pathname, errno);
3694 error ("PIOCSWATCH failed");
3695 }
3696 return 0;
3697 }
3698
3699 int
3700 procfs_stopped_by_watchpoint(pid)
3701 int pid;
3702 {
3703 struct procinfo *pi;
3704 short what;
3705 short why;
3706
3707 pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
3708 if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
3709 {
3710 why = pi->prstatus.pr_why;
3711 what = pi->prstatus.pr_what;
3712 if (why == PR_FAULTED
3713 #if defined (FLTWATCH) && defined (FLTKWATCH)
3714 && (what == FLTWATCH) || (what == FLTKWATCH)
3715 #else
3716 #ifdef FLTWATCH
3717 && (what == FLTWATCH)
3718 #endif
3719 #ifdef FLTKWATCH
3720 && (what == FLTKWATCH)
3721 #endif
3722 #endif
3723 )
3724 return what;
3725 }
3726 return 0;
3727 }
3728 #endif
3729
3730 /* Send a SIGINT to the process group. This acts just like the user typed a
3731 ^C on the controlling terminal.
3732
3733 XXX - This may not be correct for all systems. Some may want to use
3734 killpg() instead of kill (-pgrp). */
3735
3736 void
3737 procfs_stop ()
3738 {
3739 extern pid_t inferior_process_group;
3740
3741 kill (-inferior_process_group, SIGINT);
3742 }
3743
3744 \f
3745 struct target_ops procfs_ops = {
3746 "procfs", /* to_shortname */
3747 "Unix /proc child process", /* to_longname */
3748 "Unix /proc child process (started by the \"run\" command).", /* to_doc */
3749 procfs_open, /* to_open */
3750 0, /* to_close */
3751 procfs_attach, /* to_attach */
3752 procfs_detach, /* to_detach */
3753 procfs_resume, /* to_resume */
3754 procfs_wait, /* to_wait */
3755 procfs_fetch_registers, /* to_fetch_registers */
3756 procfs_store_registers, /* to_store_registers */
3757 procfs_prepare_to_store, /* to_prepare_to_store */
3758 procfs_xfer_memory, /* to_xfer_memory */
3759 procfs_files_info, /* to_files_info */
3760 memory_insert_breakpoint, /* to_insert_breakpoint */
3761 memory_remove_breakpoint, /* to_remove_breakpoint */
3762 terminal_init_inferior, /* to_terminal_init */
3763 terminal_inferior, /* to_terminal_inferior */
3764 terminal_ours_for_output, /* to_terminal_ours_for_output */
3765 terminal_ours, /* to_terminal_ours */
3766 child_terminal_info, /* to_terminal_info */
3767 procfs_kill_inferior, /* to_kill */
3768 0, /* to_load */
3769 0, /* to_lookup_symbol */
3770 procfs_create_inferior, /* to_create_inferior */
3771 procfs_mourn_inferior, /* to_mourn_inferior */
3772 procfs_can_run, /* to_can_run */
3773 procfs_notice_signals, /* to_notice_signals */
3774 0, /* to_thread_alive */
3775 procfs_stop, /* to_stop */
3776 process_stratum, /* to_stratum */
3777 0, /* to_next */
3778 1, /* to_has_all_memory */
3779 1, /* to_has_memory */
3780 1, /* to_has_stack */
3781 1, /* to_has_registers */
3782 1, /* to_has_execution */
3783 0, /* sections */
3784 0, /* sections_end */
3785 OPS_MAGIC /* to_magic */
3786 };
3787
3788 void
3789 _initialize_procfs ()
3790 {
3791 #ifdef HAVE_OPTIONAL_PROC_FS
3792 char procname[32];
3793 int fd;
3794
3795 /* If we have an optional /proc filesystem (e.g. under OSF/1),
3796 don't add procfs support if we cannot access the running
3797 GDB via /proc. */
3798 sprintf (procname, PROC_NAME_FMT, getpid ());
3799 if ((fd = open (procname, O_RDONLY)) < 0)
3800 return;
3801 close (fd);
3802 #endif
3803
3804 add_target (&procfs_ops);
3805
3806 add_info ("proc", info_proc,
3807 "Show process status information using /proc entry.\n\
3808 Specify process id or use current inferior by default.\n\
3809 Specify keywords for detailed information; default is summary.\n\
3810 Keywords are: `all', `faults', `flags', `id', `mappings', `signals',\n\
3811 `status', `syscalls', and `times'.\n\
3812 Unambiguous abbreviations may be used.");
3813
3814 init_syscall_table ();
3815 }
GDB Binutils - Deliverables
This page took 0.106852 seconds and 4 git commands to generate.