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