projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* inftarg.c (child_thread_alive): New function to see if a
[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., 675 Mass Ave, Cambridge, MA 02139, 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 <string.h>
45 #include <stropts.h>
46 #include <poll.h>
47 #include <unistd.h>
48 #include <sys/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_PIOCSSIG_FOR_KILL
1255 /* Alpha OSF/1 procfs needs a PIOCSSIG call with a SIGKILL signal
1256 to kill the inferior, otherwise it might remain stopped with a
1257 pending SIGKILL.
1258 We do not check the result of the PIOCSSIG, the inferior might have
1259 died already. */
1260 {
1261 struct siginfo newsiginfo;
1262
1263 memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
1264 newsiginfo.si_signo = signo;
1265 newsiginfo.si_code = 0;
1266 newsiginfo.si_errno = 0;
1267 newsiginfo.si_pid = getpid ();
1268 newsiginfo.si_uid = getuid ();
1269 ioctl (pi->fd, PIOCSSIG, &newsiginfo);
1270 }
1271 #else
1272 ioctl (pi->fd, PIOCKILL, &signo);
1273 #endif
1274
1275 close_proc_file (pi);
1276
1277 /* Only wait() for our direct children. Our grandchildren zombies are killed
1278 by the death of their parents. */
1279
1280 if (ppid == getpid())
1281 wait ((int *) 0);
1282 }
1283
1284 /*
1285
1286 LOCAL FUNCTION
1287
1288 procfs_xfer_memory -- copy data to or from inferior memory space
1289
1290 SYNOPSIS
1291
1292 int procfs_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
1293 int dowrite, struct target_ops target)
1294
1295 DESCRIPTION
1296
1297 Copy LEN bytes to/from inferior's memory starting at MEMADDR
1298 from/to debugger memory starting at MYADDR. Copy from inferior
1299 if DOWRITE is zero or to inferior if DOWRITE is nonzero.
1300
1301 Returns the length copied, which is either the LEN argument or
1302 zero. This xfer function does not do partial moves, since procfs_ops
1303 doesn't allow memory operations to cross below us in the target stack
1304 anyway.
1305
1306 NOTES
1307
1308 The /proc interface makes this an almost trivial task.
1309 */
1310
1311 static int
1312 procfs_xfer_memory (memaddr, myaddr, len, dowrite, target)
1313 CORE_ADDR memaddr;
1314 char *myaddr;
1315 int len;
1316 int dowrite;
1317 struct target_ops *target; /* ignored */
1318 {
1319 int nbytes = 0;
1320 struct procinfo *pi;
1321
1322 pi = current_procinfo;
1323
1324 if (lseek(pi->fd, (off_t) memaddr, 0) == (off_t) memaddr)
1325 {
1326 if (dowrite)
1327 {
1328 nbytes = write (pi->fd, myaddr, len);
1329 }
1330 else
1331 {
1332 nbytes = read (pi->fd, myaddr, len);
1333 }
1334 if (nbytes < 0)
1335 {
1336 nbytes = 0;
1337 }
1338 }
1339 return (nbytes);
1340 }
1341
1342 /*
1343
1344 LOCAL FUNCTION
1345
1346 procfs_store_registers -- copy register values back to inferior
1347
1348 SYNOPSIS
1349
1350 void procfs_store_registers (int regno)
1351
1352 DESCRIPTION
1353
1354 Store our current register values back into the inferior. If
1355 REGNO is -1 then store all the register, otherwise store just
1356 the value specified by REGNO.
1357
1358 NOTES
1359
1360 If we are storing only a single register, we first have to get all
1361 the current values from the process, overwrite the desired register
1362 in the gregset with the one we want from gdb's registers, and then
1363 send the whole set back to the process. For writing all the
1364 registers, all we have to do is generate the gregset and send it to
1365 the process.
1366
1367 Also note that the process has to be stopped on an event of interest
1368 for this to work, which basically means that it has to have been
1369 run under the control of one of the other /proc ioctl calls and not
1370 ptrace. Since we don't use ptrace anyway, we don't worry about this
1371 fine point, but it is worth noting for future reference.
1372
1373 Gdb is confused about what this function is supposed to return.
1374 Some versions return a value, others return nothing. Some are
1375 declared to return a value and actually return nothing. Gdb ignores
1376 anything returned. (FIXME)
1377
1378 */
1379
1380 static void
1381 procfs_store_registers (regno)
1382 int regno;
1383 {
1384 struct procinfo *pi;
1385
1386 pi = current_procinfo;
1387
1388 if (regno != -1)
1389 {
1390 ioctl (pi->fd, PIOCGREG, &pi->gregset);
1391 }
1392 fill_gregset (&pi->gregset, regno);
1393 ioctl (pi->fd, PIOCSREG, &pi->gregset);
1394
1395 #if defined (FP0_REGNUM)
1396
1397 /* Now repeat everything using the floating point register set, if the
1398 target has floating point hardware. Since we ignore the returned value,
1399 we'll never know whether it worked or not anyway. */
1400
1401 if (regno != -1)
1402 {
1403 ioctl (pi->fd, PIOCGFPREG, &pi->fpregset);
1404 }
1405 fill_fpregset (&pi->fpregset, regno);
1406 ioctl (pi->fd, PIOCSFPREG, &pi->fpregset);
1407
1408 #endif /* FP0_REGNUM */
1409
1410 }
1411
1412 /*
1413
1414 LOCAL FUNCTION
1415
1416 create_procinfo - initialize access to a /proc entry
1417
1418 SYNOPSIS
1419
1420 struct procinfo * create_procinfo (int pid)
1421
1422 DESCRIPTION
1423
1424 Allocate a procinfo structure, open the /proc file and then set up the
1425 set of signals and faults that are to be traced. Returns a pointer to
1426 the new procinfo structure.
1427
1428 NOTES
1429
1430 If proc_init_failed ever gets called, control returns to the command
1431 processing loop via the standard error handling code.
1432
1433 */
1434
1435 static struct procinfo *
1436 create_procinfo (pid)
1437 int pid;
1438 {
1439 struct procinfo *pi;
1440
1441 pi = find_procinfo (pid, 1);
1442 if (pi != NULL)
1443 return pi; /* All done! It already exists */
1444
1445 pi = (struct procinfo *) xmalloc (sizeof (struct procinfo));
1446
1447 if (!open_proc_file (pid, pi, O_RDWR))
1448 proc_init_failed (pi, "can't open process file");
1449
1450 /* Add new process to process info list */
1451
1452 pi->next = procinfo_list;
1453 procinfo_list = pi;
1454
1455 add_fd (pi); /* Add to list for poll/select */
1456
1457 memset ((char *) &pi->prrun, 0, sizeof (pi->prrun));
1458 prfillset (&pi->prrun.pr_trace);
1459 procfs_notice_signals (pid);
1460 prfillset (&pi->prrun.pr_fault);
1461 prdelset (&pi->prrun.pr_fault, FLTPAGE);
1462
1463 #ifdef PROCFS_DONT_TRACE_FAULTS
1464 premptyset (&pi->prrun.pr_fault);
1465 #endif
1466
1467 if (ioctl (pi->fd, PIOCWSTOP, &pi->prstatus) < 0)
1468 proc_init_failed (pi, "PIOCWSTOP failed");
1469
1470 if (ioctl (pi->fd, PIOCSFAULT, &pi->prrun.pr_fault) < 0)
1471 proc_init_failed (pi, "PIOCSFAULT failed");
1472
1473 return pi;
1474 }
1475
1476 /*
1477
1478 LOCAL FUNCTION
1479
1480 procfs_init_inferior - initialize target vector and access to a
1481 /proc entry
1482
1483 SYNOPSIS
1484
1485 void procfs_init_inferior (int pid)
1486
1487 DESCRIPTION
1488
1489 When gdb starts an inferior, this function is called in the parent
1490 process immediately after the fork. It waits for the child to stop
1491 on the return from the exec system call (the child itself takes care
1492 of ensuring that this is set up), then sets up the set of signals
1493 and faults that are to be traced.
1494
1495 NOTES
1496
1497 If proc_init_failed ever gets called, control returns to the command
1498 processing loop via the standard error handling code.
1499
1500 */
1501
1502 static void
1503 procfs_init_inferior (pid)
1504 int pid;
1505 {
1506 push_target (&procfs_ops);
1507
1508 create_procinfo (pid);
1509 add_thread (pid); /* Setup initial thread */
1510
1511 #ifdef START_INFERIOR_TRAPS_EXPECTED
1512 startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
1513 #else
1514 /* One trap to exec the shell, one to exec the program being debugged. */
1515 startup_inferior (2);
1516 #endif
1517 }
1518
1519 /*
1520
1521 GLOBAL FUNCTION
1522
1523 procfs_notice_signals
1524
1525 SYNOPSIS
1526
1527 static void procfs_notice_signals (int pid);
1528
1529 DESCRIPTION
1530
1531 When the user changes the state of gdb's signal handling via the
1532 "handle" command, this function gets called to see if any change
1533 in the /proc interface is required. It is also called internally
1534 by other /proc interface functions to initialize the state of
1535 the traced signal set.
1536
1537 One thing it does is that signals for which the state is "nostop",
1538 "noprint", and "pass", have their trace bits reset in the pr_trace
1539 field, so that they are no longer traced. This allows them to be
1540 delivered directly to the inferior without the debugger ever being
1541 involved.
1542 */
1543
1544 static void
1545 procfs_notice_signals (pid)
1546 int pid;
1547 {
1548 int signo;
1549 struct procinfo *pi;
1550
1551 pi = find_procinfo (pid, 0);
1552
1553 for (signo = 0; signo < NSIG; signo++)
1554 {
1555 if (signal_stop_state (target_signal_from_host (signo)) == 0 &&
1556 signal_print_state (target_signal_from_host (signo)) == 0 &&
1557 signal_pass_state (target_signal_from_host (signo)) == 1)
1558 {
1559 prdelset (&pi->prrun.pr_trace, signo);
1560 }
1561 else
1562 {
1563 praddset (&pi->prrun.pr_trace, signo);
1564 }
1565 }
1566 if (ioctl (pi->fd, PIOCSTRACE, &pi->prrun.pr_trace))
1567 {
1568 print_sys_errmsg ("PIOCSTRACE failed", errno);
1569 }
1570 }
1571
1572 /*
1573
1574 LOCAL FUNCTION
1575
1576 proc_set_exec_trap -- arrange for exec'd child to halt at startup
1577
1578 SYNOPSIS
1579
1580 void proc_set_exec_trap (void)
1581
1582 DESCRIPTION
1583
1584 This function is called in the child process when starting up
1585 an inferior, prior to doing the exec of the actual inferior.
1586 It sets the child process's exitset to make exit from the exec
1587 system call an event of interest to stop on, and then simply
1588 returns. The child does the exec, the system call returns, and
1589 the child stops at the first instruction, ready for the gdb
1590 parent process to take control of it.
1591
1592 NOTE
1593
1594 We need to use all local variables since the child may be sharing
1595 it's data space with the parent, if vfork was used rather than
1596 fork.
1597
1598 Also note that we want to turn off the inherit-on-fork flag in
1599 the child process so that any grand-children start with all
1600 tracing flags cleared.
1601 */
1602
1603 static void
1604 proc_set_exec_trap ()
1605 {
1606 sysset_t exitset;
1607 sysset_t entryset;
1608 auto char procname[32];
1609 int fd;
1610
1611 sprintf (procname, PROC_NAME_FMT, getpid ());
1612 if ((fd = open (procname, O_RDWR)) < 0)
1613 {
1614 perror (procname);
1615 gdb_flush (gdb_stderr);
1616 _exit (127);
1617 }
1618 premptyset (&exitset);
1619 premptyset (&entryset);
1620
1621 #ifdef PIOCSSPCACT
1622 /* Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
1623 exits from exec system calls because of the user level loader. */
1624 {
1625 int prfs_flags;
1626
1627 if (ioctl (fd, PIOCGSPCACT, &prfs_flags) < 0)
1628 {
1629 perror (procname);
1630 gdb_flush (gdb_stderr);
1631 _exit (127);
1632 }
1633 prfs_flags |= PRFS_STOPEXEC;
1634 if (ioctl (fd, PIOCSSPCACT, &prfs_flags) < 0)
1635 {
1636 perror (procname);
1637 gdb_flush (gdb_stderr);
1638 _exit (127);
1639 }
1640 }
1641 #else
1642 /* GW: Rationale...
1643 Not all systems with /proc have all the exec* syscalls with the same
1644 names. On the SGI, for example, there is no SYS_exec, but there
1645 *is* a SYS_execv. So, we try to account for that. */
1646
1647 #ifdef SYS_exec
1648 praddset (&exitset, SYS_exec);
1649 #endif
1650 #ifdef SYS_execve
1651 praddset (&exitset, SYS_execve);
1652 #endif
1653 #ifdef SYS_execv
1654 praddset (&exitset, SYS_execv);
1655 #endif
1656
1657 if (ioctl (fd, PIOCSEXIT, &exitset) < 0)
1658 {
1659 perror (procname);
1660 gdb_flush (gdb_stderr);
1661 _exit (127);
1662 }
1663 #endif
1664
1665 praddset (&entryset, SYS_exit);
1666
1667 if (ioctl (fd, PIOCSENTRY, &entryset) < 0)
1668 {
1669 perror (procname);
1670 gdb_flush (gdb_stderr);
1671 _exit (126);
1672 }
1673
1674 /* Turn off inherit-on-fork flag so that all grand-children of gdb
1675 start with tracing flags cleared. */
1676
1677 #if defined (PIOCRESET) /* New method */
1678 {
1679 long pr_flags;
1680 pr_flags = PR_FORK;
1681 ioctl (fd, PIOCRESET, &pr_flags);
1682 }
1683 #else
1684 #if defined (PIOCRFORK) /* Original method */
1685 ioctl (fd, PIOCRFORK, NULL);
1686 #endif
1687 #endif
1688
1689 /* Turn on run-on-last-close flag so that this process will not hang
1690 if GDB goes away for some reason. */
1691
1692 #if defined (PIOCSET) /* New method */
1693 {
1694 long pr_flags;
1695 pr_flags = PR_RLC;
1696 (void) ioctl (fd, PIOCSET, &pr_flags);
1697 }
1698 #else
1699 #if defined (PIOCSRLC) /* Original method */
1700 (void) ioctl (fd, PIOCSRLC, 0);
1701 #endif
1702 #endif
1703 }
1704
1705 /*
1706
1707 GLOBAL FUNCTION
1708
1709 proc_iterate_over_mappings -- call function for every mapped space
1710
1711 SYNOPSIS
1712
1713 int proc_iterate_over_mappings (int (*func)())
1714
1715 DESCRIPTION
1716
1717 Given a pointer to a function, call that function for every
1718 mapped address space, passing it an open file descriptor for
1719 the file corresponding to that mapped address space (if any)
1720 and the base address of the mapped space. Quit when we hit
1721 the end of the mappings or the function returns nonzero.
1722 */
1723
1724 int
1725 proc_iterate_over_mappings (func)
1726 int (*func) PARAMS ((int, CORE_ADDR));
1727 {
1728 int nmap;
1729 int fd;
1730 int funcstat = 0;
1731 struct prmap *prmaps;
1732 struct prmap *prmap;
1733 struct procinfo *pi;
1734
1735 pi = current_procinfo;
1736
1737 if (ioctl (pi->fd, PIOCNMAP, &nmap) == 0)
1738 {
1739 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
1740 if (ioctl (pi->fd, PIOCMAP, prmaps) == 0)
1741 {
1742 for (prmap = prmaps; prmap -> pr_size && funcstat == 0; ++prmap)
1743 {
1744 fd = proc_address_to_fd (pi, (CORE_ADDR) prmap -> pr_vaddr, 0);
1745 funcstat = (*func) (fd, (CORE_ADDR) prmap -> pr_vaddr);
1746 close (fd);
1747 }
1748 }
1749 }
1750 return (funcstat);
1751 }
1752
1753 #if 0 /* Currently unused */
1754 /*
1755
1756 GLOBAL FUNCTION
1757
1758 proc_base_address -- find base address for segment containing address
1759
1760 SYNOPSIS
1761
1762 CORE_ADDR proc_base_address (CORE_ADDR addr)
1763
1764 DESCRIPTION
1765
1766 Given an address of a location in the inferior, find and return
1767 the base address of the mapped segment containing that address.
1768
1769 This is used for example, by the shared library support code,
1770 where we have the pc value for some location in the shared library
1771 where we are stopped, and need to know the base address of the
1772 segment containing that address.
1773 */
1774
1775 CORE_ADDR
1776 proc_base_address (addr)
1777 CORE_ADDR addr;
1778 {
1779 int nmap;
1780 struct prmap *prmaps;
1781 struct prmap *prmap;
1782 CORE_ADDR baseaddr = 0;
1783 struct procinfo *pi;
1784
1785 pi = current_procinfo;
1786
1787 if (ioctl (pi->fd, PIOCNMAP, &nmap) == 0)
1788 {
1789 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
1790 if (ioctl (pi->fd, PIOCMAP, prmaps) == 0)
1791 {
1792 for (prmap = prmaps; prmap -> pr_size; ++prmap)
1793 {
1794 if ((prmap -> pr_vaddr <= (caddr_t) addr) &&
1795 (prmap -> pr_vaddr + prmap -> pr_size > (caddr_t) addr))
1796 {
1797 baseaddr = (CORE_ADDR) prmap -> pr_vaddr;
1798 break;
1799 }
1800 }
1801 }
1802 }
1803 return (baseaddr);
1804 }
1805
1806 #endif /* 0 */
1807
1808 /*
1809
1810 LOCAL FUNCTION
1811
1812 proc_address_to_fd -- return open fd for file mapped to address
1813
1814 SYNOPSIS
1815
1816 int proc_address_to_fd (struct procinfo *pi, CORE_ADDR addr, complain)
1817
1818 DESCRIPTION
1819
1820 Given an address in the current inferior's address space, use the
1821 /proc interface to find an open file descriptor for the file that
1822 this address was mapped in from. Return -1 if there is no current
1823 inferior. Print a warning message if there is an inferior but
1824 the address corresponds to no file (IE a bogus address).
1825
1826 */
1827
1828 static int
1829 proc_address_to_fd (pi, addr, complain)
1830 struct procinfo *pi;
1831 CORE_ADDR addr;
1832 int complain;
1833 {
1834 int fd = -1;
1835
1836 if ((fd = ioctl (pi->fd, PIOCOPENM, (caddr_t *) &addr)) < 0)
1837 {
1838 if (complain)
1839 {
1840 print_sys_errmsg (pi->pathname, errno);
1841 warning ("can't find mapped file for address 0x%x", addr);
1842 }
1843 }
1844 return (fd);
1845 }
1846
1847
1848 /* Attach to process PID, then initialize for debugging it
1849 and wait for the trace-trap that results from attaching. */
1850
1851 static void
1852 procfs_attach (args, from_tty)
1853 char *args;
1854 int from_tty;
1855 {
1856 char *exec_file;
1857 int pid;
1858
1859 if (!args)
1860 error_no_arg ("process-id to attach");
1861
1862 pid = atoi (args);
1863
1864 if (pid == getpid()) /* Trying to masturbate? */
1865 error ("I refuse to debug myself!");
1866
1867 if (from_tty)
1868 {
1869 exec_file = (char *) get_exec_file (0);
1870
1871 if (exec_file)
1872 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file, target_pid_to_str (pid));
1873 else
1874 printf_unfiltered ("Attaching to %s\n", target_pid_to_str (pid));
1875
1876 gdb_flush (gdb_stdout);
1877 }
1878
1879 do_attach (pid);
1880 inferior_pid = pid;
1881 push_target (&procfs_ops);
1882 }
1883
1884
1885 /* Take a program previously attached to and detaches it.
1886 The program resumes execution and will no longer stop
1887 on signals, etc. We'd better not have left any breakpoints
1888 in the program or it'll die when it hits one. For this
1889 to work, it may be necessary for the process to have been
1890 previously attached. It *might* work if the program was
1891 started via the normal ptrace (PTRACE_TRACEME). */
1892
1893 static void
1894 procfs_detach (args, from_tty)
1895 char *args;
1896 int from_tty;
1897 {
1898 int siggnal = 0;
1899
1900 if (from_tty)
1901 {
1902 char *exec_file = get_exec_file (0);
1903 if (exec_file == 0)
1904 exec_file = "";
1905 printf_unfiltered ("Detaching from program: %s %s\n",
1906 exec_file, target_pid_to_str (inferior_pid));
1907 gdb_flush (gdb_stdout);
1908 }
1909 if (args)
1910 siggnal = atoi (args);
1911
1912 do_detach (siggnal);
1913 inferior_pid = 0;
1914 unpush_target (&procfs_ops); /* Pop out of handling an inferior */
1915 }
1916
1917 /* Get ready to modify the registers array. On machines which store
1918 individual registers, this doesn't need to do anything. On machines
1919 which store all the registers in one fell swoop, this makes sure
1920 that registers contains all the registers from the program being
1921 debugged. */
1922
1923 static void
1924 procfs_prepare_to_store ()
1925 {
1926 #ifdef CHILD_PREPARE_TO_STORE
1927 CHILD_PREPARE_TO_STORE ();
1928 #endif
1929 }
1930
1931 /* Print status information about what we're accessing. */
1932
1933 static void
1934 procfs_files_info (ignore)
1935 struct target_ops *ignore;
1936 {
1937 printf_unfiltered ("\tUsing the running image of %s %s via /proc.\n",
1938 attach_flag? "attached": "child", target_pid_to_str (inferior_pid));
1939 }
1940
1941 /* ARGSUSED */
1942 static void
1943 procfs_open (arg, from_tty)
1944 char *arg;
1945 int from_tty;
1946 {
1947 error ("Use the \"run\" command to start a Unix child process.");
1948 }
1949
1950 /*
1951
1952 LOCAL FUNCTION
1953
1954 do_attach -- attach to an already existing process
1955
1956 SYNOPSIS
1957
1958 int do_attach (int pid)
1959
1960 DESCRIPTION
1961
1962 Attach to an already existing process with the specified process
1963 id. If the process is not already stopped, query whether to
1964 stop it or not.
1965
1966 NOTES
1967
1968 The option of stopping at attach time is specific to the /proc
1969 versions of gdb. Versions using ptrace force the attachee
1970 to stop. (I have changed this version to do so, too. All you
1971 have to do is "continue" to make it go on. -- gnu@cygnus.com)
1972
1973 */
1974
1975 static int
1976 do_attach (pid)
1977 int pid;
1978 {
1979 int result;
1980 struct procinfo *pi;
1981
1982 pi = (struct procinfo *) xmalloc (sizeof (struct procinfo));
1983
1984 if (!open_proc_file (pid, pi, O_RDWR))
1985 {
1986 free (pi);
1987 perror_with_name (pi->pathname);
1988 /* NOTREACHED */
1989 }
1990
1991 /* Add new process to process info list */
1992
1993 pi->next = procinfo_list;
1994 procinfo_list = pi;
1995
1996 add_fd (pi); /* Add to list for poll/select */
1997
1998 /* Get current status of process and if it is not already stopped,
1999 then stop it. Remember whether or not it was stopped when we first
2000 examined it. */
2001
2002 if (ioctl (pi->fd, PIOCSTATUS, &pi->prstatus) < 0)
2003 {
2004 print_sys_errmsg (pi->pathname, errno);
2005 close_proc_file (pi);
2006 error ("PIOCSTATUS failed");
2007 }
2008 if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
2009 {
2010 pi->was_stopped = 1;
2011 }
2012 else
2013 {
2014 pi->was_stopped = 0;
2015 if (1 || query ("Process is currently running, stop it? "))
2016 {
2017 /* Make it run again when we close it. */
2018 #if defined (PIOCSET) /* New method */
2019 {
2020 long pr_flags;
2021 pr_flags = PR_RLC;
2022 result = ioctl (pi->fd, PIOCSET, &pr_flags);
2023 }
2024 #else
2025 #if defined (PIOCSRLC) /* Original method */
2026 result = ioctl (pi->fd, PIOCSRLC, 0);
2027 #endif
2028 #endif
2029 if (result < 0)
2030 {
2031 print_sys_errmsg (pi->pathname, errno);
2032 close_proc_file (pi);
2033 error ("PIOCSRLC or PIOCSET failed");
2034 }
2035 if (ioctl (pi->fd, PIOCSTOP, &pi->prstatus) < 0)
2036 {
2037 print_sys_errmsg (pi->pathname, errno);
2038 close_proc_file (pi);
2039 error ("PIOCSTOP failed");
2040 }
2041 pi->nopass_next_sigstop = 1;
2042 }
2043 else
2044 {
2045 printf_unfiltered ("Ok, gdb will wait for %s to stop.\n", target_pid_to_str (pid));
2046 }
2047 }
2048
2049 /* Remember some things about the inferior that we will, or might, change
2050 so that we can restore them when we detach. */
2051
2052 ioctl (pi->fd, PIOCGTRACE, &pi->saved_trace);
2053 ioctl (pi->fd, PIOCGHOLD, &pi->saved_sighold);
2054 ioctl (pi->fd, PIOCGFAULT, &pi->saved_fltset);
2055 ioctl (pi->fd, PIOCGENTRY, &pi->saved_entryset);
2056 ioctl (pi->fd, PIOCGEXIT, &pi->saved_exitset);
2057
2058 /* Set up trace and fault sets, as gdb expects them. */
2059
2060 memset (&pi->prrun, 0, sizeof (pi->prrun));
2061 prfillset (&pi->prrun.pr_trace);
2062 procfs_notice_signals (pid);
2063 prfillset (&pi->prrun.pr_fault);
2064 prdelset (&pi->prrun.pr_fault, FLTPAGE);
2065
2066 #ifdef PROCFS_DONT_TRACE_FAULTS
2067 premptyset (&pi->prrun.pr_fault);
2068 #endif
2069
2070 if (ioctl (pi->fd, PIOCSFAULT, &pi->prrun.pr_fault))
2071 {
2072 print_sys_errmsg ("PIOCSFAULT failed", errno);
2073 }
2074 if (ioctl (pi->fd, PIOCSTRACE, &pi->prrun.pr_trace))
2075 {
2076 print_sys_errmsg ("PIOCSTRACE failed", errno);
2077 }
2078 attach_flag = 1;
2079 return (pid);
2080 }
2081
2082 /*
2083
2084 LOCAL FUNCTION
2085
2086 do_detach -- detach from an attached-to process
2087
2088 SYNOPSIS
2089
2090 void do_detach (int signal)
2091
2092 DESCRIPTION
2093
2094 Detach from the current attachee.
2095
2096 If signal is non-zero, the attachee is started running again and sent
2097 the specified signal.
2098
2099 If signal is zero and the attachee was not already stopped when we
2100 attached to it, then we make it runnable again when we detach.
2101
2102 Otherwise, we query whether or not to make the attachee runnable
2103 again, since we may simply want to leave it in the state it was in
2104 when we attached.
2105
2106 We report any problems, but do not consider them errors, since we
2107 MUST detach even if some things don't seem to go right. This may not
2108 be the ideal situation. (FIXME).
2109 */
2110
2111 static void
2112 do_detach (signal)
2113 int signal;
2114 {
2115 int result;
2116 struct procinfo *pi;
2117
2118 pi = current_procinfo;
2119
2120 if (signal)
2121 {
2122 set_proc_siginfo (pi, signal);
2123 }
2124 if (ioctl (pi->fd, PIOCSEXIT, &pi->saved_exitset) < 0)
2125 {
2126 print_sys_errmsg (pi->pathname, errno);
2127 printf_unfiltered ("PIOCSEXIT failed.\n");
2128 }
2129 if (ioctl (pi->fd, PIOCSENTRY, &pi->saved_entryset) < 0)
2130 {
2131 print_sys_errmsg (pi->pathname, errno);
2132 printf_unfiltered ("PIOCSENTRY failed.\n");
2133 }
2134 if (ioctl (pi->fd, PIOCSTRACE, &pi->saved_trace) < 0)
2135 {
2136 print_sys_errmsg (pi->pathname, errno);
2137 printf_unfiltered ("PIOCSTRACE failed.\n");
2138 }
2139 if (ioctl (pi->fd, PIOCSHOLD, &pi->saved_sighold) < 0)
2140 {
2141 print_sys_errmsg (pi->pathname, errno);
2142 printf_unfiltered ("PIOSCHOLD failed.\n");
2143 }
2144 if (ioctl (pi->fd, PIOCSFAULT, &pi->saved_fltset) < 0)
2145 {
2146 print_sys_errmsg (pi->pathname, errno);
2147 printf_unfiltered ("PIOCSFAULT failed.\n");
2148 }
2149 if (ioctl (pi->fd, PIOCSTATUS, &pi->prstatus) < 0)
2150 {
2151 print_sys_errmsg (pi->pathname, errno);
2152 printf_unfiltered ("PIOCSTATUS failed.\n");
2153 }
2154 else
2155 {
2156 if (signal || (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)))
2157 {
2158 if (signal || !pi->was_stopped ||
2159 query ("Was stopped when attached, make it runnable again? "))
2160 {
2161 /* Clear any pending signal if we want to detach without
2162 a signal. */
2163 if (signal == 0)
2164 set_proc_siginfo (pi, signal);
2165
2166 /* Clear any fault that might have stopped it. */
2167 if (ioctl (pi->fd, PIOCCFAULT, 0))
2168 {
2169 print_sys_errmsg (pi->pathname, errno);
2170 printf_unfiltered ("PIOCCFAULT failed.\n");
2171 }
2172
2173 /* Make it run again when we close it. */
2174 #if defined (PIOCSET) /* New method */
2175 {
2176 long pr_flags;
2177 pr_flags = PR_RLC;
2178 result = ioctl (pi->fd, PIOCSET, &pr_flags);
2179 }
2180 #else
2181 #if defined (PIOCSRLC) /* Original method */
2182 result = ioctl (pi->fd, PIOCSRLC, 0);
2183 #endif
2184 #endif
2185 if (result)
2186 {
2187 print_sys_errmsg (pi->pathname, errno);
2188 printf_unfiltered ("PIOCSRLC or PIOCSET failed.\n");
2189 }
2190 }
2191 }
2192 }
2193 close_proc_file (pi);
2194 attach_flag = 0;
2195 }
2196
2197 /* emulate wait() as much as possible.
2198 Wait for child to do something. Return pid of child, or -1 in case
2199 of error; store status in *OURSTATUS.
2200
2201 Not sure why we can't
2202 just use wait(), but it seems to have problems when applied to a
2203 process being controlled with the /proc interface.
2204
2205 We have a race problem here with no obvious solution. We need to let
2206 the inferior run until it stops on an event of interest, which means
2207 that we need to use the PIOCWSTOP ioctl. However, we cannot use this
2208 ioctl if the process is already stopped on something that is not an
2209 event of interest, or the call will hang indefinitely. Thus we first
2210 use PIOCSTATUS to see if the process is not stopped. If not, then we
2211 use PIOCWSTOP. But during the window between the two, if the process
2212 stops for any reason that is not an event of interest (such as a job
2213 control signal) then gdb will hang. One possible workaround is to set
2214 an alarm to wake up every minute of so and check to see if the process
2215 is still running, and if so, then reissue the PIOCWSTOP. But this is
2216 a real kludge, so has not been implemented. FIXME: investigate
2217 alternatives.
2218
2219 FIXME: Investigate why wait() seems to have problems with programs
2220 being control by /proc routines. */
2221
2222 static int
2223 procfs_wait (pid, ourstatus)
2224 int pid;
2225 struct target_waitstatus *ourstatus;
2226 {
2227 short what;
2228 short why;
2229 int statval = 0;
2230 int checkerr = 0;
2231 int rtnval = -1;
2232 struct procinfo *pi;
2233
2234 if (pid != -1) /* Non-specific process? */
2235 pi = NULL;
2236 else
2237 for (pi = procinfo_list; pi; pi = pi->next)
2238 if (pi->had_event)
2239 break;
2240
2241 if (!pi)
2242 {
2243 wait_again:
2244
2245 pi = wait_fd ();
2246 }
2247
2248 if (pid != -1)
2249 for (pi = procinfo_list; pi; pi = pi->next)
2250 if (pi->pid == pid && pi->had_event)
2251 break;
2252
2253 if (!pi && !checkerr)
2254 goto wait_again;
2255
2256 if (!checkerr && !(pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)))
2257 {
2258 if (ioctl (pi->fd, PIOCWSTOP, &pi->prstatus) < 0)
2259 {
2260 checkerr++;
2261 }
2262 }
2263 if (checkerr)
2264 {
2265 if (errno == ENOENT)
2266 {
2267 rtnval = wait (&statval);
2268 if (rtnval != inferior_pid)
2269 {
2270 print_sys_errmsg (pi->pathname, errno);
2271 error ("PIOCWSTOP, wait failed, returned %d", rtnval);
2272 /* NOTREACHED */
2273 }
2274 }
2275 else
2276 {
2277 print_sys_errmsg (pi->pathname, errno);
2278 error ("PIOCSTATUS or PIOCWSTOP failed.");
2279 /* NOTREACHED */
2280 }
2281 }
2282 else if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
2283 {
2284 rtnval = pi->prstatus.pr_pid;
2285 why = pi->prstatus.pr_why;
2286 what = pi->prstatus.pr_what;
2287
2288 switch (why)
2289 {
2290 case PR_SIGNALLED:
2291 statval = (what << 8) | 0177;
2292 break;
2293 case PR_SYSENTRY:
2294 if (what != SYS_exit)
2295 error ("PR_SYSENTRY, unknown system call %d", what);
2296
2297 pi->prrun.pr_flags = PRCFAULT;
2298
2299 if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
2300 perror_with_name (pi->pathname);
2301
2302 rtnval = wait (&statval);
2303
2304 break;
2305 case PR_SYSEXIT:
2306 switch (what)
2307 {
2308 #ifdef SYS_exec
2309 case SYS_exec:
2310 #endif
2311 #ifdef SYS_execve
2312 case SYS_execve:
2313 #endif
2314 #ifdef SYS_execv
2315 case SYS_execv:
2316 #endif
2317 statval = (SIGTRAP << 8) | 0177;
2318 break;
2319 #ifdef SYS_sproc
2320 case SYS_sproc:
2321 /* We've just detected the completion of an sproc system call. Now we need to
2322 setup a procinfo struct for this thread, and notify the thread system of the
2323 new arrival. */
2324
2325 /* If sproc failed, then nothing interesting happened. Continue the process and
2326 go back to sleep. */
2327
2328 if (pi->prstatus.pr_errno != 0)
2329 {
2330 pi->prrun.pr_flags &= PRSTEP;
2331 pi->prrun.pr_flags |= PRCFAULT;
2332
2333 if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
2334 perror_with_name (pi->pathname);
2335
2336 goto wait_again;
2337 }
2338
2339 /* At this point, the new thread is stopped at it's first instruction, and
2340 the parent is stopped at the exit from sproc. */
2341
2342 /* Notify the caller of the arrival of a new thread. */
2343 create_procinfo (pi->prstatus.pr_rval1);
2344
2345 rtnval = pi->prstatus.pr_rval1;
2346 statval = (SIGTRAP << 8) | 0177;
2347
2348 break;
2349 case SYS_fork:
2350 #ifdef SYS_vfork
2351 case SYS_vfork:
2352 #endif
2353 /* At this point, we've detected the completion of a fork (or vfork) call in
2354 our child. The grandchild is also stopped because we set inherit-on-fork
2355 earlier. (Note that nobody has the grandchilds' /proc file open at this
2356 point.) We will release the grandchild from the debugger by opening it's
2357 /proc file and then closing it. Since run-on-last-close is set, the
2358 grandchild continues on its' merry way. */
2359
2360 {
2361 struct procinfo *pitemp;
2362
2363 pitemp = create_procinfo (pi->prstatus.pr_rval1);
2364 if (pitemp)
2365 close_proc_file (pitemp);
2366
2367 if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
2368 perror_with_name (pi->pathname);
2369 }
2370 goto wait_again;
2371 #endif /* SYS_sproc */
2372
2373 default:
2374 error ("PIOCSTATUS (PR_SYSEXIT): Unknown system call %d", what);
2375 }
2376 break;
2377 case PR_REQUESTED:
2378 statval = (SIGSTOP << 8) | 0177;
2379 break;
2380 case PR_JOBCONTROL:
2381 statval = (what << 8) | 0177;
2382 break;
2383 case PR_FAULTED:
2384 switch (what)
2385 {
2386 #ifdef FLTWATCH
2387 case FLTWATCH:
2388 statval = (SIGTRAP << 8) | 0177;
2389 break;
2390 #endif
2391 #ifdef FLTKWATCH
2392 case FLTKWATCH:
2393 statval = (SIGTRAP << 8) | 0177;
2394 break;
2395 #endif
2396 #ifndef FAULTED_USE_SIGINFO
2397 /* Irix, contrary to the documentation, fills in 0 for si_signo.
2398 Solaris fills in si_signo. I'm not sure about others. */
2399 case FLTPRIV:
2400 case FLTILL:
2401 statval = (SIGILL << 8) | 0177;
2402 break;
2403 case FLTBPT:
2404 case FLTTRACE:
2405 statval = (SIGTRAP << 8) | 0177;
2406 break;
2407 case FLTSTACK:
2408 case FLTACCESS:
2409 case FLTBOUNDS:
2410 statval = (SIGSEGV << 8) | 0177;
2411 break;
2412 case FLTIOVF:
2413 case FLTIZDIV:
2414 case FLTFPE:
2415 statval = (SIGFPE << 8) | 0177;
2416 break;
2417 case FLTPAGE: /* Recoverable page fault */
2418 #endif /* not FAULTED_USE_SIGINFO */
2419 default:
2420 /* Use the signal which the kernel assigns. This is better than
2421 trying to second-guess it from the fault. In fact, I suspect
2422 that FLTACCESS can be either SIGSEGV or SIGBUS. */
2423 statval = ((pi->prstatus.pr_info.si_signo) << 8) | 0177;
2424 break;
2425 }
2426 break;
2427 default:
2428 error ("PIOCWSTOP, unknown why %d, what %d", why, what);
2429 }
2430 /* Stop all the other threads when any of them stops. */
2431
2432 {
2433 struct procinfo *procinfo;
2434
2435 for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
2436 {
2437 if (!procinfo->had_event)
2438 if (ioctl (procinfo->fd, PIOCSTOP, &procinfo->prstatus) < 0)
2439 {
2440 print_sys_errmsg (procinfo->pathname, errno);
2441 error ("PIOCSTOP failed");
2442 }
2443 }
2444 }
2445 }
2446 else
2447 {
2448 error ("PIOCWSTOP, stopped for unknown/unhandled reason, flags %#x",
2449 pi->prstatus.pr_flags);
2450 }
2451
2452 store_waitstatus (ourstatus, statval);
2453
2454 if (rtnval == -1) /* No more children to wait for */
2455 {
2456 fprintf_unfiltered (gdb_stderr, "Child process unexpectedly missing.\n");
2457 /* Claim it exited with unknown signal. */
2458 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
2459 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
2460 return rtnval;
2461 }
2462
2463 pi->had_event = 0; /* Indicate that we've seen this one */
2464 return (rtnval);
2465 }
2466
2467 /*
2468
2469 LOCAL FUNCTION
2470
2471 set_proc_siginfo - set a process's current signal info
2472
2473 SYNOPSIS
2474
2475 void set_proc_siginfo (struct procinfo *pip, int signo);
2476
2477 DESCRIPTION
2478
2479 Given a pointer to a process info struct in PIP and a signal number
2480 in SIGNO, set the process's current signal and its associated signal
2481 information. The signal will be delivered to the process immediately
2482 after execution is resumed, even if it is being held. In addition,
2483 this particular delivery will not cause another PR_SIGNALLED stop
2484 even if the signal is being traced.
2485
2486 If we are not delivering the same signal that the prstatus siginfo
2487 struct contains information about, then synthesize a siginfo struct
2488 to match the signal we are doing to deliver, make it of the type
2489 "generated by a user process", and send this synthesized copy. When
2490 used to set the inferior's signal state, this will be required if we
2491 are not currently stopped because of a traced signal, or if we decide
2492 to continue with a different signal.
2493
2494 Note that when continuing the inferior from a stop due to receipt
2495 of a traced signal, we either have set PRCSIG to clear the existing
2496 signal, or we have to call this function to do a PIOCSSIG with either
2497 the existing siginfo struct from pr_info, or one we have synthesized
2498 appropriately for the signal we want to deliver. Otherwise if the
2499 signal is still being traced, the inferior will immediately stop
2500 again.
2501
2502 See siginfo(5) for more details.
2503 */
2504
2505 static void
2506 set_proc_siginfo (pip, signo)
2507 struct procinfo *pip;
2508 int signo;
2509 {
2510 struct siginfo newsiginfo;
2511 struct siginfo *sip;
2512
2513 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
2514 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
2515 receives a PIOCSSIG with a signal identical to the current signal,
2516 it messes up the current signal. Work around the kernel bug. */
2517 if (signo == pip -> prstatus.pr_cursig)
2518 return;
2519 #endif
2520
2521 if (signo == pip -> prstatus.pr_info.si_signo)
2522 {
2523 sip = &pip -> prstatus.pr_info;
2524 }
2525 else
2526 {
2527 memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
2528 sip = &newsiginfo;
2529 sip -> si_signo = signo;
2530 sip -> si_code = 0;
2531 sip -> si_errno = 0;
2532 sip -> si_pid = getpid ();
2533 sip -> si_uid = getuid ();
2534 }
2535 if (ioctl (pip -> fd, PIOCSSIG, sip) < 0)
2536 {
2537 print_sys_errmsg (pip -> pathname, errno);
2538 warning ("PIOCSSIG failed");
2539 }
2540 }
2541
2542 /* Resume execution of process PID. If STEP is nozero, then
2543 just single step it. If SIGNAL is nonzero, restart it with that
2544 signal activated. */
2545
2546 static void
2547 procfs_resume (pid, step, signo)
2548 int pid;
2549 int step;
2550 enum target_signal signo;
2551 {
2552 int signal_to_pass;
2553 struct procinfo *pi, *procinfo;
2554
2555 pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
2556
2557 errno = 0;
2558 pi->prrun.pr_flags = PRSTRACE | PRSFAULT | PRCFAULT;
2559
2560 #if 0
2561 /* It should not be necessary. If the user explicitly changes the value,
2562 value_assign calls write_register_bytes, which writes it. */
2563 /* It may not be absolutely necessary to specify the PC value for
2564 restarting, but to be safe we use the value that gdb considers
2565 to be current. One case where this might be necessary is if the
2566 user explicitly changes the PC value that gdb considers to be
2567 current. FIXME: Investigate if this is necessary or not. */
2568
2569 #ifdef PRSVADDR_BROKEN
2570 /* Can't do this under Solaris running on a Sparc, as there seems to be no
2571 place to put nPC. In fact, if you use this, nPC seems to be set to some
2572 random garbage. We have to rely on the fact that PC and nPC have been
2573 written previously via PIOCSREG during a register flush. */
2574
2575 pi->prrun.pr_vaddr = (caddr_t) *(int *) &registers[REGISTER_BYTE (PC_REGNUM)];
2576 pi->prrun.pr_flags != PRSVADDR;
2577 #endif
2578 #endif
2579
2580 if (signo == TARGET_SIGNAL_STOP && pi->nopass_next_sigstop)
2581 /* When attaching to a child process, if we forced it to stop with
2582 a PIOCSTOP, then we will have set the nopass_next_sigstop flag.
2583 Upon resuming the first time after such a stop, we explicitly
2584 inhibit sending it another SIGSTOP, which would be the normal
2585 result of default signal handling. One potential drawback to
2586 this is that we will also ignore any attempt to by the user
2587 to explicitly continue after the attach with a SIGSTOP. Ultimately
2588 this problem should be dealt with by making the routines that
2589 deal with the inferior a little smarter, and possibly even allow
2590 an inferior to continue running at the same time as gdb. (FIXME?) */
2591 signal_to_pass = 0;
2592 else if (signo == TARGET_SIGNAL_TSTP
2593 && pi->prstatus.pr_cursig == SIGTSTP
2594 && pi->prstatus.pr_action.sa_handler == SIG_DFL)
2595
2596 /* We are about to pass the inferior a SIGTSTP whose action is
2597 SIG_DFL. The SIG_DFL action for a SIGTSTP is to stop
2598 (notifying the parent via wait()), and then keep going from the
2599 same place when the parent is ready for you to keep going. So
2600 under the debugger, it should do nothing (as if the program had
2601 been stopped and then later resumed. Under ptrace, this
2602 happens for us, but under /proc, the system obligingly stops
2603 the process, and wait_for_inferior would have no way of
2604 distinguishing that type of stop (which indicates that we
2605 should just start it again), with a stop due to the pr_trace
2606 field of the prrun_t struct.
2607
2608 Note that if the SIGTSTP is being caught, we *do* need to pass it,
2609 because the handler needs to get executed. */
2610 signal_to_pass = 0;
2611 else
2612 signal_to_pass = target_signal_to_host (signo);
2613
2614 if (signal_to_pass)
2615 {
2616 set_proc_siginfo (pi, signal_to_pass);
2617 }
2618 else
2619 {
2620 pi->prrun.pr_flags |= PRCSIG;
2621 }
2622 pi->nopass_next_sigstop = 0;
2623 if (step)
2624 {
2625 pi->prrun.pr_flags |= PRSTEP;
2626 }
2627 if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
2628 {
2629 perror_with_name (pi->pathname);
2630 /* NOTREACHED */
2631 }
2632
2633 pi->had_event = 0;
2634
2635 /* Continue all the other threads that haven't had an event of
2636 interest. */
2637
2638 if (pid == -1)
2639 for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
2640 {
2641 if (pi != procinfo && !procinfo->had_event)
2642 {
2643 procinfo->prrun.pr_flags &= PRSTEP;
2644 procinfo->prrun.pr_flags |= PRCFAULT | PRCSIG;
2645 ioctl (procinfo->fd, PIOCSTATUS, &procinfo->prstatus);
2646 if (ioctl (procinfo->fd, PIOCRUN, &procinfo->prrun) < 0)
2647 {
2648 if (ioctl (procinfo->fd, PIOCSTATUS, &procinfo->prstatus) < 0)
2649 {
2650 fprintf_unfiltered(gdb_stderr, "PIOCSTATUS failed, errno=%d\n", errno);
2651 }
2652 print_sys_errmsg (procinfo->pathname, errno);
2653 error ("PIOCRUN failed");
2654 }
2655 ioctl (procinfo->fd, PIOCSTATUS, &procinfo->prstatus);
2656 }
2657 }
2658 }
2659
2660 /*
2661
2662 LOCAL FUNCTION
2663
2664 procfs_fetch_registers -- fetch current registers from inferior
2665
2666 SYNOPSIS
2667
2668 void procfs_fetch_registers (int regno)
2669
2670 DESCRIPTION
2671
2672 Read the current values of the inferior's registers, both the
2673 general register set and floating point registers (if supported)
2674 and update gdb's idea of their current values.
2675
2676 */
2677
2678 static void
2679 procfs_fetch_registers (regno)
2680 int regno;
2681 {
2682 struct procinfo *pi;
2683
2684 pi = current_procinfo;
2685
2686 if (ioctl (pi->fd, PIOCGREG, &pi->gregset) != -1)
2687 {
2688 supply_gregset (&pi->gregset);
2689 }
2690 #if defined (FP0_REGNUM)
2691 if (ioctl (pi->fd, PIOCGFPREG, &pi->fpregset) != -1)
2692 {
2693 supply_fpregset (&pi->fpregset);
2694 }
2695 #endif
2696 }
2697
2698 /*
2699
2700 LOCAL FUNCTION
2701
2702 proc_init_failed - called whenever /proc access initialization
2703 fails
2704
2705 SYNOPSIS
2706
2707 static void proc_init_failed (struct procinfo *pi, char *why)
2708
2709 DESCRIPTION
2710
2711 This function is called whenever initialization of access to a /proc
2712 entry fails. It prints a suitable error message, does some cleanup,
2713 and then invokes the standard error processing routine which dumps
2714 us back into the command loop.
2715 */
2716
2717 static void
2718 proc_init_failed (pi, why)
2719 struct procinfo *pi;
2720 char *why;
2721 {
2722 print_sys_errmsg (pi->pathname, errno);
2723 kill (pi->pid, SIGKILL);
2724 close_proc_file (pi);
2725 error (why);
2726 /* NOTREACHED */
2727 }
2728
2729 /*
2730
2731 LOCAL FUNCTION
2732
2733 close_proc_file - close any currently open /proc entry
2734
2735 SYNOPSIS
2736
2737 static void close_proc_file (struct procinfo *pip)
2738
2739 DESCRIPTION
2740
2741 Close any currently open /proc entry and mark the process information
2742 entry as invalid. In order to ensure that we don't try to reuse any
2743 stale information, the pid, fd, and pathnames are explicitly
2744 invalidated, which may be overkill.
2745
2746 */
2747
2748 static void
2749 close_proc_file (pip)
2750 struct procinfo *pip;
2751 {
2752 struct procinfo *procinfo;
2753
2754 remove_fd (pip); /* Remove fd from poll/select list */
2755
2756 close (pip -> fd);
2757
2758 free (pip -> pathname);
2759
2760 /* Unlink pip from the procinfo chain. Note pip might not be on the list. */
2761
2762 if (procinfo_list == pip)
2763 procinfo_list = pip->next;
2764 else
2765 for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
2766 if (procinfo->next == pip)
2767 procinfo->next = pip->next;
2768
2769 free (pip);
2770 }
2771
2772 /*
2773
2774 LOCAL FUNCTION
2775
2776 open_proc_file - open a /proc entry for a given process id
2777
2778 SYNOPSIS
2779
2780 static int open_proc_file (int pid, struct procinfo *pip, int mode)
2781
2782 DESCRIPTION
2783
2784 Given a process id and a mode, close the existing open /proc
2785 entry (if any) and open one for the new process id, in the
2786 specified mode. Once it is open, then mark the local process
2787 information structure as valid, which guarantees that the pid,
2788 fd, and pathname fields match an open /proc entry. Returns
2789 zero if the open fails, nonzero otherwise.
2790
2791 Note that the pathname is left intact, even when the open fails,
2792 so that callers can use it to construct meaningful error messages
2793 rather than just "file open failed".
2794 */
2795
2796 static int
2797 open_proc_file (pid, pip, mode)
2798 int pid;
2799 struct procinfo *pip;
2800 int mode;
2801 {
2802 pip -> next = NULL;
2803 pip -> had_event = 0;
2804 pip -> pathname = xmalloc (32);
2805 pip -> pid = pid;
2806
2807 sprintf (pip -> pathname, PROC_NAME_FMT, pid);
2808 if ((pip -> fd = open (pip -> pathname, mode)) < 0)
2809 return 0;
2810
2811 return 1;
2812 }
2813
2814 static char *
2815 mappingflags (flags)
2816 long flags;
2817 {
2818 static char asciiflags[8];
2819
2820 strcpy (asciiflags, "-------");
2821 #if defined (MA_PHYS)
2822 if (flags & MA_PHYS) asciiflags[0] = 'd';
2823 #endif
2824 if (flags & MA_STACK) asciiflags[1] = 's';
2825 if (flags & MA_BREAK) asciiflags[2] = 'b';
2826 if (flags & MA_SHARED) asciiflags[3] = 's';
2827 if (flags & MA_READ) asciiflags[4] = 'r';
2828 if (flags & MA_WRITE) asciiflags[5] = 'w';
2829 if (flags & MA_EXEC) asciiflags[6] = 'x';
2830 return (asciiflags);
2831 }
2832
2833 static void
2834 info_proc_flags (pip, summary)
2835 struct procinfo *pip;
2836 int summary;
2837 {
2838 struct trans *transp;
2839
2840 printf_filtered ("%-32s", "Process status flags:");
2841 if (!summary)
2842 {
2843 printf_filtered ("\n\n");
2844 }
2845 for (transp = pr_flag_table; transp -> name != NULL; transp++)
2846 {
2847 if (pip -> prstatus.pr_flags & transp -> value)
2848 {
2849 if (summary)
2850 {
2851 printf_filtered ("%s ", transp -> name);
2852 }
2853 else
2854 {
2855 printf_filtered ("\t%-16s %s.\n", transp -> name, transp -> desc);
2856 }
2857 }
2858 }
2859 printf_filtered ("\n");
2860 }
2861
2862 static void
2863 info_proc_stop (pip, summary)
2864 struct procinfo *pip;
2865 int summary;
2866 {
2867 struct trans *transp;
2868 int why;
2869 int what;
2870
2871 why = pip -> prstatus.pr_why;
2872 what = pip -> prstatus.pr_what;
2873
2874 if (pip -> prstatus.pr_flags & PR_STOPPED)
2875 {
2876 printf_filtered ("%-32s", "Reason for stopping:");
2877 if (!summary)
2878 {
2879 printf_filtered ("\n\n");
2880 }
2881 for (transp = pr_why_table; transp -> name != NULL; transp++)
2882 {
2883 if (why == transp -> value)
2884 {
2885 if (summary)
2886 {
2887 printf_filtered ("%s ", transp -> name);
2888 }
2889 else
2890 {
2891 printf_filtered ("\t%-16s %s.\n",
2892 transp -> name, transp -> desc);
2893 }
2894 break;
2895 }
2896 }
2897
2898 /* Use the pr_why field to determine what the pr_what field means, and
2899 print more information. */
2900
2901 switch (why)
2902 {
2903 case PR_REQUESTED:
2904 /* pr_what is unused for this case */
2905 break;
2906 case PR_JOBCONTROL:
2907 case PR_SIGNALLED:
2908 if (summary)
2909 {
2910 printf_filtered ("%s ", signalname (what));
2911 }
2912 else
2913 {
2914 printf_filtered ("\t%-16s %s.\n", signalname (what),
2915 safe_strsignal (what));
2916 }
2917 break;
2918 case PR_SYSENTRY:
2919 if (summary)
2920 {
2921 printf_filtered ("%s ", syscallname (what));
2922 }
2923 else
2924 {
2925 printf_filtered ("\t%-16s %s.\n", syscallname (what),
2926 "Entered this system call");
2927 }
2928 break;
2929 case PR_SYSEXIT:
2930 if (summary)
2931 {
2932 printf_filtered ("%s ", syscallname (what));
2933 }
2934 else
2935 {
2936 printf_filtered ("\t%-16s %s.\n", syscallname (what),
2937 "Returned from this system call");
2938 }
2939 break;
2940 case PR_FAULTED:
2941 if (summary)
2942 {
2943 printf_filtered ("%s ",
2944 lookupname (faults_table, what, "fault"));
2945 }
2946 else
2947 {
2948 printf_filtered ("\t%-16s %s.\n",
2949 lookupname (faults_table, what, "fault"),
2950 lookupdesc (faults_table, what));
2951 }
2952 break;
2953 }
2954 printf_filtered ("\n");
2955 }
2956 }
2957
2958 static void
2959 info_proc_siginfo (pip, summary)
2960 struct procinfo *pip;
2961 int summary;
2962 {
2963 struct siginfo *sip;
2964
2965 if ((pip -> prstatus.pr_flags & PR_STOPPED) &&
2966 (pip -> prstatus.pr_why == PR_SIGNALLED ||
2967 pip -> prstatus.pr_why == PR_FAULTED))
2968 {
2969 printf_filtered ("%-32s", "Additional signal/fault info:");
2970 sip = &pip -> prstatus.pr_info;
2971 if (summary)
2972 {
2973 printf_filtered ("%s ", signalname (sip -> si_signo));
2974 if (sip -> si_errno > 0)
2975 {
2976 printf_filtered ("%s ", errnoname (sip -> si_errno));
2977 }
2978 if (sip -> si_code <= 0)
2979 {
2980 printf_filtered ("sent by %s, uid %d ",
2981 target_pid_to_str (sip -> si_pid),
2982 sip -> si_uid);
2983 }
2984 else
2985 {
2986 printf_filtered ("%s ", sigcodename (sip));
2987 if ((sip -> si_signo == SIGILL) ||
2988 (sip -> si_signo == SIGFPE) ||
2989 (sip -> si_signo == SIGSEGV) ||
2990 (sip -> si_signo == SIGBUS))
2991 {
2992 printf_filtered ("addr=%#lx ",
2993 (unsigned long) sip -> si_addr);
2994 }
2995 else if ((sip -> si_signo == SIGCHLD))
2996 {
2997 printf_filtered ("child %s, status %u ",
2998 target_pid_to_str (sip -> si_pid),
2999 sip -> si_status);
3000 }
3001 else if ((sip -> si_signo == SIGPOLL))
3002 {
3003 printf_filtered ("band %u ", sip -> si_band);
3004 }
3005 }
3006 }
3007 else
3008 {
3009 printf_filtered ("\n\n");
3010 printf_filtered ("\t%-16s %s.\n", signalname (sip -> si_signo),
3011 safe_strsignal (sip -> si_signo));
3012 if (sip -> si_errno > 0)
3013 {
3014 printf_filtered ("\t%-16s %s.\n",
3015 errnoname (sip -> si_errno),
3016 safe_strerror (sip -> si_errno));
3017 }
3018 if (sip -> si_code <= 0)
3019 {
3020 printf_filtered ("\t%-16u %s\n", sip -> si_pid, /* XXX need target_pid_to_str() */
3021 "PID of process sending signal");
3022 printf_filtered ("\t%-16u %s\n", sip -> si_uid,
3023 "UID of process sending signal");
3024 }
3025 else
3026 {
3027 printf_filtered ("\t%-16s %s.\n", sigcodename (sip),
3028 sigcodedesc (sip));
3029 if ((sip -> si_signo == SIGILL) ||
3030 (sip -> si_signo == SIGFPE))
3031 {
3032 printf_filtered ("\t%#-16lx %s.\n",
3033 (unsigned long) sip -> si_addr,
3034 "Address of faulting instruction");
3035 }
3036 else if ((sip -> si_signo == SIGSEGV) ||
3037 (sip -> si_signo == SIGBUS))
3038 {
3039 printf_filtered ("\t%#-16lx %s.\n",
3040 (unsigned long) sip -> si_addr,
3041 "Address of faulting memory reference");
3042 }
3043 else if ((sip -> si_signo == SIGCHLD))
3044 {
3045 printf_filtered ("\t%-16u %s.\n", sip -> si_pid, /* XXX need target_pid_to_str() */
3046 "Child process ID");
3047 printf_filtered ("\t%-16u %s.\n", sip -> si_status,
3048 "Child process exit value or signal");
3049 }
3050 else if ((sip -> si_signo == SIGPOLL))
3051 {
3052 printf_filtered ("\t%-16u %s.\n", sip -> si_band,
3053 "Band event for POLL_{IN,OUT,MSG}");
3054 }
3055 }
3056 }
3057 printf_filtered ("\n");
3058 }
3059 }
3060
3061 static void
3062 info_proc_syscalls (pip, summary)
3063 struct procinfo *pip;
3064 int summary;
3065 {
3066 int syscallnum;
3067
3068 if (!summary)
3069 {
3070
3071 #if 0 /* FIXME: Needs to use gdb-wide configured info about system calls. */
3072 if (pip -> prstatus.pr_flags & PR_ASLEEP)
3073 {
3074 int syscallnum = pip -> prstatus.pr_reg[R_D0];
3075 if (summary)
3076 {
3077 printf_filtered ("%-32s", "Sleeping in system call:");
3078 printf_filtered ("%s", syscallname (syscallnum));
3079 }
3080 else
3081 {
3082 printf_filtered ("Sleeping in system call '%s'.\n",
3083 syscallname (syscallnum));
3084 }
3085 }
3086 #endif
3087
3088 if (ioctl (pip -> fd, PIOCGENTRY, &pip -> entryset) < 0)
3089 {
3090 print_sys_errmsg (pip -> pathname, errno);
3091 error ("PIOCGENTRY failed");
3092 }
3093
3094 if (ioctl (pip -> fd, PIOCGEXIT, &pip -> exitset) < 0)
3095 {
3096 print_sys_errmsg (pip -> pathname, errno);
3097 error ("PIOCGEXIT failed");
3098 }
3099
3100 printf_filtered ("System call tracing information:\n\n");
3101
3102 printf_filtered ("\t%-12s %-8s %-8s\n",
3103 "System call",
3104 "Entry",
3105 "Exit");
3106 for (syscallnum = 0; syscallnum < MAX_SYSCALLS; syscallnum++)
3107 {
3108 QUIT;
3109 if (syscall_table[syscallnum] != NULL)
3110 {
3111 printf_filtered ("\t%-12s ", syscall_table[syscallnum]);
3112 printf_filtered ("%-8s ",
3113 prismember (&pip -> entryset, syscallnum)
3114 ? "on" : "off");
3115 printf_filtered ("%-8s ",
3116 prismember (&pip -> exitset, syscallnum)
3117 ? "on" : "off");
3118 printf_filtered ("\n");
3119 }
3120 }
3121 printf_filtered ("\n");
3122 }
3123 }
3124
3125 static char *
3126 signalname (signo)
3127 int signo;
3128 {
3129 const char *name;
3130 static char locbuf[32];
3131
3132 name = strsigno (signo);
3133 if (name == NULL)
3134 {
3135 sprintf (locbuf, "Signal %d", signo);
3136 }
3137 else
3138 {
3139 sprintf (locbuf, "%s (%d)", name, signo);
3140 }
3141 return (locbuf);
3142 }
3143
3144 static char *
3145 errnoname (errnum)
3146 int errnum;
3147 {
3148 const char *name;
3149 static char locbuf[32];
3150
3151 name = strerrno (errnum);
3152 if (name == NULL)
3153 {
3154 sprintf (locbuf, "Errno %d", errnum);
3155 }
3156 else
3157 {
3158 sprintf (locbuf, "%s (%d)", name, errnum);
3159 }
3160 return (locbuf);
3161 }
3162
3163 static void
3164 info_proc_signals (pip, summary)
3165 struct procinfo *pip;
3166 int summary;
3167 {
3168 int signo;
3169
3170 if (!summary)
3171 {
3172 if (ioctl (pip -> fd, PIOCGTRACE, &pip -> trace) < 0)
3173 {
3174 print_sys_errmsg (pip -> pathname, errno);
3175 error ("PIOCGTRACE failed");
3176 }
3177
3178 printf_filtered ("Disposition of signals:\n\n");
3179 printf_filtered ("\t%-15s %-8s %-8s %-8s %s\n\n",
3180 "Signal", "Trace", "Hold", "Pending", "Description");
3181 for (signo = 0; signo < NSIG; signo++)
3182 {
3183 QUIT;
3184 printf_filtered ("\t%-15s ", signalname (signo));
3185 printf_filtered ("%-8s ",
3186 prismember (&pip -> trace, signo)
3187 ? "on" : "off");
3188 printf_filtered ("%-8s ",
3189 prismember (&pip -> prstatus.pr_sighold, signo)
3190 ? "on" : "off");
3191
3192 #ifdef PROCFS_SIGPEND_OFFSET
3193 /* Alpha OSF/1 numbers the pending signals from 1. */
3194 printf_filtered ("%-8s ",
3195 (signo ? prismember (&pip -> prstatus.pr_sigpend,
3196 signo - 1)
3197 : 0)
3198 ? "yes" : "no");
3199 #else
3200 printf_filtered ("%-8s ",
3201 prismember (&pip -> prstatus.pr_sigpend, signo)
3202 ? "yes" : "no");
3203 #endif
3204 printf_filtered (" %s\n", safe_strsignal (signo));
3205 }
3206 printf_filtered ("\n");
3207 }
3208 }
3209
3210 static void
3211 info_proc_faults (pip, summary)
3212 struct procinfo *pip;
3213 int summary;
3214 {
3215 struct trans *transp;
3216
3217 if (!summary)
3218 {
3219 if (ioctl (pip -> fd, PIOCGFAULT, &pip -> fltset) < 0)
3220 {
3221 print_sys_errmsg (pip -> pathname, errno);
3222 error ("PIOCGFAULT failed");
3223 }
3224
3225 printf_filtered ("Current traced hardware fault set:\n\n");
3226 printf_filtered ("\t%-12s %-8s\n", "Fault", "Trace");
3227
3228 for (transp = faults_table; transp -> name != NULL; transp++)
3229 {
3230 QUIT;
3231 printf_filtered ("\t%-12s ", transp -> name);
3232 printf_filtered ("%-8s", prismember (&pip -> fltset, transp -> value)
3233 ? "on" : "off");
3234 printf_filtered ("\n");
3235 }
3236 printf_filtered ("\n");
3237 }
3238 }
3239
3240 static void
3241 info_proc_mappings (pip, summary)
3242 struct procinfo *pip;
3243 int summary;
3244 {
3245 int nmap;
3246 struct prmap *prmaps;
3247 struct prmap *prmap;
3248
3249 if (!summary)
3250 {
3251 printf_filtered ("Mapped address spaces:\n\n");
3252 #ifdef BFD_HOST_64_BIT
3253 printf_filtered (" %18s %18s %10s %10s %7s\n",
3254 #else
3255 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
3256 #endif
3257 "Start Addr",
3258 " End Addr",
3259 " Size",
3260 " Offset",
3261 "Flags");
3262 if (ioctl (pip -> fd, PIOCNMAP, &nmap) == 0)
3263 {
3264 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
3265 if (ioctl (pip -> fd, PIOCMAP, prmaps) == 0)
3266 {
3267 for (prmap = prmaps; prmap -> pr_size; ++prmap)
3268 {
3269 #ifdef BFD_HOST_64_BIT
3270 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
3271 #else
3272 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
3273 #endif
3274 (unsigned long)prmap -> pr_vaddr,
3275 (unsigned long)prmap -> pr_vaddr
3276 + prmap -> pr_size - 1,
3277 prmap -> pr_size,
3278 prmap -> pr_off,
3279 mappingflags (prmap -> pr_mflags));
3280 }
3281 }
3282 }
3283 printf_filtered ("\n");
3284 }
3285 }
3286
3287 /*
3288
3289 LOCAL FUNCTION
3290
3291 info_proc -- implement the "info proc" command
3292
3293 SYNOPSIS
3294
3295 void info_proc (char *args, int from_tty)
3296
3297 DESCRIPTION
3298
3299 Implement gdb's "info proc" command by using the /proc interface
3300 to print status information about any currently running process.
3301
3302 Examples of the use of "info proc" are:
3303
3304 info proc (prints summary info for current inferior)
3305 info proc 123 (prints summary info for process with pid 123)
3306 info proc mappings (prints address mappings)
3307 info proc times (prints process/children times)
3308 info proc id (prints pid, ppid, gid, sid, etc)
3309 FIXME: i proc id not implemented.
3310 info proc status (prints general process state info)
3311 FIXME: i proc status not implemented.
3312 info proc signals (prints info about signal handling)
3313 info proc all (prints all info)
3314
3315 */
3316
3317 static void
3318 info_proc (args, from_tty)
3319 char *args;
3320 int from_tty;
3321 {
3322 int pid;
3323 struct procinfo *pip;
3324 struct cleanup *old_chain;
3325 char **argv;
3326 int argsize;
3327 int summary = 1;
3328 int flags = 0;
3329 int syscalls = 0;
3330 int signals = 0;
3331 int faults = 0;
3332 int mappings = 0;
3333 int times = 0;
3334 int id = 0;
3335 int status = 0;
3336 int all = 0;
3337
3338 old_chain = make_cleanup (null_cleanup, 0);
3339
3340 /* Default to using the current inferior if no pid specified. Note
3341 that inferior_pid may be 0, hence we set okerr. */
3342
3343 pip = find_procinfo (inferior_pid, 1);
3344
3345 if (args != NULL)
3346 {
3347 if ((argv = buildargv (args)) == NULL)
3348 {
3349 nomem (0);
3350 }
3351 make_cleanup (freeargv, (char *) argv);
3352
3353 while (*argv != NULL)
3354 {
3355 argsize = strlen (*argv);
3356 if (argsize >= 1 && strncmp (*argv, "all", argsize) == 0)
3357 {
3358 summary = 0;
3359 all = 1;
3360 }
3361 else if (argsize >= 2 && strncmp (*argv, "faults", argsize) == 0)
3362 {
3363 summary = 0;
3364 faults = 1;
3365 }
3366 else if (argsize >= 2 && strncmp (*argv, "flags", argsize) == 0)
3367 {
3368 summary = 0;
3369 flags = 1;
3370 }
3371 else if (argsize >= 1 && strncmp (*argv, "id", argsize) == 0)
3372 {
3373 summary = 0;
3374 id = 1;
3375 }
3376 else if (argsize >= 1 && strncmp (*argv, "mappings", argsize) == 0)
3377 {
3378 summary = 0;
3379 mappings = 1;
3380 }
3381 else if (argsize >= 2 && strncmp (*argv, "signals", argsize) == 0)
3382 {
3383 summary = 0;
3384 signals = 1;
3385 }
3386 else if (argsize >= 2 && strncmp (*argv, "status", argsize) == 0)
3387 {
3388 summary = 0;
3389 status = 1;
3390 }
3391 else if (argsize >= 2 && strncmp (*argv, "syscalls", argsize) == 0)
3392 {
3393 summary = 0;
3394 syscalls = 1;
3395 }
3396 else if (argsize >= 1 && strncmp (*argv, "times", argsize) == 0)
3397 {
3398 summary = 0;
3399 times = 1;
3400 }
3401 else if ((pid = atoi (*argv)) > 0)
3402 {
3403 pip = (struct procinfo *) xmalloc (sizeof (struct procinfo));
3404 memset (pip, 0, sizeof (*pip));
3405
3406 pip->pid = pid;
3407 if (!open_proc_file (pid, pip, O_RDONLY))
3408 {
3409 perror_with_name (pip -> pathname);
3410 /* NOTREACHED */
3411 }
3412 make_cleanup (close_proc_file, pip);
3413 }
3414 else if (**argv != '\000')
3415 {
3416 error ("Unrecognized or ambiguous keyword `%s'.", *argv);
3417 }
3418 argv++;
3419 }
3420 }
3421
3422 /* If we don't have a valid open process at this point, then we have no
3423 inferior or didn't specify a specific pid. */
3424
3425 if (!pip)
3426 {
3427 error ("\
3428 No process. Start debugging a program or specify an explicit process ID.");
3429 }
3430 if (ioctl (pip -> fd, PIOCSTATUS, &(pip -> prstatus)) < 0)
3431 {
3432 print_sys_errmsg (pip -> pathname, errno);
3433 error ("PIOCSTATUS failed");
3434 }
3435
3436 /* Print verbose information of the requested type(s), or just a summary
3437 of the information for all types. */
3438
3439 printf_filtered ("\nInformation for %s:\n\n", pip -> pathname);
3440 if (summary || all || flags)
3441 {
3442 info_proc_flags (pip, summary);
3443 }
3444 if (summary || all)
3445 {
3446 info_proc_stop (pip, summary);
3447 }
3448 if (summary || all || signals || faults)
3449 {
3450 info_proc_siginfo (pip, summary);
3451 }
3452 if (summary || all || syscalls)
3453 {
3454 info_proc_syscalls (pip, summary);
3455 }
3456 if (summary || all || mappings)
3457 {
3458 info_proc_mappings (pip, summary);
3459 }
3460 if (summary || all || signals)
3461 {
3462 info_proc_signals (pip, summary);
3463 }
3464 if (summary || all || faults)
3465 {
3466 info_proc_faults (pip, summary);
3467 }
3468 printf_filtered ("\n");
3469
3470 /* All done, deal with closing any temporary process info structure,
3471 freeing temporary memory , etc. */
3472
3473 do_cleanups (old_chain);
3474 }
3475
3476 /*
3477
3478 LOCAL FUNCTION
3479
3480 procfs_set_sproc_trap -- arrange for child to stop on sproc().
3481
3482 SYNOPSIS
3483
3484 void procfs_set_sproc_trap (struct procinfo *)
3485
3486 DESCRIPTION
3487
3488 This function sets up a trap on sproc system call exits so that we can
3489 detect the arrival of a new thread. We are called with the new thread
3490 stopped prior to it's first instruction.
3491
3492 Also note that we turn on the inherit-on-fork flag in the child process
3493 so that any grand-children start with all tracing flags set.
3494 */
3495
3496 #ifdef SYS_sproc
3497
3498 static void
3499 procfs_set_sproc_trap (pi)
3500 struct procinfo *pi;
3501 {
3502 sysset_t exitset;
3503
3504 if (ioctl (pi->fd, PIOCGEXIT, &exitset) < 0)
3505 {
3506 print_sys_errmsg (pi->pathname, errno);
3507 error ("PIOCGEXIT failed");
3508 }
3509
3510 praddset (&exitset, SYS_sproc);
3511
3512 /* We trap on fork() and vfork() in order to disable debugging in our grand-
3513 children and descendant processes. At this time, GDB can only handle
3514 threads (multiple processes, one address space). forks (and execs) result
3515 in the creation of multiple address spaces, which GDB can't handle yet. */
3516
3517 praddset (&exitset, SYS_fork);
3518 #ifdef SYS_vfork
3519 praddset (&exitset, SYS_vfork);
3520 #endif
3521
3522 if (ioctl (pi->fd, PIOCSEXIT, &exitset) < 0)
3523 {
3524 print_sys_errmsg (pi->pathname, errno);
3525 error ("PIOCSEXIT failed");
3526 }
3527
3528 /* Turn on inherit-on-fork flag so that all grand-children of gdb start with
3529 tracing flags set. */
3530
3531 #ifdef PIOCSET /* New method */
3532 {
3533 long pr_flags;
3534 pr_flags = PR_FORK;
3535 ioctl (pi->fd, PIOCSET, &pr_flags);
3536 }
3537 #else
3538 #ifdef PIOCSFORK /* Original method */
3539 ioctl (pi->fd, PIOCSFORK, NULL);
3540 #endif
3541 #endif
3542 }
3543 #endif /* SYS_sproc */
3544
3545 /* Fork an inferior process, and start debugging it with /proc. */
3546
3547 static void
3548 procfs_create_inferior (exec_file, allargs, env)
3549 char *exec_file;
3550 char *allargs;
3551 char **env;
3552 {
3553 char *shell_file = getenv ("SHELL");
3554 char *tryname;
3555 if (shell_file != NULL && strchr (shell_file, '/') == NULL)
3556 {
3557
3558 /* We will be looking down the PATH to find shell_file. If we
3559 just do this the normal way (via execlp, which operates by
3560 attempting an exec for each element of the PATH until it
3561 finds one which succeeds), then there will be an exec for
3562 each failed attempt, each of which will cause a PR_SYSEXIT
3563 stop, and we won't know how to distinguish the PR_SYSEXIT's
3564 for these failed execs with the ones for successful execs
3565 (whether the exec has succeeded is stored at that time in the
3566 carry bit or some such architecture-specific and
3567 non-ABI-specified place).
3568
3569 So I can't think of anything better than to search the PATH
3570 now. This has several disadvantages: (1) There is a race
3571 condition; if we find a file now and it is deleted before we
3572 exec it, we lose, even if the deletion leaves a valid file
3573 further down in the PATH, (2) there is no way to know exactly
3574 what an executable (in the sense of "capable of being
3575 exec'd") file is. Using access() loses because it may lose
3576 if the caller is the superuser; failing to use it loses if
3577 there are ACLs or some such. */
3578
3579 char *p;
3580 char *p1;
3581 /* FIXME-maybe: might want "set path" command so user can change what
3582 path is used from within GDB. */
3583 char *path = getenv ("PATH");
3584 int len;
3585 struct stat statbuf;
3586
3587 if (path == NULL)
3588 path = "/bin:/usr/bin";
3589
3590 tryname = alloca (strlen (path) + strlen (shell_file) + 2);
3591 for (p = path; p != NULL; p = p1 ? p1 + 1: NULL)
3592 {
3593 p1 = strchr (p, ':');
3594 if (p1 != NULL)
3595 len = p1 - p;
3596 else
3597 len = strlen (p);
3598 strncpy (tryname, p, len);
3599 tryname[len] = '\0';
3600 strcat (tryname, "/");
3601 strcat (tryname, shell_file);
3602 if (access (tryname, X_OK) < 0)
3603 continue;
3604 if (stat (tryname, &statbuf) < 0)
3605 continue;
3606 if (!S_ISREG (statbuf.st_mode))
3607 /* We certainly need to reject directories. I'm not quite
3608 as sure about FIFOs, sockets, etc., but I kind of doubt
3609 that people want to exec() these things. */
3610 continue;
3611 break;
3612 }
3613 if (p == NULL)
3614 /* Not found. This must be an error rather than merely passing
3615 the file to execlp(), because execlp() would try all the
3616 exec()s, causing GDB to get confused. */
3617 error ("Can't find shell %s in PATH", shell_file);
3618
3619 shell_file = tryname;
3620 }
3621
3622 fork_inferior (exec_file, allargs, env,
3623 proc_set_exec_trap, procfs_init_inferior, shell_file);
3624
3625 /* We are at the first instruction we care about. */
3626 /* Pedal to the metal... */
3627
3628 /* Setup traps on exit from sproc() */
3629
3630 #ifdef SYS_sproc
3631 procfs_set_sproc_trap (current_procinfo);
3632 #endif
3633
3634 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
3635 }
3636
3637 /* Clean up after the inferior dies. */
3638
3639 static void
3640 procfs_mourn_inferior ()
3641 {
3642 struct procinfo *pi;
3643 struct procinfo *next_pi;
3644
3645 for (pi = procinfo_list; pi; pi = next_pi)
3646 {
3647 next_pi = pi->next;
3648 unconditionally_kill_inferior (pi);
3649 }
3650
3651 unpush_target (&procfs_ops);
3652 generic_mourn_inferior ();
3653 }
3654
3655
3656 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
3657 static int
3658 procfs_can_run ()
3659 {
3660 return(1);
3661 }
3662 #ifdef TARGET_HAS_HARDWARE_WATCHPOINTS
3663 \f
3664 /* Insert a watchpoint */
3665 int
3666 procfs_set_watchpoint(pid, addr, len, rw)
3667 int pid;
3668 CORE_ADDR addr;
3669 int len;
3670 int rw;
3671 {
3672 struct procinfo *pi;
3673 prwatch_t wpt;
3674
3675 pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
3676 wpt.pr_vaddr = (caddr_t)addr;
3677 wpt.pr_size = len;
3678 wpt.pr_wflags = ((rw & 1) ? MA_READ : 0) | ((rw & 2) ? MA_WRITE : 0);
3679 if (ioctl (pi->fd, PIOCSWATCH, &wpt) < 0)
3680 {
3681 if (errno == E2BIG)
3682 return -1;
3683 /* Currently it sometimes happens that the same watchpoint gets
3684 deleted twice - don't die in this case (FIXME please) */
3685 if (errno == ESRCH && len == 0)
3686 return 0;
3687 print_sys_errmsg (pi->pathname, errno);
3688 error ("PIOCSWATCH failed");
3689 }
3690 return 0;
3691 }
3692
3693 int
3694 procfs_stopped_by_watchpoint(pid)
3695 int pid;
3696 {
3697 struct procinfo *pi;
3698 short what;
3699 short why;
3700
3701 pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
3702 if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
3703 {
3704 why = pi->prstatus.pr_why;
3705 what = pi->prstatus.pr_what;
3706 if (why == PR_FAULTED
3707 #if defined (FLTWATCH) && defined (FLTKWATCH)
3708 && (what == FLTWATCH) || (what == FLTKWATCH)
3709 #else
3710 #ifdef FLTWATCH
3711 && (what == FLTWATCH)
3712 #endif
3713 #ifdef FLTKWATCH
3714 && (what == FLTKWATCH)
3715 #endif
3716 #endif
3717 )
3718 return what;
3719 }
3720 return 0;
3721 }
3722 #endif
3723
3724 /* Send a SIGINT to the process group. This acts just like the user typed a
3725 ^C on the controlling terminal.
3726
3727 XXX - This may not be correct for all systems. Some may want to use
3728 killpg() instead of kill (-pgrp). */
3729
3730 void
3731 procfs_stop ()
3732 {
3733 extern pid_t inferior_process_group;
3734
3735 kill (-inferior_process_group, SIGINT);
3736 }
3737
3738 \f
3739 struct target_ops procfs_ops = {
3740 "procfs", /* to_shortname */
3741 "Unix /proc child process", /* to_longname */
3742 "Unix /proc child process (started by the \"run\" command).", /* to_doc */
3743 procfs_open, /* to_open */
3744 0, /* to_close */
3745 procfs_attach, /* to_attach */
3746 procfs_detach, /* to_detach */
3747 procfs_resume, /* to_resume */
3748 procfs_wait, /* to_wait */
3749 procfs_fetch_registers, /* to_fetch_registers */
3750 procfs_store_registers, /* to_store_registers */
3751 procfs_prepare_to_store, /* to_prepare_to_store */
3752 procfs_xfer_memory, /* to_xfer_memory */
3753 procfs_files_info, /* to_files_info */
3754 memory_insert_breakpoint, /* to_insert_breakpoint */
3755 memory_remove_breakpoint, /* to_remove_breakpoint */
3756 terminal_init_inferior, /* to_terminal_init */
3757 terminal_inferior, /* to_terminal_inferior */
3758 terminal_ours_for_output, /* to_terminal_ours_for_output */
3759 terminal_ours, /* to_terminal_ours */
3760 child_terminal_info, /* to_terminal_info */
3761 procfs_kill_inferior, /* to_kill */
3762 0, /* to_load */
3763 0, /* to_lookup_symbol */
3764 procfs_create_inferior, /* to_create_inferior */
3765 procfs_mourn_inferior, /* to_mourn_inferior */
3766 procfs_can_run, /* to_can_run */
3767 procfs_notice_signals, /* to_notice_signals */
3768 0 /* to_thread_alive */
3769 procfs_stop, /* to_stop */
3770 process_stratum, /* to_stratum */
3771 0, /* to_next */
3772 1, /* to_has_all_memory */
3773 1, /* to_has_memory */
3774 1, /* to_has_stack */
3775 1, /* to_has_registers */
3776 1, /* to_has_execution */
3777 0, /* sections */
3778 0, /* sections_end */
3779 OPS_MAGIC /* to_magic */
3780 };
3781
3782 void
3783 _initialize_procfs ()
3784 {
3785 #ifdef HAVE_OPTIONAL_PROC_FS
3786 char procname[32];
3787 int fd;
3788
3789 /* If we have an optional /proc filesystem (e.g. under OSF/1),
3790 don't add procfs support if we cannot access the running
3791 GDB via /proc. */
3792 sprintf (procname, PROC_NAME_FMT, getpid ());
3793 if ((fd = open (procname, O_RDONLY)) < 0)
3794 return;
3795 close (fd);
3796 #endif
3797
3798 add_target (&procfs_ops);
3799
3800 add_info ("proc", info_proc,
3801 "Show process status information using /proc entry.\n\
3802 Specify process id or use current inferior by default.\n\
3803 Specify keywords for detailed information; default is summary.\n\
3804 Keywords are: `all', `faults', `flags', `id', `mappings', `signals',\n\
3805 `status', `syscalls', and `times'.\n\
3806 Unambiguous abbreviations may be used.");
3807
3808 init_syscall_table ();
3809 }
GDB Binutils - Deliverables
This page took 0.1093 seconds and 4 git commands to generate.