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