GDB (xrefs)
/tmp/gdb-7.10/gdb/procfs.c
Go to the documentation of this file.
1 /* Machine independent support for SVR4 /proc (process file system) for GDB.
2 
3  Copyright (C) 1999-2015 Free Software Foundation, Inc.
4 
5  Written by Michael Snyder at Cygnus Solutions.
6  Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
7 
8  This file is part of GDB.
9 
10  This program is free software; you can redistribute it and/or modify
11  it under the terms of the GNU General Public License as published by
12  the Free Software Foundation; either version 3 of the License, or
13  (at your option) any later version.
14 
15  This program is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  GNU General Public License for more details.
19 
20  You should have received a copy of the GNU General Public License
21  along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 
23 #include "defs.h"
24 #include "inferior.h"
25 #include "infrun.h"
26 #include "target.h"
27 #include "gdbcore.h"
28 #include "elf-bfd.h" /* for elfcore_write_* */
29 #include "gdbcmd.h"
30 #include "gdbthread.h"
31 #include "regcache.h"
32 #include "inf-child.h"
33 #include "filestuff.h"
34 
35 #if defined (NEW_PROC_API)
36 #define _STRUCTURED_PROC 1 /* Should be done by configure script. */
37 #endif
38 
39 #include <sys/procfs.h>
40 #ifdef HAVE_SYS_FAULT_H
41 #include <sys/fault.h>
42 #endif
43 #ifdef HAVE_SYS_SYSCALL_H
44 #include <sys/syscall.h>
45 #endif
46 #include "gdb_wait.h"
47 #include <signal.h>
48 #include <ctype.h>
49 #include "gdb_bfd.h"
50 #include "inflow.h"
51 #include "auxv.h"
52 #include "procfs.h"
53 #include "observer.h"
54 
55 /* This module provides the interface between GDB and the
56  /proc file system, which is used on many versions of Unix
57  as a means for debuggers to control other processes.
58 
59  Examples of the systems that use this interface are:
60 
61  Irix
62  Solaris
63  OSF
64  AIX5
65 
66  /proc works by imitating a file system: you open a simulated file
67  that represents the process you wish to interact with, and perform
68  operations on that "file" in order to examine or change the state
69  of the other process.
70 
71  The most important thing to know about /proc and this module is
72  that there are two very different interfaces to /proc:
73 
74  One that uses the ioctl system call, and another that uses read
75  and write system calls.
76 
77  This module has to support both /proc interfaces. This means that
78  there are two different ways of doing every basic operation.
79 
80  In order to keep most of the code simple and clean, I have defined
81  an interface "layer" which hides all these system calls. An ifdef
82  (NEW_PROC_API) determines which interface we are using, and most or
83  all occurrances of this ifdef should be confined to this interface
84  layer. */
85 
86 /* Determine which /proc API we are using: The ioctl API defines
87  PIOCSTATUS, while the read/write (multiple fd) API never does. */
88 
89 #ifdef NEW_PROC_API
90 #include <sys/types.h>
91 #include <dirent.h> /* opendir/readdir, for listing the LWP's */
92 #endif
93 
94 #include <fcntl.h> /* for O_RDONLY */
95 #include <unistd.h> /* for "X_OK" */
96 #include <sys/stat.h> /* for struct stat */
97 
98 /* Note: procfs-utils.h must be included after the above system header
99  files, because it redefines various system calls using macros.
100  This may be incompatible with the prototype declarations. */
101 
102 #include "proc-utils.h"
103 
104 /* Prototypes for supply_gregset etc. */
105 #include "gregset.h"
106 
107 /* =================== TARGET_OPS "MODULE" =================== */
108 
109 /* This module defines the GDB target vector and its methods. */
110 
111 static void procfs_attach (struct target_ops *, const char *, int);
112 static void procfs_detach (struct target_ops *, const char *, int);
113 static void procfs_resume (struct target_ops *,
114  ptid_t, int, enum gdb_signal);
115 static void procfs_stop (struct target_ops *self, ptid_t);
116 static void procfs_files_info (struct target_ops *);
117 static void procfs_fetch_registers (struct target_ops *,
118  struct regcache *, int);
119 static void procfs_store_registers (struct target_ops *,
120  struct regcache *, int);
121 static void procfs_pass_signals (struct target_ops *self,
122  int, unsigned char *);
123 static void procfs_kill_inferior (struct target_ops *ops);
124 static void procfs_mourn_inferior (struct target_ops *ops);
125 static void procfs_create_inferior (struct target_ops *, char *,
126  char *, char **, int);
127 static ptid_t procfs_wait (struct target_ops *,
128  ptid_t, struct target_waitstatus *, int);
130  const gdb_byte *,
132  ULONGEST *);
134 
135 static int procfs_thread_alive (struct target_ops *ops, ptid_t);
136 
137 static void procfs_update_thread_list (struct target_ops *ops);
138 static char *procfs_pid_to_str (struct target_ops *, ptid_t);
139 
140 static int proc_find_memory_regions (struct target_ops *self,
141  find_memory_region_ftype, void *);
142 
143 static char * procfs_make_note_section (struct target_ops *self,
144  bfd *, int *);
145 
146 static int procfs_can_use_hw_breakpoint (struct target_ops *self,
147  int, int, int);
148 
149 static void procfs_info_proc (struct target_ops *, const char *,
150  enum info_proc_what);
151 
152 #if defined (PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
153 /* When GDB is built as 64-bit application on Solaris, the auxv data
154  is presented in 64-bit format. We need to provide a custom parser
155  to handle that. */
156 static int
157 procfs_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
158  gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
159 {
160  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
161  gdb_byte *ptr = *readptr;
162 
163  if (endptr == ptr)
164  return 0;
165 
166  if (endptr - ptr < 8 * 2)
167  return -1;
168 
169  *typep = extract_unsigned_integer (ptr, 4, byte_order);
170  ptr += 8;
171  /* The size of data is always 64-bit. If the application is 32-bit,
172  it will be zero extended, as expected. */
173  *valp = extract_unsigned_integer (ptr, 8, byte_order);
174  ptr += 8;
175 
176  *readptr = ptr;
177  return 1;
178 }
179 #endif
180 
181 struct target_ops *
183 {
184  struct target_ops *t = inf_child_target ();
185 
191  t->to_wait = procfs_wait;
198  t->to_stop = procfs_stop;
199 
203 
208 
209 #if defined(PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
210  t->to_auxv_parse = procfs_auxv_parse;
211 #endif
212 
213  t->to_magic = OPS_MAGIC;
214 
215  return t;
216 }
217 
218 /* =================== END, TARGET_OPS "MODULE" =================== */
219 
220 /* World Unification:
221 
222  Put any typedefs, defines etc. here that are required for the
223  unification of code that handles different versions of /proc. */
224 
225 #ifdef NEW_PROC_API /* Solaris 7 && 8 method for watchpoints */
226 #ifdef WA_READ
227  enum { READ_WATCHFLAG = WA_READ,
228  WRITE_WATCHFLAG = WA_WRITE,
229  EXEC_WATCHFLAG = WA_EXEC,
230  AFTER_WATCHFLAG = WA_TRAPAFTER
231  };
232 #endif
233 #else /* Irix method for watchpoints */
234  enum { READ_WATCHFLAG = MA_READ,
235  WRITE_WATCHFLAG = MA_WRITE,
236  EXEC_WATCHFLAG = MA_EXEC,
237  AFTER_WATCHFLAG = 0 /* trapafter not implemented */
238  };
239 #endif
240 
241 /* gdb_sigset_t */
242 #ifdef HAVE_PR_SIGSET_T
243 typedef pr_sigset_t gdb_sigset_t;
244 #else
245 typedef sigset_t gdb_sigset_t;
246 #endif
247 
248 /* sigaction */
249 #ifdef HAVE_PR_SIGACTION64_T
250 typedef pr_sigaction64_t gdb_sigaction_t;
251 #else
252 typedef struct sigaction gdb_sigaction_t;
253 #endif
254 
255 /* siginfo */
256 #ifdef HAVE_PR_SIGINFO64_T
257 typedef pr_siginfo64_t gdb_siginfo_t;
258 #else
259 typedef siginfo_t gdb_siginfo_t;
260 #endif
261 
262 /* On mips-irix, praddset and prdelset are defined in such a way that
263  they return a value, which causes GCC to emit a -Wunused error
264  because the returned value is not used. Prevent this warning
265  by casting the return value to void. On sparc-solaris, this issue
266  does not exist because the definition of these macros already include
267  that cast to void. */
268 #define gdb_praddset(sp, flag) ((void) praddset (sp, flag))
269 #define gdb_prdelset(sp, flag) ((void) prdelset (sp, flag))
270 
271 /* gdb_premptysysset */
272 #ifdef premptysysset
273 #define gdb_premptysysset premptysysset
274 #else
275 #define gdb_premptysysset premptyset
276 #endif
277 
278 /* praddsysset */
279 #ifdef praddsysset
280 #define gdb_praddsysset praddsysset
281 #else
282 #define gdb_praddsysset gdb_praddset
283 #endif
284 
285 /* prdelsysset */
286 #ifdef prdelsysset
287 #define gdb_prdelsysset prdelsysset
288 #else
289 #define gdb_prdelsysset gdb_prdelset
290 #endif
291 
292 /* prissyssetmember */
293 #ifdef prissyssetmember
294 #define gdb_pr_issyssetmember prissyssetmember
295 #else
296 #define gdb_pr_issyssetmember prismember
297 #endif
298 
299 /* As a feature test, saying ``#if HAVE_PRSYSENT_T'' everywhere isn't
300  as intuitively descriptive as it could be, so we'll define
301  DYNAMIC_SYSCALLS to mean the same thing. Anyway, at the time of
302  this writing, this feature is only found on AIX5 systems and
303  basically means that the set of syscalls is not fixed. I.e,
304  there's no nice table that one can #include to get all of the
305  syscall numbers. Instead, they're stored in /proc/PID/sysent
306  for each process. We are at least guaranteed that they won't
307  change over the lifetime of the process. But each process could
308  (in theory) have different syscall numbers. */
309 #ifdef HAVE_PRSYSENT_T
310 #define DYNAMIC_SYSCALLS
311 #endif
312 
313 
314 
315 /* =================== STRUCT PROCINFO "MODULE" =================== */
316 
317  /* FIXME: this comment will soon be out of date W.R.T. threads. */
318 
319 /* The procinfo struct is a wrapper to hold all the state information
320  concerning a /proc process. There should be exactly one procinfo
321  for each process, and since GDB currently can debug only one
322  process at a time, that means there should be only one procinfo.
323  All of the LWP's of a process can be accessed indirectly thru the
324  single process procinfo.
325 
326  However, against the day when GDB may debug more than one process,
327  this data structure is kept in a list (which for now will hold no
328  more than one member), and many functions will have a pointer to a
329  procinfo as an argument.
330 
331  There will be a separate procinfo structure for use by the (not yet
332  implemented) "info proc" command, so that we can print useful
333  information about any random process without interfering with the
334  inferior's procinfo information. */
335 
336 #ifdef NEW_PROC_API
337 /* format strings for /proc paths */
338 # ifndef CTL_PROC_NAME_FMT
339 # define MAIN_PROC_NAME_FMT "/proc/%d"
340 # define CTL_PROC_NAME_FMT "/proc/%d/ctl"
341 # define AS_PROC_NAME_FMT "/proc/%d/as"
342 # define MAP_PROC_NAME_FMT "/proc/%d/map"
343 # define STATUS_PROC_NAME_FMT "/proc/%d/status"
344 # define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus")
345 # endif
346 /* the name of the proc status struct depends on the implementation */
347 typedef pstatus_t gdb_prstatus_t;
348 typedef lwpstatus_t gdb_lwpstatus_t;
349 #else /* ! NEW_PROC_API */
350 /* format strings for /proc paths */
351 # ifndef CTL_PROC_NAME_FMT
352 # define MAIN_PROC_NAME_FMT "/proc/%05d"
353 # define CTL_PROC_NAME_FMT "/proc/%05d"
354 # define AS_PROC_NAME_FMT "/proc/%05d"
355 # define MAP_PROC_NAME_FMT "/proc/%05d"
356 # define STATUS_PROC_NAME_FMT "/proc/%05d"
357 # define MAX_PROC_NAME_SIZE sizeof("/proc/ttttppppp")
358 # endif
359 /* The name of the proc status struct depends on the implementation. */
360 typedef prstatus_t gdb_prstatus_t;
361 typedef prstatus_t gdb_lwpstatus_t;
362 #endif /* NEW_PROC_API */
363 
364 typedef struct procinfo {
365  struct procinfo *next;
366  int pid; /* Process ID */
367  int tid; /* Thread/LWP id */
368 
369  /* process state */
372 
373  /* The following four fd fields may be identical, or may contain
374  several different fd's, depending on the version of /proc
375  (old ioctl or new read/write). */
376 
377  int ctl_fd; /* File descriptor for /proc control file */
378 
379  /* The next three file descriptors are actually only needed in the
380  read/write, multiple-file-descriptor implemenation
381  (NEW_PROC_API). However, to avoid a bunch of #ifdefs in the
382  code, we will use them uniformly by (in the case of the ioctl
383  single-file-descriptor implementation) filling them with copies
384  of the control fd. */
385  int status_fd; /* File descriptor for /proc status file */
386  int as_fd; /* File descriptor for /proc as file */
387 
388  char pathname[MAX_PROC_NAME_SIZE]; /* Pathname to /proc entry */
389 
390  fltset_t saved_fltset; /* Saved traced hardware fault set */
391  gdb_sigset_t saved_sigset; /* Saved traced signal set */
392  gdb_sigset_t saved_sighold; /* Saved held signal set */
393  sysset_t *saved_exitset; /* Saved traced system call exit set */
394  sysset_t *saved_entryset; /* Saved traced system call entry set */
395 
396  gdb_prstatus_t prstatus; /* Current process status info */
397 
398 #ifndef NEW_PROC_API
399  gdb_fpregset_t fpregset; /* Current floating point registers */
400 #endif
401 
402 #ifdef DYNAMIC_SYSCALLS
403  int num_syscalls; /* Total number of syscalls */
404  char **syscall_names; /* Syscall number to name map */
405 #endif
406 
408 
409  int status_valid : 1;
410  int gregs_valid : 1;
411  int fpregs_valid : 1;
413 } procinfo;
414 
415 static char errmsg[128]; /* shared error msg buffer */
416 
417 /* Function prototypes for procinfo module: */
418 
419 static procinfo *find_procinfo_or_die (int pid, int tid);
420 static procinfo *find_procinfo (int pid, int tid);
421 static procinfo *create_procinfo (int pid, int tid);
422 static void destroy_procinfo (procinfo * p);
423 static void do_destroy_procinfo_cleanup (void *);
424 static void dead_procinfo (procinfo * p, char *msg, int killp);
425 static int open_procinfo_files (procinfo * p, int which);
426 static void close_procinfo_files (procinfo * p);
427 static int sysset_t_size (procinfo *p);
428 static sysset_t *sysset_t_alloc (procinfo * pi);
429 #ifdef DYNAMIC_SYSCALLS
430 static void load_syscalls (procinfo *pi);
431 static void free_syscalls (procinfo *pi);
432 static int find_syscall (procinfo *pi, char *name);
433 #endif /* DYNAMIC_SYSCALLS */
434 
435 static int iterate_over_mappings
436  (procinfo *pi, find_memory_region_ftype child_func, void *data,
437  int (*func) (struct prmap *map, find_memory_region_ftype child_func,
438  void *data));
439 
440 /* The head of the procinfo list: */
442 
443 /* Search the procinfo list. Return a pointer to procinfo, or NULL if
444  not found. */
445 
446 static procinfo *
448 {
449  procinfo *pi;
450 
451  for (pi = procinfo_list; pi; pi = pi->next)
452  if (pi->pid == pid)
453  break;
454 
455  if (pi)
456  if (tid)
457  {
458  /* Don't check threads_valid. If we're updating the
459  thread_list, we want to find whatever threads are already
460  here. This means that in general it is the caller's
461  responsibility to check threads_valid and update before
462  calling find_procinfo, if the caller wants to find a new
463  thread. */
464 
465  for (pi = pi->thread_list; pi; pi = pi->next)
466  if (pi->tid == tid)
467  break;
468  }
469 
470  return pi;
471 }
472 
473 /* Calls find_procinfo, but errors on failure. */
474 
475 static procinfo *
477 {
478  procinfo *pi = find_procinfo (pid, tid);
479 
480  if (pi == NULL)
481  {
482  if (tid)
483  error (_("procfs: couldn't find pid %d "
484  "(kernel thread %d) in procinfo list."),
485  pid, tid);
486  else
487  error (_("procfs: couldn't find pid %d in procinfo list."), pid);
488  }
489  return pi;
490 }
491 
492 /* Wrapper for `open'. The appropriate open call is attempted; if
493  unsuccessful, it will be retried as many times as needed for the
494  EAGAIN and EINTR conditions.
495 
496  For other conditions, retry the open a limited number of times. In
497  addition, a short sleep is imposed prior to retrying the open. The
498  reason for this sleep is to give the kernel a chance to catch up
499  and create the file in question in the event that GDB "wins" the
500  race to open a file before the kernel has created it. */
501 
502 static int
503 open_with_retry (const char *pathname, int flags)
504 {
505  int retries_remaining, status;
506 
507  retries_remaining = 2;
508 
509  while (1)
510  {
511  status = open (pathname, flags);
512 
513  if (status >= 0 || retries_remaining == 0)
514  break;
515  else if (errno != EINTR && errno != EAGAIN)
516  {
517  retries_remaining--;
518  sleep (1);
519  }
520  }
521 
522  return status;
523 }
524 
525 /* Open the file descriptor for the process or LWP. If NEW_PROC_API
526  is defined, we only open the control file descriptor; the others
527  are opened lazily as needed. Otherwise (if not NEW_PROC_API),
528  there is only one real file descriptor, but we keep multiple copies
529  of it so that the code that uses them does not have to be #ifdef'd.
530  Returns the file descriptor, or zero for failure. */
531 
532 enum { FD_CTL, FD_STATUS, FD_AS };
533 
534 static int
536 {
537 #ifdef NEW_PROC_API
538  char tmp[MAX_PROC_NAME_SIZE];
539 #endif
540  int fd;
541 
542  /* This function is getting ALMOST long enough to break up into
543  several. Here is some rationale:
544 
545  NEW_PROC_API (Solaris 2.6, Solaris 2.7):
546  There are several file descriptors that may need to be open
547  for any given process or LWP. The ones we're intereted in are:
548  - control (ctl) write-only change the state
549  - status (status) read-only query the state
550  - address space (as) read/write access memory
551  - map (map) read-only virtual addr map
552  Most of these are opened lazily as they are needed.
553  The pathnames for the 'files' for an LWP look slightly
554  different from those of a first-class process:
555  Pathnames for a process (<proc-id>):
556  /proc/<proc-id>/ctl
557  /proc/<proc-id>/status
558  /proc/<proc-id>/as
559  /proc/<proc-id>/map
560  Pathnames for an LWP (lwp-id):
561  /proc/<proc-id>/lwp/<lwp-id>/lwpctl
562  /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
563  An LWP has no map or address space file descriptor, since
564  the memory map and address space are shared by all LWPs.
565 
566  Everyone else (Solaris 2.5, Irix, OSF)
567  There is only one file descriptor for each process or LWP.
568  For convenience, we copy the same file descriptor into all
569  three fields of the procinfo struct (ctl_fd, status_fd, and
570  as_fd, see NEW_PROC_API above) so that code that uses them
571  doesn't need any #ifdef's.
572  Pathname for all:
573  /proc/<proc-id>
574 
575  Solaris 2.5 LWP's:
576  Each LWP has an independent file descriptor, but these
577  are not obtained via the 'open' system call like the rest:
578  instead, they're obtained thru an ioctl call (PIOCOPENLWP)
579  to the file descriptor of the parent process.
580 
581  OSF threads:
582  These do not even have their own independent file descriptor.
583  All operations are carried out on the file descriptor of the
584  parent process. Therefore we just call open again for each
585  thread, getting a new handle for the same 'file'. */
586 
587 #ifdef NEW_PROC_API
588  /* In this case, there are several different file descriptors that
589  we might be asked to open. The control file descriptor will be
590  opened early, but the others will be opened lazily as they are
591  needed. */
592 
593  strcpy (tmp, pi->pathname);
594  switch (which) { /* Which file descriptor to open? */
595  case FD_CTL:
596  if (pi->tid)
597  strcat (tmp, "/lwpctl");
598  else
599  strcat (tmp, "/ctl");
600  fd = open_with_retry (tmp, O_WRONLY);
601  if (fd < 0)
602  return 0; /* fail */
603  pi->ctl_fd = fd;
604  break;
605  case FD_AS:
606  if (pi->tid)
607  return 0; /* There is no 'as' file descriptor for an lwp. */
608  strcat (tmp, "/as");
609  fd = open_with_retry (tmp, O_RDWR);
610  if (fd < 0)
611  return 0; /* fail */
612  pi->as_fd = fd;
613  break;
614  case FD_STATUS:
615  if (pi->tid)
616  strcat (tmp, "/lwpstatus");
617  else
618  strcat (tmp, "/status");
619  fd = open_with_retry (tmp, O_RDONLY);
620  if (fd < 0)
621  return 0; /* fail */
622  pi->status_fd = fd;
623  break;
624  default:
625  return 0; /* unknown file descriptor */
626  }
627 #else /* not NEW_PROC_API */
628  /* In this case, there is only one file descriptor for each procinfo
629  (ie. each process or LWP). In fact, only the file descriptor for
630  the process can actually be opened by an 'open' system call. The
631  ones for the LWPs have to be obtained thru an IOCTL call on the
632  process's file descriptor.
633 
634  For convenience, we copy each procinfo's single file descriptor
635  into all of the fields occupied by the several file descriptors
636  of the NEW_PROC_API implementation. That way, the code that uses
637  them can be written without ifdefs. */
638 
639 
640 #ifdef PIOCTSTATUS /* OSF */
641  /* Only one FD; just open it. */
642  if ((fd = open_with_retry (pi->pathname, O_RDWR)) < 0)
643  return 0;
644 #else /* Sol 2.5, Irix, other? */
645  if (pi->tid == 0) /* Master procinfo for the process */
646  {
647  fd = open_with_retry (pi->pathname, O_RDWR);
648  if (fd < 0)
649  return 0; /* fail */
650  }
651  else /* LWP thread procinfo */
652  {
653 #ifdef PIOCOPENLWP /* Sol 2.5, thread/LWP */
654  procinfo *process;
655  int lwpid = pi->tid;
656 
657  /* Find the procinfo for the entire process. */
658  if ((process = find_procinfo (pi->pid, 0)) == NULL)
659  return 0; /* fail */
660 
661  /* Now obtain the file descriptor for the LWP. */
662  if ((fd = ioctl (process->ctl_fd, PIOCOPENLWP, &lwpid)) < 0)
663  return 0; /* fail */
664 #else /* Irix, other? */
665  return 0; /* Don't know how to open threads. */
666 #endif /* Sol 2.5 PIOCOPENLWP */
667  }
668 #endif /* OSF PIOCTSTATUS */
669  pi->ctl_fd = pi->as_fd = pi->status_fd = fd;
670 #endif /* NEW_PROC_API */
671 
672  return 1; /* success */
673 }
674 
675 /* Allocate a data structure and link it into the procinfo list.
676  First tries to find a pre-existing one (FIXME: why?). Returns the
677  pointer to new procinfo struct. */
678 
679 static procinfo *
681 {
682  procinfo *pi, *parent = NULL;
683 
684  if ((pi = find_procinfo (pid, tid)))
685  return pi; /* Already exists, nothing to do. */
686 
687  /* Find parent before doing malloc, to save having to cleanup. */
688  if (tid != 0)
689  parent = find_procinfo_or_die (pid, 0); /* FIXME: should I
690  create it if it
691  doesn't exist yet? */
692 
693  pi = (procinfo *) xmalloc (sizeof (procinfo));
694  memset (pi, 0, sizeof (procinfo));
695  pi->pid = pid;
696  pi->tid = tid;
697 
698 #ifdef DYNAMIC_SYSCALLS
699  load_syscalls (pi);
700 #endif
701 
702  pi->saved_entryset = sysset_t_alloc (pi);
703  pi->saved_exitset = sysset_t_alloc (pi);
704 
705  /* Chain into list. */
706  if (tid == 0)
707  {
708  sprintf (pi->pathname, MAIN_PROC_NAME_FMT, pid);
709  pi->next = procinfo_list;
710  procinfo_list = pi;
711  }
712  else
713  {
714 #ifdef NEW_PROC_API
715  sprintf (pi->pathname, "/proc/%05d/lwp/%d", pid, tid);
716 #else
717  sprintf (pi->pathname, MAIN_PROC_NAME_FMT, pid);
718 #endif
719  pi->next = parent->thread_list;
720  parent->thread_list = pi;
721  }
722  return pi;
723 }
724 
725 /* Close all file descriptors associated with the procinfo. */
726 
727 static void
729 {
730  if (pi->ctl_fd > 0)
731  close (pi->ctl_fd);
732 #ifdef NEW_PROC_API
733  if (pi->as_fd > 0)
734  close (pi->as_fd);
735  if (pi->status_fd > 0)
736  close (pi->status_fd);
737 #endif
738  pi->ctl_fd = pi->as_fd = pi->status_fd = 0;
739 }
740 
741 /* Destructor function. Close, unlink and deallocate the object. */
742 
743 static void
745 {
746  procinfo *ptr;
747 
748  /* Step one: unlink the procinfo from its list. */
749  if (pi == *list)
750  *list = pi->next;
751  else
752  for (ptr = *list; ptr; ptr = ptr->next)
753  if (ptr->next == pi)
754  {
755  ptr->next = pi->next;
756  break;
757  }
758 
759  /* Step two: close any open file descriptors. */
761 
762  /* Step three: free the memory. */
763 #ifdef DYNAMIC_SYSCALLS
764  free_syscalls (pi);
765 #endif
766  xfree (pi->saved_entryset);
767  xfree (pi->saved_exitset);
768  xfree (pi);
769 }
770 
771 static void
773 {
774  procinfo *tmp;
775 
776  if (pi->tid != 0) /* Destroy a thread procinfo. */
777  {
778  tmp = find_procinfo (pi->pid, 0); /* Find the parent process. */
779  destroy_one_procinfo (&tmp->thread_list, pi);
780  }
781  else /* Destroy a process procinfo and all its threads. */
782  {
783  /* First destroy the children, if any; */
784  while (pi->thread_list != NULL)
786  /* Then destroy the parent. Genocide!!! */
787  destroy_one_procinfo (&procinfo_list, pi);
788  }
789 }
790 
791 static void
793 {
794  destroy_procinfo (pi);
795 }
796 
797 enum { NOKILL, KILL };
798 
799 /* To be called on a non_recoverable error for a procinfo. Prints
800  error messages, optionally sends a SIGKILL to the process, then
801  destroys the data structure. */
802 
803 static void
804 dead_procinfo (procinfo *pi, char *msg, int kill_p)
805 {
806  char procfile[80];
807 
808  if (pi->pathname)
809  {
810  print_sys_errmsg (pi->pathname, errno);
811  }
812  else
813  {
814  sprintf (procfile, "process %d", pi->pid);
815  print_sys_errmsg (procfile, errno);
816  }
817  if (kill_p == KILL)
818  kill (pi->pid, SIGKILL);
819 
820  destroy_procinfo (pi);
821  error ("%s", msg);
822 }
823 
824 /* Returns the (complete) size of a sysset_t struct. Normally, this
825  is just sizeof (sysset_t), but in the case of Monterey/64, the
826  actual size of sysset_t isn't known until runtime. */
827 
828 static int
830 {
831 #ifndef DYNAMIC_SYSCALLS
832  return sizeof (sysset_t);
833 #else
834  return sizeof (sysset_t) - sizeof (uint64_t)
835  + sizeof (uint64_t) * ((pi->num_syscalls + (8 * sizeof (uint64_t) - 1))
836  / (8 * sizeof (uint64_t)));
837 #endif
838 }
839 
840 /* Allocate and (partially) initialize a sysset_t struct. */
841 
842 static sysset_t *
844 {
845  sysset_t *ret;
846  int size = sysset_t_size (pi);
847 
848  ret = xmalloc (size);
849 #ifdef DYNAMIC_SYSCALLS
850  ret->pr_size = ((pi->num_syscalls + (8 * sizeof (uint64_t) - 1))
851  / (8 * sizeof (uint64_t)));
852 #endif
853  return ret;
854 }
855 
856 #ifdef DYNAMIC_SYSCALLS
857 
858 /* Extract syscall numbers and names from /proc/<pid>/sysent. Initialize
859  pi->num_syscalls with the number of syscalls and pi->syscall_names
860  with the names. (Certain numbers may be skipped in which case the
861  names for these numbers will be left as NULL.) */
862 
863 #define MAX_SYSCALL_NAME_LENGTH 256
864 #define MAX_SYSCALLS 65536
865 
866 static void
867 load_syscalls (procinfo *pi)
868 {
869  char pathname[MAX_PROC_NAME_SIZE];
870  int sysent_fd;
871  prsysent_t header;
872  prsyscall_t *syscalls;
873  int i, size, maxcall;
874  struct cleanup *cleanups;
875 
876  pi->num_syscalls = 0;
877  pi->syscall_names = 0;
878 
879  /* Open the file descriptor for the sysent file. */
880  sprintf (pathname, "/proc/%d/sysent", pi->pid);
881  sysent_fd = open_with_retry (pathname, O_RDONLY);
882  if (sysent_fd < 0)
883  {
884  error (_("load_syscalls: Can't open /proc/%d/sysent"), pi->pid);
885  }
886  cleanups = make_cleanup_close (sysent_fd);
887 
888  size = sizeof header - sizeof (prsyscall_t);
889  if (read (sysent_fd, &header, size) != size)
890  {
891  error (_("load_syscalls: Error reading /proc/%d/sysent"), pi->pid);
892  }
893 
894  if (header.pr_nsyscalls == 0)
895  {
896  error (_("load_syscalls: /proc/%d/sysent contains no syscalls!"),
897  pi->pid);
898  }
899 
900  size = header.pr_nsyscalls * sizeof (prsyscall_t);
901  syscalls = xmalloc (size);
902  make_cleanup (free_current_contents, &syscalls);
903 
904  if (read (sysent_fd, syscalls, size) != size)
905  error (_("load_syscalls: Error reading /proc/%d/sysent"), pi->pid);
906 
907  /* Find maximum syscall number. This may not be the same as
908  pr_nsyscalls since that value refers to the number of entries
909  in the table. (Also, the docs indicate that some system
910  call numbers may be skipped.) */
911 
912  maxcall = syscalls[0].pr_number;
913 
914  for (i = 1; i < header.pr_nsyscalls; i++)
915  if (syscalls[i].pr_number > maxcall
916  && syscalls[i].pr_nameoff > 0
917  && syscalls[i].pr_number < MAX_SYSCALLS)
918  maxcall = syscalls[i].pr_number;
919 
920  pi->num_syscalls = maxcall+1;
921  pi->syscall_names = xmalloc (pi->num_syscalls * sizeof (char *));
922 
923  for (i = 0; i < pi->num_syscalls; i++)
924  pi->syscall_names[i] = NULL;
925 
926  /* Read the syscall names in. */
927  for (i = 0; i < header.pr_nsyscalls; i++)
928  {
929  char namebuf[MAX_SYSCALL_NAME_LENGTH];
930  int nread;
931  int callnum;
932 
933  if (syscalls[i].pr_number >= MAX_SYSCALLS
934  || syscalls[i].pr_number < 0
935  || syscalls[i].pr_nameoff <= 0
936  || (lseek (sysent_fd, (off_t) syscalls[i].pr_nameoff, SEEK_SET)
937  != (off_t) syscalls[i].pr_nameoff))
938  continue;
939 
940  nread = read (sysent_fd, namebuf, sizeof namebuf);
941  if (nread <= 0)
942  continue;
943 
944  callnum = syscalls[i].pr_number;
945 
946  if (pi->syscall_names[callnum] != NULL)
947  {
948  /* FIXME: Generate warning. */
949  continue;
950  }
951 
952  namebuf[nread-1] = '\0';
953  size = strlen (namebuf) + 1;
954  pi->syscall_names[callnum] = xmalloc (size);
955  strncpy (pi->syscall_names[callnum], namebuf, size-1);
956  pi->syscall_names[callnum][size-1] = '\0';
957  }
958 
959  do_cleanups (cleanups);
960 }
961 
962 /* Free the space allocated for the syscall names from the procinfo
963  structure. */
964 
965 static void
966 free_syscalls (procinfo *pi)
967 {
968  if (pi->syscall_names)
969  {
970  int i;
971 
972  for (i = 0; i < pi->num_syscalls; i++)
973  if (pi->syscall_names[i] != NULL)
974  xfree (pi->syscall_names[i]);
975 
976  xfree (pi->syscall_names);
977  pi->syscall_names = 0;
978  }
979 }
980 
981 /* Given a name, look up (and return) the corresponding syscall number.
982  If no match is found, return -1. */
983 
984 static int
985 find_syscall (procinfo *pi, char *name)
986 {
987  int i;
988 
989  for (i = 0; i < pi->num_syscalls; i++)
990  {
991  if (pi->syscall_names[i] && strcmp (name, pi->syscall_names[i]) == 0)
992  return i;
993  }
994  return -1;
995 }
996 #endif
997 
998 /* =================== END, STRUCT PROCINFO "MODULE" =================== */
999 
1000 /* =================== /proc "MODULE" =================== */
1001 
1002 /* This "module" is the interface layer between the /proc system API
1003  and the gdb target vector functions. This layer consists of access
1004  functions that encapsulate each of the basic operations that we
1005  need to use from the /proc API.
1006 
1007  The main motivation for this layer is to hide the fact that there
1008  are two very different implementations of the /proc API. Rather
1009  than have a bunch of #ifdefs all thru the gdb target vector
1010  functions, we do our best to hide them all in here. */
1011 
1012 static long proc_flags (procinfo * pi);
1013 static int proc_why (procinfo * pi);
1014 static int proc_what (procinfo * pi);
1015 static int proc_set_current_signal (procinfo * pi, int signo);
1016 static int proc_get_current_thread (procinfo * pi);
1017 static int proc_iterate_over_threads
1018  (procinfo * pi,
1019  int (*func) (procinfo *, procinfo *, void *),
1020  void *ptr);
1021 
1022 static void
1023 proc_warn (procinfo *pi, char *func, int line)
1024 {
1025  sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
1026  print_sys_errmsg (errmsg, errno);
1027 }
1028 
1029 static void
1030 proc_error (procinfo *pi, char *func, int line)
1031 {
1032  sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
1033  perror_with_name (errmsg);
1034 }
1035 
1036 /* Updates the status struct in the procinfo. There is a 'valid'
1037  flag, to let other functions know when this function needs to be
1038  called (so the status is only read when it is needed). The status
1039  file descriptor is also only opened when it is needed. Returns
1040  non-zero for success, zero for failure. */
1041 
1042 static int
1044 {
1045  /* Status file descriptor is opened "lazily". */
1046  if (pi->status_fd == 0 &&
1047  open_procinfo_files (pi, FD_STATUS) == 0)
1048  {
1049  pi->status_valid = 0;
1050  return 0;
1051  }
1052 
1053 #ifdef NEW_PROC_API
1054  if (lseek (pi->status_fd, 0, SEEK_SET) < 0)
1055  pi->status_valid = 0; /* fail */
1056  else
1057  {
1058  /* Sigh... I have to read a different data structure,
1059  depending on whether this is a main process or an LWP. */
1060  if (pi->tid)
1061  pi->status_valid = (read (pi->status_fd,
1062  (char *) &pi->prstatus.pr_lwp,
1063  sizeof (lwpstatus_t))
1064  == sizeof (lwpstatus_t));
1065  else
1066  {
1067  pi->status_valid = (read (pi->status_fd,
1068  (char *) &pi->prstatus,
1069  sizeof (gdb_prstatus_t))
1070  == sizeof (gdb_prstatus_t));
1071  }
1072  }
1073 #else /* ioctl method */
1074 #ifdef PIOCTSTATUS /* osf */
1075  if (pi->tid == 0) /* main process */
1076  {
1077  /* Just read the danged status. Now isn't that simple? */
1078  pi->status_valid =
1079  (ioctl (pi->status_fd, PIOCSTATUS, &pi->prstatus) >= 0);
1080  }
1081  else
1082  {
1083  int win;
1084  struct {
1085  long pr_count;
1086  tid_t pr_error_thread;
1087  struct prstatus status;
1088  } thread_status;
1089 
1090  thread_status.pr_count = 1;
1091  thread_status.status.pr_tid = pi->tid;
1092  win = (ioctl (pi->status_fd, PIOCTSTATUS, &thread_status) >= 0);
1093  if (win)
1094  {
1095  memcpy (&pi->prstatus, &thread_status.status,
1096  sizeof (pi->prstatus));
1097  pi->status_valid = 1;
1098  }
1099  }
1100 #else
1101  /* Just read the danged status. Now isn't that simple? */
1102  pi->status_valid = (ioctl (pi->status_fd, PIOCSTATUS, &pi->prstatus) >= 0);
1103 #endif
1104 #endif
1105 
1106  if (pi->status_valid)
1107  {
1109  proc_why (pi),
1110  proc_what (pi),
1112  }
1113 
1114  /* The status struct includes general regs, so mark them valid too. */
1115  pi->gregs_valid = pi->status_valid;
1116 #ifdef NEW_PROC_API
1117  /* In the read/write multiple-fd model, the status struct includes
1118  the fp regs too, so mark them valid too. */
1119  pi->fpregs_valid = pi->status_valid;
1120 #endif
1121  return pi->status_valid; /* True if success, false if failure. */
1122 }
1123 
1124 /* Returns the process flags (pr_flags field). */
1125 
1126 static long
1128 {
1129  if (!pi->status_valid)
1130  if (!proc_get_status (pi))
1131  return 0; /* FIXME: not a good failure value (but what is?) */
1132 
1133 #ifdef NEW_PROC_API
1134  return pi->prstatus.pr_lwp.pr_flags;
1135 #else
1136  return pi->prstatus.pr_flags;
1137 #endif
1138 }
1139 
1140 /* Returns the pr_why field (why the process stopped). */
1141 
1142 static int
1144 {
1145  if (!pi->status_valid)
1146  if (!proc_get_status (pi))
1147  return 0; /* FIXME: not a good failure value (but what is?) */
1148 
1149 #ifdef NEW_PROC_API
1150  return pi->prstatus.pr_lwp.pr_why;
1151 #else
1152  return pi->prstatus.pr_why;
1153 #endif
1154 }
1155 
1156 /* Returns the pr_what field (details of why the process stopped). */
1157 
1158 static int
1160 {
1161  if (!pi->status_valid)
1162  if (!proc_get_status (pi))
1163  return 0; /* FIXME: not a good failure value (but what is?) */
1164 
1165 #ifdef NEW_PROC_API
1166  return pi->prstatus.pr_lwp.pr_what;
1167 #else
1168  return pi->prstatus.pr_what;
1169 #endif
1170 }
1171 
1172 /* This function is only called when PI is stopped by a watchpoint.
1173  Assuming the OS supports it, write to *ADDR the data address which
1174  triggered it and return 1. Return 0 if it is not possible to know
1175  the address. */
1176 
1177 static int
1179 {
1180  if (!pi->status_valid)
1181  if (!proc_get_status (pi))
1182  return 0;
1183 
1184 #ifdef NEW_PROC_API
1187  (gdb_byte *) &pi->prstatus.pr_lwp.pr_info.si_addr);
1188 #else
1191  (gdb_byte *) &pi->prstatus.pr_info.si_addr);
1192 #endif
1193  return 1;
1194 }
1195 
1196 #ifndef PIOCSSPCACT /* The following is not supported on OSF. */
1197 
1198 /* Returns the pr_nsysarg field (number of args to the current
1199  syscall). */
1200 
1201 static int
1203 {
1204  if (!pi->status_valid)
1205  if (!proc_get_status (pi))
1206  return 0;
1207 
1208 #ifdef NEW_PROC_API
1209  return pi->prstatus.pr_lwp.pr_nsysarg;
1210 #else
1211  return pi->prstatus.pr_nsysarg;
1212 #endif
1213 }
1214 
1215 /* Returns the pr_sysarg field (pointer to the arguments of current
1216  syscall). */
1217 
1218 static long *
1220 {
1221  if (!pi->status_valid)
1222  if (!proc_get_status (pi))
1223  return NULL;
1224 
1225 #ifdef NEW_PROC_API
1226  return (long *) &pi->prstatus.pr_lwp.pr_sysarg;
1227 #else
1228  return (long *) &pi->prstatus.pr_sysarg;
1229 #endif
1230 }
1231 #endif /* PIOCSSPCACT */
1232 
1233 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
1234 /* Returns the pr_cursig field (current signal). */
1235 
1236 static long
1237 proc_cursig (struct procinfo *pi)
1238 {
1239  if (!pi->status_valid)
1240  if (!proc_get_status (pi))
1241  return 0; /* FIXME: not a good failure value (but what is?) */
1242 
1243 #ifdef NEW_PROC_API
1244  return pi->prstatus.pr_lwp.pr_cursig;
1245 #else
1246  return pi->prstatus.pr_cursig;
1247 #endif
1248 }
1249 #endif /* PROCFS_DONT_PIOCSSIG_CURSIG */
1250 
1251 /* === I appologize for the messiness of this function.
1252  === This is an area where the different versions of
1253  === /proc are more inconsistent than usual.
1254 
1255  Set or reset any of the following process flags:
1256  PR_FORK -- forked child will inherit trace flags
1257  PR_RLC -- traced process runs when last /proc file closed.
1258  PR_KLC -- traced process is killed when last /proc file closed.
1259  PR_ASYNC -- LWP's get to run/stop independently.
1260 
1261  There are three methods for doing this function:
1262  1) Newest: read/write [PCSET/PCRESET/PCUNSET]
1263  [Sol6, Sol7, UW]
1264  2) Middle: PIOCSET/PIOCRESET
1265  [Irix, Sol5]
1266  3) Oldest: PIOCSFORK/PIOCRFORK/PIOCSRLC/PIOCRRLC
1267  [OSF, Sol5]
1268 
1269  Note: Irix does not define PR_ASYNC.
1270  Note: OSF does not define PR_KLC.
1271  Note: OSF is the only one that can ONLY use the oldest method.
1272 
1273  Arguments:
1274  pi -- the procinfo
1275  flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
1276  mode -- 1 for set, 0 for reset.
1277 
1278  Returns non-zero for success, zero for failure. */
1279 
1281 
1282 static int
1283 proc_modify_flag (procinfo *pi, long flag, long mode)
1284 {
1285  long win = 0; /* default to fail */
1286 
1287  /* These operations affect the process as a whole, and applying them
1288  to an individual LWP has the same meaning as applying them to the
1289  main process. Therefore, if we're ever called with a pointer to
1290  an LWP's procinfo, let's substitute the process's procinfo and
1291  avoid opening the LWP's file descriptor unnecessarily. */
1292 
1293  if (pi->pid != 0)
1294  pi = find_procinfo_or_die (pi->pid, 0);
1295 
1296 #ifdef NEW_PROC_API /* Newest method: Newer Solarii. */
1297  /* First normalize the PCUNSET/PCRESET command opcode
1298  (which for no obvious reason has a different definition
1299  from one operating system to the next...) */
1300 #ifdef PCUNSET
1301 #define GDBRESET PCUNSET
1302 #else
1303 #ifdef PCRESET
1304 #define GDBRESET PCRESET
1305 #endif
1306 #endif
1307  {
1308  procfs_ctl_t arg[2];
1309 
1310  if (mode == FLAG_SET) /* Set the flag (RLC, FORK, or ASYNC). */
1311  arg[0] = PCSET;
1312  else /* Reset the flag. */
1313  arg[0] = GDBRESET;
1314 
1315  arg[1] = flag;
1316  win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
1317  }
1318 #else
1319 #ifdef PIOCSET /* Irix/Sol5 method */
1320  if (mode == FLAG_SET) /* Set the flag (hopefully RLC, FORK, or ASYNC). */
1321  {
1322  win = (ioctl (pi->ctl_fd, PIOCSET, &flag) >= 0);
1323  }
1324  else /* Reset the flag. */
1325  {
1326  win = (ioctl (pi->ctl_fd, PIOCRESET, &flag) >= 0);
1327  }
1328 
1329 #else
1330 #ifdef PIOCSRLC /* Oldest method: OSF */
1331  switch (flag) {
1332  case PR_RLC:
1333  if (mode == FLAG_SET) /* Set run-on-last-close */
1334  {
1335  win = (ioctl (pi->ctl_fd, PIOCSRLC, NULL) >= 0);
1336  }
1337  else /* Clear run-on-last-close */
1338  {
1339  win = (ioctl (pi->ctl_fd, PIOCRRLC, NULL) >= 0);
1340  }
1341  break;
1342  case PR_FORK:
1343  if (mode == FLAG_SET) /* Set inherit-on-fork */
1344  {
1345  win = (ioctl (pi->ctl_fd, PIOCSFORK, NULL) >= 0);
1346  }
1347  else /* Clear inherit-on-fork */
1348  {
1349  win = (ioctl (pi->ctl_fd, PIOCRFORK, NULL) >= 0);
1350  }
1351  break;
1352  default:
1353  win = 0; /* Fail -- unknown flag (can't do PR_ASYNC). */
1354  break;
1355  }
1356 #endif
1357 #endif
1358 #endif
1359 #undef GDBRESET
1360  /* The above operation renders the procinfo's cached pstatus
1361  obsolete. */
1362  pi->status_valid = 0;
1363 
1364  if (!win)
1365  warning (_("procfs: modify_flag failed to turn %s %s"),
1366  flag == PR_FORK ? "PR_FORK" :
1367  flag == PR_RLC ? "PR_RLC" :
1368 #ifdef PR_ASYNC
1369  flag == PR_ASYNC ? "PR_ASYNC" :
1370 #endif
1371 #ifdef PR_KLC
1372  flag == PR_KLC ? "PR_KLC" :
1373 #endif
1374  "<unknown flag>",
1375  mode == FLAG_RESET ? "off" : "on");
1376 
1377  return win;
1378 }
1379 
1380 /* Set the run_on_last_close flag. Process with all threads will
1381  become runnable when debugger closes all /proc fds. Returns
1382  non-zero for success, zero for failure. */
1383 
1384 static int
1386 {
1387  return proc_modify_flag (pi, PR_RLC, FLAG_SET);
1388 }
1389 
1390 /* Reset the run_on_last_close flag. The process will NOT become
1391  runnable when debugger closes its file handles. Returns non-zero
1392  for success, zero for failure. */
1393 
1394 static int
1396 {
1397  return proc_modify_flag (pi, PR_RLC, FLAG_RESET);
1398 }
1399 
1400 /* Reset inherit_on_fork flag. If the process forks a child while we
1401  are registered for events in the parent, then we will NOT recieve
1402  events from the child. Returns non-zero for success, zero for
1403  failure. */
1404 
1405 static int
1407 {
1408  return proc_modify_flag (pi, PR_FORK, FLAG_RESET);
1409 }
1410 
1411 #ifdef PR_ASYNC
1412 /* Set PR_ASYNC flag. If one LWP stops because of a debug event
1413  (signal etc.), the remaining LWPs will continue to run. Returns
1414  non-zero for success, zero for failure. */
1415 
1416 static int
1417 proc_set_async (procinfo *pi)
1418 {
1419  return proc_modify_flag (pi, PR_ASYNC, FLAG_SET);
1420 }
1421 
1422 /* Reset PR_ASYNC flag. If one LWP stops because of a debug event
1423  (signal etc.), then all other LWPs will stop as well. Returns
1424  non-zero for success, zero for failure. */
1425 
1426 static int
1427 proc_unset_async (procinfo *pi)
1428 {
1429  return proc_modify_flag (pi, PR_ASYNC, FLAG_RESET);
1430 }
1431 #endif /* PR_ASYNC */
1432 
1433 /* Request the process/LWP to stop. Does not wait. Returns non-zero
1434  for success, zero for failure. */
1435 
1436 static int
1438 {
1439  int win;
1440 
1441  /* We might conceivably apply this operation to an LWP, and the
1442  LWP's ctl file descriptor might not be open. */
1443 
1444  if (pi->ctl_fd == 0 &&
1445  open_procinfo_files (pi, FD_CTL) == 0)
1446  return 0;
1447  else
1448  {
1449 #ifdef NEW_PROC_API
1450  procfs_ctl_t cmd = PCSTOP;
1451 
1452  win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
1453 #else /* ioctl method */
1454  win = (ioctl (pi->ctl_fd, PIOCSTOP, &pi->prstatus) >= 0);
1455  /* Note: the call also reads the prstatus. */
1456  if (win)
1457  {
1458  pi->status_valid = 1;
1460  proc_why (pi),
1461  proc_what (pi),
1463  }
1464 #endif
1465  }
1466 
1467  return win;
1468 }
1469 
1470 /* Wait for the process or LWP to stop (block until it does). Returns
1471  non-zero for success, zero for failure. */
1472 
1473 static int
1475 {
1476  int win;
1477 
1478  /* We should never have to apply this operation to any procinfo
1479  except the one for the main process. If that ever changes for
1480  any reason, then take out the following clause and replace it
1481  with one that makes sure the ctl_fd is open. */
1482 
1483  if (pi->tid != 0)
1484  pi = find_procinfo_or_die (pi->pid, 0);
1485 
1486 #ifdef NEW_PROC_API
1487  {
1488  procfs_ctl_t cmd = PCWSTOP;
1489 
1490  win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
1491  /* We been runnin' and we stopped -- need to update status. */
1492  pi->status_valid = 0;
1493  }
1494 #else /* ioctl method */
1495  win = (ioctl (pi->ctl_fd, PIOCWSTOP, &pi->prstatus) >= 0);
1496  /* Above call also refreshes the prstatus. */
1497  if (win)
1498  {
1499  pi->status_valid = 1;
1501  proc_why (pi),
1502  proc_what (pi),
1504  }
1505 #endif
1506 
1507  return win;
1508 }
1509 
1510 /* Make the process or LWP runnable.
1511 
1512  Options (not all are implemented):
1513  - single-step
1514  - clear current fault
1515  - clear current signal
1516  - abort the current system call
1517  - stop as soon as finished with system call
1518  - (ioctl): set traced signal set
1519  - (ioctl): set held signal set
1520  - (ioctl): set traced fault set
1521  - (ioctl): set start pc (vaddr)
1522 
1523  Always clears the current fault. PI is the process or LWP to
1524  operate on. If STEP is true, set the process or LWP to trap after
1525  one instruction. If SIGNO is zero, clear the current signal if
1526  any; if non-zero, set the current signal to this one. Returns
1527  non-zero for success, zero for failure. */
1528 
1529 static int
1530 proc_run_process (procinfo *pi, int step, int signo)
1531 {
1532  int win;
1533  int runflags;
1534 
1535  /* We will probably have to apply this operation to individual
1536  threads, so make sure the control file descriptor is open. */
1537 
1538  if (pi->ctl_fd == 0 &&
1539  open_procinfo_files (pi, FD_CTL) == 0)
1540  {
1541  return 0;
1542  }
1543 
1544  runflags = PRCFAULT; /* Always clear current fault. */
1545  if (step)
1546  runflags |= PRSTEP;
1547  if (signo == 0)
1548  runflags |= PRCSIG;
1549  else if (signo != -1) /* -1 means do nothing W.R.T. signals. */
1550  proc_set_current_signal (pi, signo);
1551 
1552 #ifdef NEW_PROC_API
1553  {
1554  procfs_ctl_t cmd[2];
1555 
1556  cmd[0] = PCRUN;
1557  cmd[1] = runflags;
1558  win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
1559  }
1560 #else /* ioctl method */
1561  {
1562  prrun_t prrun;
1563 
1564  memset (&prrun, 0, sizeof (prrun));
1565  prrun.pr_flags = runflags;
1566  win = (ioctl (pi->ctl_fd, PIOCRUN, &prrun) >= 0);
1567  }
1568 #endif
1569 
1570  return win;
1571 }
1572 
1573 /* Register to trace signals in the process or LWP. Returns non-zero
1574  for success, zero for failure. */
1575 
1576 static int
1577 proc_set_traced_signals (procinfo *pi, gdb_sigset_t *sigset)
1578 {
1579  int win;
1580 
1581  /* We should never have to apply this operation to any procinfo
1582  except the one for the main process. If that ever changes for
1583  any reason, then take out the following clause and replace it
1584  with one that makes sure the ctl_fd is open. */
1585 
1586  if (pi->tid != 0)
1587  pi = find_procinfo_or_die (pi->pid, 0);
1588 
1589 #ifdef NEW_PROC_API
1590  {
1591  struct {
1592  procfs_ctl_t cmd;
1593  /* Use char array to avoid alignment issues. */
1594  char sigset[sizeof (gdb_sigset_t)];
1595  } arg;
1596 
1597  arg.cmd = PCSTRACE;
1598  memcpy (&arg.sigset, sigset, sizeof (gdb_sigset_t));
1599 
1600  win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
1601  }
1602 #else /* ioctl method */
1603  win = (ioctl (pi->ctl_fd, PIOCSTRACE, sigset) >= 0);
1604 #endif
1605  /* The above operation renders the procinfo's cached pstatus obsolete. */
1606  pi->status_valid = 0;
1607 
1608  if (!win)
1609  warning (_("procfs: set_traced_signals failed"));
1610  return win;
1611 }
1612 
1613 /* Register to trace hardware faults in the process or LWP. Returns
1614  non-zero for success, zero for failure. */
1615 
1616 static int
1617 proc_set_traced_faults (procinfo *pi, fltset_t *fltset)
1618 {
1619  int win;
1620 
1621  /* We should never have to apply this operation to any procinfo
1622  except the one for the main process. If that ever changes for
1623  any reason, then take out the following clause and replace it
1624  with one that makes sure the ctl_fd is open. */
1625 
1626  if (pi->tid != 0)
1627  pi = find_procinfo_or_die (pi->pid, 0);
1628 
1629 #ifdef NEW_PROC_API
1630  {
1631  struct {
1632  procfs_ctl_t cmd;
1633  /* Use char array to avoid alignment issues. */
1634  char fltset[sizeof (fltset_t)];
1635  } arg;
1636 
1637  arg.cmd = PCSFAULT;
1638  memcpy (&arg.fltset, fltset, sizeof (fltset_t));
1639 
1640  win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
1641  }
1642 #else /* ioctl method */
1643  win = (ioctl (pi->ctl_fd, PIOCSFAULT, fltset) >= 0);
1644 #endif
1645  /* The above operation renders the procinfo's cached pstatus obsolete. */
1646  pi->status_valid = 0;
1647 
1648  return win;
1649 }
1650 
1651 /* Register to trace entry to system calls in the process or LWP.
1652  Returns non-zero for success, zero for failure. */
1653 
1654 static int
1655 proc_set_traced_sysentry (procinfo *pi, sysset_t *sysset)
1656 {
1657  int win;
1658 
1659  /* We should never have to apply this operation to any procinfo
1660  except the one for the main process. If that ever changes for
1661  any reason, then take out the following clause and replace it
1662  with one that makes sure the ctl_fd is open. */
1663 
1664  if (pi->tid != 0)
1665  pi = find_procinfo_or_die (pi->pid, 0);
1666 
1667 #ifdef NEW_PROC_API
1668  {
1669  struct gdb_proc_ctl_pcsentry {
1670  procfs_ctl_t cmd;
1671  /* Use char array to avoid alignment issues. */
1672  char sysset[sizeof (sysset_t)];
1673  } *argp;
1674  int argp_size = sizeof (struct gdb_proc_ctl_pcsentry)
1675  - sizeof (sysset_t)
1676  + sysset_t_size (pi);
1677 
1678  argp = xmalloc (argp_size);
1679 
1680  argp->cmd = PCSENTRY;
1681  memcpy (&argp->sysset, sysset, sysset_t_size (pi));
1682 
1683  win = (write (pi->ctl_fd, (char *) argp, argp_size) == argp_size);
1684  xfree (argp);
1685  }
1686 #else /* ioctl method */
1687  win = (ioctl (pi->ctl_fd, PIOCSENTRY, sysset) >= 0);
1688 #endif
1689  /* The above operation renders the procinfo's cached pstatus
1690  obsolete. */
1691  pi->status_valid = 0;
1692 
1693  return win;
1694 }
1695 
1696 /* Register to trace exit from system calls in the process or LWP.
1697  Returns non-zero for success, zero for failure. */
1698 
1699 static int
1700 proc_set_traced_sysexit (procinfo *pi, sysset_t *sysset)
1701 {
1702  int win;
1703 
1704  /* We should never have to apply this operation to any procinfo
1705  except the one for the main process. If that ever changes for
1706  any reason, then take out the following clause and replace it
1707  with one that makes sure the ctl_fd is open. */
1708 
1709  if (pi->tid != 0)
1710  pi = find_procinfo_or_die (pi->pid, 0);
1711 
1712 #ifdef NEW_PROC_API
1713  {
1714  struct gdb_proc_ctl_pcsexit {
1715  procfs_ctl_t cmd;
1716  /* Use char array to avoid alignment issues. */
1717  char sysset[sizeof (sysset_t)];
1718  } *argp;
1719  int argp_size = sizeof (struct gdb_proc_ctl_pcsexit)
1720  - sizeof (sysset_t)
1721  + sysset_t_size (pi);
1722 
1723  argp = xmalloc (argp_size);
1724 
1725  argp->cmd = PCSEXIT;
1726  memcpy (&argp->sysset, sysset, sysset_t_size (pi));
1727 
1728  win = (write (pi->ctl_fd, (char *) argp, argp_size) == argp_size);
1729  xfree (argp);
1730  }
1731 #else /* ioctl method */
1732  win = (ioctl (pi->ctl_fd, PIOCSEXIT, sysset) >= 0);
1733 #endif
1734  /* The above operation renders the procinfo's cached pstatus
1735  obsolete. */
1736  pi->status_valid = 0;
1737 
1738  return win;
1739 }
1740 
1741 /* Specify the set of blocked / held signals in the process or LWP.
1742  Returns non-zero for success, zero for failure. */
1743 
1744 static int
1745 proc_set_held_signals (procinfo *pi, gdb_sigset_t *sighold)
1746 {
1747  int win;
1748 
1749  /* We should never have to apply this operation to any procinfo
1750  except the one for the main process. If that ever changes for
1751  any reason, then take out the following clause and replace it
1752  with one that makes sure the ctl_fd is open. */
1753 
1754  if (pi->tid != 0)
1755  pi = find_procinfo_or_die (pi->pid, 0);
1756 
1757 #ifdef NEW_PROC_API
1758  {
1759  struct {
1760  procfs_ctl_t cmd;
1761  /* Use char array to avoid alignment issues. */
1762  char hold[sizeof (gdb_sigset_t)];
1763  } arg;
1764 
1765  arg.cmd = PCSHOLD;
1766  memcpy (&arg.hold, sighold, sizeof (gdb_sigset_t));
1767  win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
1768  }
1769 #else
1770  win = (ioctl (pi->ctl_fd, PIOCSHOLD, sighold) >= 0);
1771 #endif
1772  /* The above operation renders the procinfo's cached pstatus
1773  obsolete. */
1774  pi->status_valid = 0;
1775 
1776  return win;
1777 }
1778 
1779 /* Returns the set of signals that are held / blocked. Will also copy
1780  the sigset if SAVE is non-zero. */
1781 
1782 static gdb_sigset_t *
1783 proc_get_held_signals (procinfo *pi, gdb_sigset_t *save)
1784 {
1785  gdb_sigset_t *ret = NULL;
1786 
1787  /* We should never have to apply this operation to any procinfo
1788  except the one for the main process. If that ever changes for
1789  any reason, then take out the following clause and replace it
1790  with one that makes sure the ctl_fd is open. */
1791 
1792  if (pi->tid != 0)
1793  pi = find_procinfo_or_die (pi->pid, 0);
1794 
1795 #ifdef NEW_PROC_API
1796  if (!pi->status_valid)
1797  if (!proc_get_status (pi))
1798  return NULL;
1799 
1800  ret = &pi->prstatus.pr_lwp.pr_lwphold;
1801 #else /* not NEW_PROC_API */
1802  {
1803  static gdb_sigset_t sigheld;
1804 
1805  if (ioctl (pi->ctl_fd, PIOCGHOLD, &sigheld) >= 0)
1806  ret = &sigheld;
1807  }
1808 #endif /* NEW_PROC_API */
1809  if (save && ret)
1810  memcpy (save, ret, sizeof (gdb_sigset_t));
1811 
1812  return ret;
1813 }
1814 
1815 /* Returns the set of signals that are traced / debugged. Will also
1816  copy the sigset if SAVE is non-zero. */
1817 
1818 static gdb_sigset_t *
1819 proc_get_traced_signals (procinfo *pi, gdb_sigset_t *save)
1820 {
1821  gdb_sigset_t *ret = NULL;
1822 
1823  /* We should never have to apply this operation to any procinfo
1824  except the one for the main process. If that ever changes for
1825  any reason, then take out the following clause and replace it
1826  with one that makes sure the ctl_fd is open. */
1827 
1828  if (pi->tid != 0)
1829  pi = find_procinfo_or_die (pi->pid, 0);
1830 
1831 #ifdef NEW_PROC_API
1832  if (!pi->status_valid)
1833  if (!proc_get_status (pi))
1834  return NULL;
1835 
1836  ret = &pi->prstatus.pr_sigtrace;
1837 #else
1838  {
1839  static gdb_sigset_t sigtrace;
1840 
1841  if (ioctl (pi->ctl_fd, PIOCGTRACE, &sigtrace) >= 0)
1842  ret = &sigtrace;
1843  }
1844 #endif
1845  if (save && ret)
1846  memcpy (save, ret, sizeof (gdb_sigset_t));
1847 
1848  return ret;
1849 }
1850 
1851 /* Returns the set of hardware faults that are traced /debugged. Will
1852  also copy the faultset if SAVE is non-zero. */
1853 
1854 static fltset_t *
1855 proc_get_traced_faults (procinfo *pi, fltset_t *save)
1856 {
1857  fltset_t *ret = NULL;
1858 
1859  /* We should never have to apply this operation to any procinfo
1860  except the one for the main process. If that ever changes for
1861  any reason, then take out the following clause and replace it
1862  with one that makes sure the ctl_fd is open. */
1863 
1864  if (pi->tid != 0)
1865  pi = find_procinfo_or_die (pi->pid, 0);
1866 
1867 #ifdef NEW_PROC_API
1868  if (!pi->status_valid)
1869  if (!proc_get_status (pi))
1870  return NULL;
1871 
1872  ret = &pi->prstatus.pr_flttrace;
1873 #else
1874  {
1875  static fltset_t flttrace;
1876 
1877  if (ioctl (pi->ctl_fd, PIOCGFAULT, &flttrace) >= 0)
1878  ret = &flttrace;
1879  }
1880 #endif
1881  if (save && ret)
1882  memcpy (save, ret, sizeof (fltset_t));
1883 
1884  return ret;
1885 }
1886 
1887 /* Returns the set of syscalls that are traced /debugged on entry.
1888  Will also copy the syscall set if SAVE is non-zero. */
1889 
1890 static sysset_t *
1891 proc_get_traced_sysentry (procinfo *pi, sysset_t *save)
1892 {
1893  sysset_t *ret = NULL;
1894 
1895  /* We should never have to apply this operation to any procinfo
1896  except the one for the main process. If that ever changes for
1897  any reason, then take out the following clause and replace it
1898  with one that makes sure the ctl_fd is open. */
1899 
1900  if (pi->tid != 0)
1901  pi = find_procinfo_or_die (pi->pid, 0);
1902 
1903 #ifdef NEW_PROC_API
1904  if (!pi->status_valid)
1905  if (!proc_get_status (pi))
1906  return NULL;
1907 
1908 #ifndef DYNAMIC_SYSCALLS
1909  ret = &pi->prstatus.pr_sysentry;
1910 #else /* DYNAMIC_SYSCALLS */
1911  {
1912  static sysset_t *sysentry;
1913  size_t size;
1914 
1915  if (!sysentry)
1916  sysentry = sysset_t_alloc (pi);
1917  ret = sysentry;
1918  if (pi->status_fd == 0 && open_procinfo_files (pi, FD_STATUS) == 0)
1919  return NULL;
1920  if (pi->prstatus.pr_sysentry_offset == 0)
1921  {
1922  gdb_premptysysset (sysentry);
1923  }
1924  else
1925  {
1926  int rsize;
1927 
1928  if (lseek (pi->status_fd, (off_t) pi->prstatus.pr_sysentry_offset,
1929  SEEK_SET)
1930  != (off_t) pi->prstatus.pr_sysentry_offset)
1931  return NULL;
1932  size = sysset_t_size (pi);
1933  gdb_premptysysset (sysentry);
1934  rsize = read (pi->status_fd, sysentry, size);
1935  if (rsize < 0)
1936  return NULL;
1937  }
1938  }
1939 #endif /* DYNAMIC_SYSCALLS */
1940 #else /* !NEW_PROC_API */
1941  {
1942  static sysset_t sysentry;
1943 
1944  if (ioctl (pi->ctl_fd, PIOCGENTRY, &sysentry) >= 0)
1945  ret = &sysentry;
1946  }
1947 #endif /* NEW_PROC_API */
1948  if (save && ret)
1949  memcpy (save, ret, sysset_t_size (pi));
1950 
1951  return ret;
1952 }
1953 
1954 /* Returns the set of syscalls that are traced /debugged on exit.
1955  Will also copy the syscall set if SAVE is non-zero. */
1956 
1957 static sysset_t *
1958 proc_get_traced_sysexit (procinfo *pi, sysset_t *save)
1959 {
1960  sysset_t * ret = NULL;
1961 
1962  /* We should never have to apply this operation to any procinfo
1963  except the one for the main process. If that ever changes for
1964  any reason, then take out the following clause and replace it
1965  with one that makes sure the ctl_fd is open. */
1966 
1967  if (pi->tid != 0)
1968  pi = find_procinfo_or_die (pi->pid, 0);
1969 
1970 #ifdef NEW_PROC_API
1971  if (!pi->status_valid)
1972  if (!proc_get_status (pi))
1973  return NULL;
1974 
1975 #ifndef DYNAMIC_SYSCALLS
1976  ret = &pi->prstatus.pr_sysexit;
1977 #else /* DYNAMIC_SYSCALLS */
1978  {
1979  static sysset_t *sysexit;
1980  size_t size;
1981 
1982  if (!sysexit)
1983  sysexit = sysset_t_alloc (pi);
1984  ret = sysexit;
1985  if (pi->status_fd == 0 && open_procinfo_files (pi, FD_STATUS) == 0)
1986  return NULL;
1987  if (pi->prstatus.pr_sysexit_offset == 0)
1988  {
1989  gdb_premptysysset (sysexit);
1990  }
1991  else
1992  {
1993  int rsize;
1994 
1995  if (lseek (pi->status_fd, (off_t) pi->prstatus.pr_sysexit_offset,
1996  SEEK_SET)
1997  != (off_t) pi->prstatus.pr_sysexit_offset)
1998  return NULL;
1999  size = sysset_t_size (pi);
2000  gdb_premptysysset (sysexit);
2001  rsize = read (pi->status_fd, sysexit, size);
2002  if (rsize < 0)
2003  return NULL;
2004  }
2005  }
2006 #endif /* DYNAMIC_SYSCALLS */
2007 #else
2008  {
2009  static sysset_t sysexit;
2010 
2011  if (ioctl (pi->ctl_fd, PIOCGEXIT, &sysexit) >= 0)
2012  ret = &sysexit;
2013  }
2014 #endif
2015  if (save && ret)
2016  memcpy (save, ret, sysset_t_size (pi));
2017 
2018  return ret;
2019 }
2020 
2021 /* The current fault (if any) is cleared; the associated signal will
2022  not be sent to the process or LWP when it resumes. Returns
2023  non-zero for success, zero for failure. */
2024 
2025 static int
2027 {
2028  int win;
2029 
2030  /* We should never have to apply this operation to any procinfo
2031  except the one for the main process. If that ever changes for
2032  any reason, then take out the following clause and replace it
2033  with one that makes sure the ctl_fd is open. */
2034 
2035  if (pi->tid != 0)
2036  pi = find_procinfo_or_die (pi->pid, 0);
2037 
2038 #ifdef NEW_PROC_API
2039  {
2040  procfs_ctl_t cmd = PCCFAULT;
2041 
2042  win = (write (pi->ctl_fd, (void *) &cmd, sizeof (cmd)) == sizeof (cmd));
2043  }
2044 #else
2045  win = (ioctl (pi->ctl_fd, PIOCCFAULT, 0) >= 0);
2046 #endif
2047 
2048  return win;
2049 }
2050 
2051 /* Set the "current signal" that will be delivered next to the
2052  process. NOTE: semantics are different from those of KILL. This
2053  signal will be delivered to the process or LWP immediately when it
2054  is resumed (even if the signal is held/blocked); it will NOT
2055  immediately cause another event of interest, and will NOT first
2056  trap back to the debugger. Returns non-zero for success, zero for
2057  failure. */
2058 
2059 static int
2061 {
2062  int win;
2063  struct {
2064  procfs_ctl_t cmd;
2065  /* Use char array to avoid alignment issues. */
2066  char sinfo[sizeof (gdb_siginfo_t)];
2067  } arg;
2068  gdb_siginfo_t mysinfo;
2069  ptid_t wait_ptid;
2070  struct target_waitstatus wait_status;
2071 
2072  /* We should never have to apply this operation to any procinfo
2073  except the one for the main process. If that ever changes for
2074  any reason, then take out the following clause and replace it
2075  with one that makes sure the ctl_fd is open. */
2076 
2077  if (pi->tid != 0)
2078  pi = find_procinfo_or_die (pi->pid, 0);
2079 
2080 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
2081  /* With Alpha OSF/1 procfs, the kernel gets really confused if it
2082  receives a PIOCSSIG with a signal identical to the current
2083  signal, it messes up the current signal. Work around the kernel
2084  bug. */
2085  if (signo > 0 &&
2086  signo == proc_cursig (pi))
2087  return 1; /* I assume this is a success? */
2088 #endif
2089 
2090  /* The pointer is just a type alias. */
2091  get_last_target_status (&wait_ptid, &wait_status);
2092  if (ptid_equal (wait_ptid, inferior_ptid)
2093  && wait_status.kind == TARGET_WAITKIND_STOPPED
2094  && wait_status.value.sig == gdb_signal_from_host (signo)
2095  && proc_get_status (pi)
2096 #ifdef NEW_PROC_API
2097  && pi->prstatus.pr_lwp.pr_info.si_signo == signo
2098 #else
2099  && pi->prstatus.pr_info.si_signo == signo
2100 #endif
2101  )
2102  /* Use the siginfo associated with the signal being
2103  redelivered. */
2104 #ifdef NEW_PROC_API
2105  memcpy (arg.sinfo, &pi->prstatus.pr_lwp.pr_info, sizeof (gdb_siginfo_t));
2106 #else
2107  memcpy (arg.sinfo, &pi->prstatus.pr_info, sizeof (gdb_siginfo_t));
2108 #endif
2109  else
2110  {
2111  mysinfo.si_signo = signo;
2112  mysinfo.si_code = 0;
2113  mysinfo.si_pid = getpid (); /* ?why? */
2114  mysinfo.si_uid = getuid (); /* ?why? */
2115  memcpy (arg.sinfo, &mysinfo, sizeof (gdb_siginfo_t));
2116  }
2117 
2118 #ifdef NEW_PROC_API
2119  arg.cmd = PCSSIG;
2120  win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
2121 #else
2122  win = (ioctl (pi->ctl_fd, PIOCSSIG, (void *) &arg.sinfo) >= 0);
2123 #endif
2124 
2125  return win;
2126 }
2127 
2128 /* The current signal (if any) is cleared, and is not sent to the
2129  process or LWP when it resumes. Returns non-zero for success, zero
2130  for failure. */
2131 
2132 static int
2134 {
2135  int win;
2136 
2137  /* We should never have to apply this operation to any procinfo
2138  except the one for the main process. If that ever changes for
2139  any reason, then take out the following clause and replace it
2140  with one that makes sure the ctl_fd is open. */
2141 
2142  if (pi->tid != 0)
2143  pi = find_procinfo_or_die (pi->pid, 0);
2144 
2145 #ifdef NEW_PROC_API
2146  {
2147  struct {
2148  procfs_ctl_t cmd;
2149  /* Use char array to avoid alignment issues. */
2150  char sinfo[sizeof (gdb_siginfo_t)];
2151  } arg;
2152  gdb_siginfo_t mysinfo;
2153 
2154  arg.cmd = PCSSIG;
2155  /* The pointer is just a type alias. */
2156  mysinfo.si_signo = 0;
2157  mysinfo.si_code = 0;
2158  mysinfo.si_errno = 0;
2159  mysinfo.si_pid = getpid (); /* ?why? */
2160  mysinfo.si_uid = getuid (); /* ?why? */
2161  memcpy (arg.sinfo, &mysinfo, sizeof (gdb_siginfo_t));
2162 
2163  win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
2164  }
2165 #else
2166  win = (ioctl (pi->ctl_fd, PIOCSSIG, 0) >= 0);
2167 #endif
2168 
2169  return win;
2170 }
2171 
2172 /* Return the general-purpose registers for the process or LWP
2173  corresponding to PI. Upon failure, return NULL. */
2174 
2175 static gdb_gregset_t *
2177 {
2178  if (!pi->status_valid || !pi->gregs_valid)
2179  if (!proc_get_status (pi))
2180  return NULL;
2181 
2182 #ifdef NEW_PROC_API
2183  return &pi->prstatus.pr_lwp.pr_reg;
2184 #else
2185  return &pi->prstatus.pr_reg;
2186 #endif
2187 }
2188 
2189 /* Return the general-purpose registers for the process or LWP
2190  corresponding to PI. Upon failure, return NULL. */
2191 
2192 static gdb_fpregset_t *
2194 {
2195 #ifdef NEW_PROC_API
2196  if (!pi->status_valid || !pi->fpregs_valid)
2197  if (!proc_get_status (pi))
2198  return NULL;
2199 
2200  return &pi->prstatus.pr_lwp.pr_fpreg;
2201 
2202 #else /* not NEW_PROC_API */
2203  if (pi->fpregs_valid)
2204  return &pi->fpregset; /* Already got 'em. */
2205  else
2206  {
2207  if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0)
2208  {
2209  return NULL;
2210  }
2211  else
2212  {
2213 # ifdef PIOCTGFPREG
2214  struct {
2215  long pr_count;
2216  tid_t pr_error_thread;
2217  tfpregset_t thread_1;
2218  } thread_fpregs;
2219 
2220  thread_fpregs.pr_count = 1;
2221  thread_fpregs.thread_1.tid = pi->tid;
2222 
2223  if (pi->tid == 0
2224  && ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset) >= 0)
2225  {
2226  pi->fpregs_valid = 1;
2227  return &pi->fpregset; /* Got 'em now! */
2228  }
2229  else if (pi->tid != 0
2230  && ioctl (pi->ctl_fd, PIOCTGFPREG, &thread_fpregs) >= 0)
2231  {
2232  memcpy (&pi->fpregset, &thread_fpregs.thread_1.pr_fpregs,
2233  sizeof (pi->fpregset));
2234  pi->fpregs_valid = 1;
2235  return &pi->fpregset; /* Got 'em now! */
2236  }
2237  else
2238  {
2239  return NULL;
2240  }
2241 # else
2242  if (ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset) >= 0)
2243  {
2244  pi->fpregs_valid = 1;
2245  return &pi->fpregset; /* Got 'em now! */
2246  }
2247  else
2248  {
2249  return NULL;
2250  }
2251 # endif
2252  }
2253  }
2254 #endif /* NEW_PROC_API */
2255 }
2256 
2257 /* Write the general-purpose registers back to the process or LWP
2258  corresponding to PI. Return non-zero for success, zero for
2259  failure. */
2260 
2261 static int
2263 {
2264  gdb_gregset_t *gregs;
2265  int win;
2266 
2267  gregs = proc_get_gregs (pi);
2268  if (gregs == NULL)
2269  return 0; /* proc_get_regs has already warned. */
2270 
2271  if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0)
2272  {
2273  return 0;
2274  }
2275  else
2276  {
2277 #ifdef NEW_PROC_API
2278  struct {
2279  procfs_ctl_t cmd;
2280  /* Use char array to avoid alignment issues. */
2281  char gregs[sizeof (gdb_gregset_t)];
2282  } arg;
2283 
2284  arg.cmd = PCSREG;
2285  memcpy (&arg.gregs, gregs, sizeof (arg.gregs));
2286  win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
2287 #else
2288  win = (ioctl (pi->ctl_fd, PIOCSREG, gregs) >= 0);
2289 #endif
2290  }
2291 
2292  /* Policy: writing the registers invalidates our cache. */
2293  pi->gregs_valid = 0;
2294  return win;
2295 }
2296 
2297 /* Write the floating-pointer registers back to the process or LWP
2298  corresponding to PI. Return non-zero for success, zero for
2299  failure. */
2300 
2301 static int
2303 {
2304  gdb_fpregset_t *fpregs;
2305  int win;
2306 
2307  fpregs = proc_get_fpregs (pi);
2308  if (fpregs == NULL)
2309  return 0; /* proc_get_fpregs has already warned. */
2310 
2311  if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0)
2312  {
2313  return 0;
2314  }
2315  else
2316  {
2317 #ifdef NEW_PROC_API
2318  struct {
2319  procfs_ctl_t cmd;
2320  /* Use char array to avoid alignment issues. */
2321  char fpregs[sizeof (gdb_fpregset_t)];
2322  } arg;
2323 
2324  arg.cmd = PCSFPREG;
2325  memcpy (&arg.fpregs, fpregs, sizeof (arg.fpregs));
2326  win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
2327 #else
2328 # ifdef PIOCTSFPREG
2329  if (pi->tid == 0)
2330  win = (ioctl (pi->ctl_fd, PIOCSFPREG, fpregs) >= 0);
2331  else
2332  {
2333  struct {
2334  long pr_count;
2335  tid_t pr_error_thread;
2336  tfpregset_t thread_1;
2337  } thread_fpregs;
2338 
2339  thread_fpregs.pr_count = 1;
2340  thread_fpregs.thread_1.tid = pi->tid;
2341  memcpy (&thread_fpregs.thread_1.pr_fpregs, fpregs,
2342  sizeof (*fpregs));
2343  win = (ioctl (pi->ctl_fd, PIOCTSFPREG, &thread_fpregs) >= 0);
2344  }
2345 # else
2346  win = (ioctl (pi->ctl_fd, PIOCSFPREG, fpregs) >= 0);
2347 # endif
2348 #endif /* NEW_PROC_API */
2349  }
2350 
2351  /* Policy: writing the registers invalidates our cache. */
2352  pi->fpregs_valid = 0;
2353  return win;
2354 }
2355 
2356 /* Send a signal to the proc or lwp with the semantics of "kill()".
2357  Returns non-zero for success, zero for failure. */
2358 
2359 static int
2360 proc_kill (procinfo *pi, int signo)
2361 {
2362  int win;
2363 
2364  /* We might conceivably apply this operation to an LWP, and the
2365  LWP's ctl file descriptor might not be open. */
2366 
2367  if (pi->ctl_fd == 0 &&
2368  open_procinfo_files (pi, FD_CTL) == 0)
2369  {
2370  return 0;
2371  }
2372  else
2373  {
2374 #ifdef NEW_PROC_API
2375  procfs_ctl_t cmd[2];
2376 
2377  cmd[0] = PCKILL;
2378  cmd[1] = signo;
2379  win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
2380 #else /* ioctl method */
2381  /* FIXME: do I need the Alpha OSF fixups present in
2382  procfs.c/unconditionally_kill_inferior? Perhaps only for SIGKILL? */
2383  win = (ioctl (pi->ctl_fd, PIOCKILL, &signo) >= 0);
2384 #endif
2385  }
2386 
2387  return win;
2388 }
2389 
2390 /* Find the pid of the process that started this one. Returns the
2391  parent process pid, or zero. */
2392 
2393 static int
2395 {
2396  /* We should never have to apply this operation to any procinfo
2397  except the one for the main process. If that ever changes for
2398  any reason, then take out the following clause and replace it
2399  with one that makes sure the ctl_fd is open. */
2400 
2401  if (pi->tid != 0)
2402  pi = find_procinfo_or_die (pi->pid, 0);
2403 
2404  if (!pi->status_valid)
2405  if (!proc_get_status (pi))
2406  return 0;
2407 
2408  return pi->prstatus.pr_ppid;
2409 }
2410 
2411 /* Convert a target address (a.k.a. CORE_ADDR) into a host address
2412  (a.k.a void pointer)! */
2413 
2414 #if (defined (PCWATCH) || defined (PIOCSWATCH)) \
2415  && !(defined (PIOCOPENLWP))
2416 static void *
2417 procfs_address_to_host_pointer (CORE_ADDR addr)
2418 {
2419  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
2420  void *ptr;
2421 
2422  gdb_assert (sizeof (ptr) == TYPE_LENGTH (ptr_type));
2424  (gdb_byte *) &ptr, addr);
2425  return ptr;
2426 }
2427 #endif
2428 
2429 static int
2430 proc_set_watchpoint (procinfo *pi, CORE_ADDR addr, int len, int wflags)
2431 {
2432 #if !defined (PCWATCH) && !defined (PIOCSWATCH)
2433  /* If neither or these is defined, we can't support watchpoints.
2434  This just avoids possibly failing to compile the below on such
2435  systems. */
2436  return 0;
2437 #else
2438 /* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5. */
2439 #if defined (PIOCOPENLWP) /* Solaris 2.5: bail out. */
2440  return 0;
2441 #else
2442  struct {
2443  procfs_ctl_t cmd;
2444  char watch[sizeof (prwatch_t)];
2445  } arg;
2446  prwatch_t pwatch;
2447 
2448  /* NOTE: cagney/2003-02-01: Even more horrible hack. Need to
2449  convert a target address into something that can be stored in a
2450  native data structure. */
2451 #ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */
2452  pwatch.pr_vaddr = (uintptr_t) procfs_address_to_host_pointer (addr);
2453 #else
2454  pwatch.pr_vaddr = (caddr_t) procfs_address_to_host_pointer (addr);
2455 #endif
2456  pwatch.pr_size = len;
2457  pwatch.pr_wflags = wflags;
2458 #if defined(NEW_PROC_API) && defined (PCWATCH)
2459  arg.cmd = PCWATCH;
2460  memcpy (arg.watch, &pwatch, sizeof (prwatch_t));
2461  return (write (pi->ctl_fd, &arg, sizeof (arg)) == sizeof (arg));
2462 #else
2463 #if defined (PIOCSWATCH)
2464  return (ioctl (pi->ctl_fd, PIOCSWATCH, &pwatch) >= 0);
2465 #else
2466  return 0; /* Fail */
2467 #endif
2468 #endif
2469 #endif
2470 #endif
2471 }
2472 
2473 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
2474 
2475 #include <sys/sysi86.h>
2476 
2477 /* The KEY is actually the value of the lower 16 bits of the GS
2478  register for the LWP that we're interested in. Returns the
2479  matching ssh struct (LDT entry). */
2480 
2481 static struct ssd *
2482 proc_get_LDT_entry (procinfo *pi, int key)
2483 {
2484  static struct ssd *ldt_entry = NULL;
2485 #ifdef NEW_PROC_API
2486  char pathname[MAX_PROC_NAME_SIZE];
2487  struct cleanup *old_chain = NULL;
2488  int fd;
2489 
2490  /* Allocate space for one LDT entry.
2491  This alloc must persist, because we return a pointer to it. */
2492  if (ldt_entry == NULL)
2493  ldt_entry = (struct ssd *) xmalloc (sizeof (struct ssd));
2494 
2495  /* Open the file descriptor for the LDT table. */
2496  sprintf (pathname, "/proc/%d/ldt", pi->pid);
2497  if ((fd = open_with_retry (pathname, O_RDONLY)) < 0)
2498  {
2499  proc_warn (pi, "proc_get_LDT_entry (open)", __LINE__);
2500  return NULL;
2501  }
2502  /* Make sure it gets closed again! */
2503  old_chain = make_cleanup_close (fd);
2504 
2505  /* Now 'read' thru the table, find a match and return it. */
2506  while (read (fd, ldt_entry, sizeof (struct ssd)) == sizeof (struct ssd))
2507  {
2508  if (ldt_entry->sel == 0 &&
2509  ldt_entry->bo == 0 &&
2510  ldt_entry->acc1 == 0 &&
2511  ldt_entry->acc2 == 0)
2512  break; /* end of table */
2513  /* If key matches, return this entry. */
2514  if (ldt_entry->sel == key)
2515  return ldt_entry;
2516  }
2517  /* Loop ended, match not found. */
2518  return NULL;
2519 #else
2520  int nldt, i;
2521  static int nalloc = 0;
2522 
2523  /* Get the number of LDT entries. */
2524  if (ioctl (pi->ctl_fd, PIOCNLDT, &nldt) < 0)
2525  {
2526  proc_warn (pi, "proc_get_LDT_entry (PIOCNLDT)", __LINE__);
2527  return NULL;
2528  }
2529 
2530  /* Allocate space for the number of LDT entries. */
2531  /* This alloc has to persist, 'cause we return a pointer to it. */
2532  if (nldt > nalloc)
2533  {
2534  ldt_entry = (struct ssd *)
2535  xrealloc (ldt_entry, (nldt + 1) * sizeof (struct ssd));
2536  nalloc = nldt;
2537  }
2538 
2539  /* Read the whole table in one gulp. */
2540  if (ioctl (pi->ctl_fd, PIOCLDT, ldt_entry) < 0)
2541  {
2542  proc_warn (pi, "proc_get_LDT_entry (PIOCLDT)", __LINE__);
2543  return NULL;
2544  }
2545 
2546  /* Search the table and return the (first) entry matching 'key'. */
2547  for (i = 0; i < nldt; i++)
2548  if (ldt_entry[i].sel == key)
2549  return &ldt_entry[i];
2550 
2551  /* Loop ended, match not found. */
2552  return NULL;
2553 #endif
2554 }
2555 
2556 /* Returns the pointer to the LDT entry of PTID. */
2557 
2558 struct ssd *
2559 procfs_find_LDT_entry (ptid_t ptid)
2560 {
2561  gdb_gregset_t *gregs;
2562  int key;
2563  procinfo *pi;
2564 
2565  /* Find procinfo for the lwp. */
2566  if ((pi = find_procinfo (ptid_get_pid (ptid), ptid_get_lwp (ptid))) == NULL)
2567  {
2568  warning (_("procfs_find_LDT_entry: could not find procinfo for %d:%ld."),
2569  ptid_get_pid (ptid), ptid_get_lwp (ptid));
2570  return NULL;
2571  }
2572  /* get its general registers. */
2573  if ((gregs = proc_get_gregs (pi)) == NULL)
2574  {
2575  warning (_("procfs_find_LDT_entry: could not read gregs for %d:%ld."),
2576  ptid_get_pid (ptid), ptid_get_lwp (ptid));
2577  return NULL;
2578  }
2579  /* Now extract the GS register's lower 16 bits. */
2580  key = (*gregs)[GS] & 0xffff;
2581 
2582  /* Find the matching entry and return it. */
2583  return proc_get_LDT_entry (pi, key);
2584 }
2585 
2586 #endif
2587 
2588 /* =============== END, non-thread part of /proc "MODULE" =============== */
2589 
2590 /* =================== Thread "MODULE" =================== */
2591 
2592 /* NOTE: you'll see more ifdefs and duplication of functions here,
2593  since there is a different way to do threads on every OS. */
2594 
2595 /* Returns the number of threads for the process. */
2596 
2597 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2598 /* OSF version */
2599 static int
2601 {
2602  int nthreads = 0;
2603 
2604  if (ioctl (pi->ctl_fd, PIOCNTHR, &nthreads) < 0)
2605  proc_warn (pi, "procfs: PIOCNTHR failed", __LINE__);
2606 
2607  return nthreads;
2608 }
2609 
2610 #else
2611 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2612 /* Solaris version */
2613 static int
2615 {
2616  if (!pi->status_valid)
2617  if (!proc_get_status (pi))
2618  return 0;
2619 
2620  /* NEW_PROC_API: only works for the process procinfo, because the
2621  LWP procinfos do not get prstatus filled in. */
2622 #ifdef NEW_PROC_API
2623  if (pi->tid != 0) /* Find the parent process procinfo. */
2624  pi = find_procinfo_or_die (pi->pid, 0);
2625 #endif
2626  return pi->prstatus.pr_nlwp;
2627 }
2628 
2629 #else
2630 /* Default version */
2631 static int
2633 {
2634  return 0;
2635 }
2636 #endif
2637 #endif
2638 
2639 /* LWP version.
2640 
2641  Return the ID of the thread that had an event of interest.
2642  (ie. the one that hit a breakpoint or other traced event). All
2643  other things being equal, this should be the ID of a thread that is
2644  currently executing. */
2645 
2646 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2647 /* Solaris version */
2648 static int
2650 {
2651  /* Note: this should be applied to the root procinfo for the
2652  process, not to the procinfo for an LWP. If applied to the
2653  procinfo for an LWP, it will simply return that LWP's ID. In
2654  that case, find the parent process procinfo. */
2655 
2656  if (pi->tid != 0)
2657  pi = find_procinfo_or_die (pi->pid, 0);
2658 
2659  if (!pi->status_valid)
2660  if (!proc_get_status (pi))
2661  return 0;
2662 
2663 #ifdef NEW_PROC_API
2664  return pi->prstatus.pr_lwp.pr_lwpid;
2665 #else
2666  return pi->prstatus.pr_who;
2667 #endif
2668 }
2669 
2670 #else
2671 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2672 /* OSF version */
2673 static int
2675 {
2676 #if 0 /* FIXME: not ready for prime time? */
2677  return pi->prstatus.pr_tid;
2678 #else
2679  return 0;
2680 #endif
2681 }
2682 
2683 #else
2684 /* Default version */
2685 static int
2687 {
2688  return 0;
2689 }
2690 
2691 #endif
2692 #endif
2693 
2694 /* Discover the IDs of all the threads within the process, and create
2695  a procinfo for each of them (chained to the parent). This
2696  unfortunately requires a different method on every OS. Returns
2697  non-zero for success, zero for failure. */
2698 
2699 static int
2701 {
2702  if (thread && parent) /* sanity */
2703  {
2704  thread->status_valid = 0;
2705  if (!proc_get_status (thread))
2706  destroy_one_procinfo (&parent->thread_list, thread);
2707  }
2708  return 0; /* keep iterating */
2709 }
2710 
2711 #if defined (PIOCLSTATUS)
2712 /* Solaris 2.5 (ioctl) version */
2713 static int
2715 {
2716  gdb_prstatus_t *prstatus;
2717  struct cleanup *old_chain = NULL;
2718  procinfo *thread;
2719  int nlwp, i;
2720 
2721  /* We should never have to apply this operation to any procinfo
2722  except the one for the main process. If that ever changes for
2723  any reason, then take out the following clause and replace it
2724  with one that makes sure the ctl_fd is open. */
2725 
2726  if (pi->tid != 0)
2727  pi = find_procinfo_or_die (pi->pid, 0);
2728 
2730 
2731  if ((nlwp = proc_get_nthreads (pi)) <= 1)
2732  return 1; /* Process is not multi-threaded; nothing to do. */
2733 
2734  prstatus = xmalloc (sizeof (gdb_prstatus_t) * (nlwp + 1));
2735 
2736  old_chain = make_cleanup (xfree, prstatus);
2737  if (ioctl (pi->ctl_fd, PIOCLSTATUS, prstatus) < 0)
2738  proc_error (pi, "update_threads (PIOCLSTATUS)", __LINE__);
2739 
2740  /* Skip element zero, which represents the process as a whole. */
2741  for (i = 1; i < nlwp + 1; i++)
2742  {
2743  if ((thread = create_procinfo (pi->pid, prstatus[i].pr_who)) == NULL)
2744  proc_error (pi, "update_threads, create_procinfo", __LINE__);
2745 
2746  memcpy (&thread->prstatus, &prstatus[i], sizeof (*prstatus));
2747  thread->status_valid = 1;
2748  }
2749  pi->threads_valid = 1;
2750  do_cleanups (old_chain);
2751  return 1;
2752 }
2753 #else
2754 #ifdef NEW_PROC_API
2755 /* Solaris 6 (and later) version. */
2756 static void
2757 do_closedir_cleanup (void *dir)
2758 {
2759  closedir (dir);
2760 }
2761 
2762 static int
2764 {
2765  char pathname[MAX_PROC_NAME_SIZE + 16];
2766  struct dirent *direntry;
2767  struct cleanup *old_chain = NULL;
2768  procinfo *thread;
2769  DIR *dirp;
2770  int lwpid;
2771 
2772  /* We should never have to apply this operation to any procinfo
2773  except the one for the main process. If that ever changes for
2774  any reason, then take out the following clause and replace it
2775  with one that makes sure the ctl_fd is open. */
2776 
2777  if (pi->tid != 0)
2778  pi = find_procinfo_or_die (pi->pid, 0);
2779 
2781 
2782  /* Note: this brute-force method was originally devised for Unixware
2783  (support removed since), and will also work on Solaris 2.6 and
2784  2.7. The original comment mentioned the existence of a much
2785  simpler and more elegant way to do this on Solaris, but didn't
2786  point out what that was. */
2787 
2788  strcpy (pathname, pi->pathname);
2789  strcat (pathname, "/lwp");
2790  if ((dirp = opendir (pathname)) == NULL)
2791  proc_error (pi, "update_threads, opendir", __LINE__);
2792 
2793  old_chain = make_cleanup (do_closedir_cleanup, dirp);
2794  while ((direntry = readdir (dirp)) != NULL)
2795  if (direntry->d_name[0] != '.') /* skip '.' and '..' */
2796  {
2797  lwpid = atoi (&direntry->d_name[0]);
2798  if ((thread = create_procinfo (pi->pid, lwpid)) == NULL)
2799  proc_error (pi, "update_threads, create_procinfo", __LINE__);
2800  }
2801  pi->threads_valid = 1;
2802  do_cleanups (old_chain);
2803  return 1;
2804 }
2805 #else
2806 #ifdef PIOCTLIST
2807 /* OSF version */
2808 static int
2810 {
2811  int nthreads, i;
2812  tid_t *threads;
2813 
2814  /* We should never have to apply this operation to any procinfo
2815  except the one for the main process. If that ever changes for
2816  any reason, then take out the following clause and replace it
2817  with one that makes sure the ctl_fd is open. */
2818 
2819  if (pi->tid != 0)
2820  pi = find_procinfo_or_die (pi->pid, 0);
2821 
2823 
2824  nthreads = proc_get_nthreads (pi);
2825  if (nthreads < 2)
2826  return 0; /* Nothing to do for 1 or fewer threads. */
2827 
2828  threads = xmalloc (nthreads * sizeof (tid_t));
2829 
2830  if (ioctl (pi->ctl_fd, PIOCTLIST, threads) < 0)
2831  proc_error (pi, "procfs: update_threads (PIOCTLIST)", __LINE__);
2832 
2833  for (i = 0; i < nthreads; i++)
2834  {
2835  if (!find_procinfo (pi->pid, threads[i]))
2836  if (!create_procinfo (pi->pid, threads[i]))
2837  proc_error (pi, "update_threads, create_procinfo", __LINE__);
2838  }
2839  pi->threads_valid = 1;
2840  return 1;
2841 }
2842 #else
2843 /* Default version */
2844 static int
2846 {
2847  return 0;
2848 }
2849 #endif /* OSF PIOCTLIST */
2850 #endif /* NEW_PROC_API */
2851 #endif /* SOL 2.5 PIOCLSTATUS */
2852 
2853 /* Given a pointer to a function, call that function once for each lwp
2854  in the procinfo list, until the function returns non-zero, in which
2855  event return the value returned by the function.
2856 
2857  Note: this function does NOT call update_threads. If you want to
2858  discover new threads first, you must call that function explicitly.
2859  This function just makes a quick pass over the currently-known
2860  procinfos.
2861 
2862  PI is the parent process procinfo. FUNC is the per-thread
2863  function. PTR is an opaque parameter for function. Returns the
2864  first non-zero return value from the callee, or zero. */
2865 
2866 static int
2868  int (*func) (procinfo *, procinfo *, void *),
2869  void *ptr)
2870 {
2871  procinfo *thread, *next;
2872  int retval = 0;
2873 
2874  /* We should never have to apply this operation to any procinfo
2875  except the one for the main process. If that ever changes for
2876  any reason, then take out the following clause and replace it
2877  with one that makes sure the ctl_fd is open. */
2878 
2879  if (pi->tid != 0)
2880  pi = find_procinfo_or_die (pi->pid, 0);
2881 
2882  for (thread = pi->thread_list; thread != NULL; thread = next)
2883  {
2884  next = thread->next; /* In case thread is destroyed. */
2885  if ((retval = (*func) (pi, thread, ptr)) != 0)
2886  break;
2887  }
2888 
2889  return retval;
2890 }
2891 
2892 /* =================== END, Thread "MODULE" =================== */
2893 
2894 /* =================== END, /proc "MODULE" =================== */
2895 
2896 /* =================== GDB "MODULE" =================== */
2897 
2898 /* Here are all of the gdb target vector functions and their
2899  friends. */
2900 
2901 static ptid_t do_attach (ptid_t ptid);
2902 static void do_detach (int signo);
2903 static void proc_trace_syscalls_1 (procinfo *pi, int syscallnum,
2904  int entry_or_exit, int mode, int from_tty);
2905 
2906 /* Sets up the inferior to be debugged. Registers to trace signals,
2907  hardware faults, and syscalls. Note: does not set RLC flag: caller
2908  may want to customize that. Returns zero for success (note!
2909  unlike most functions in this module); on failure, returns the LINE
2910  NUMBER where it failed! */
2911 
2912 static int
2914 {
2915  fltset_t traced_faults;
2916  gdb_sigset_t traced_signals;
2917  sysset_t *traced_syscall_entries;
2918  sysset_t *traced_syscall_exits;
2919  int status;
2920 
2921  /* Register to trace hardware faults in the child. */
2922  prfillset (&traced_faults); /* trace all faults... */
2923  gdb_prdelset (&traced_faults, FLTPAGE); /* except page fault. */
2924  if (!proc_set_traced_faults (pi, &traced_faults))
2925  return __LINE__;
2926 
2927  /* Initially, register to trace all signals in the child. */
2928  prfillset (&traced_signals);
2929  if (!proc_set_traced_signals (pi, &traced_signals))
2930  return __LINE__;
2931 
2932 
2933  /* Register to trace the 'exit' system call (on entry). */
2934  traced_syscall_entries = sysset_t_alloc (pi);
2935  gdb_premptysysset (traced_syscall_entries);
2936 #ifdef SYS_exit
2937  gdb_praddsysset (traced_syscall_entries, SYS_exit);
2938 #endif
2939 #ifdef SYS_lwpexit
2940  gdb_praddsysset (traced_syscall_entries, SYS_lwpexit);/* And _lwp_exit... */
2941 #endif
2942 #ifdef SYS_lwp_exit
2943  gdb_praddsysset (traced_syscall_entries, SYS_lwp_exit);
2944 #endif
2945 #ifdef DYNAMIC_SYSCALLS
2946  {
2947  int callnum = find_syscall (pi, "_exit");
2948 
2949  if (callnum >= 0)
2950  gdb_praddsysset (traced_syscall_entries, callnum);
2951  }
2952 #endif
2953 
2954  status = proc_set_traced_sysentry (pi, traced_syscall_entries);
2955  xfree (traced_syscall_entries);
2956  if (!status)
2957  return __LINE__;
2958 
2959 #ifdef PRFS_STOPEXEC /* defined on OSF */
2960  /* OSF method for tracing exec syscalls. Quoting:
2961  Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
2962  exits from exec system calls because of the user level loader. */
2963  /* FIXME: make nice and maybe move into an access function. */
2964  {
2965  int prfs_flags;
2966 
2967  if (ioctl (pi->ctl_fd, PIOCGSPCACT, &prfs_flags) < 0)
2968  return __LINE__;
2969 
2970  prfs_flags |= PRFS_STOPEXEC;
2971 
2972  if (ioctl (pi->ctl_fd, PIOCSSPCACT, &prfs_flags) < 0)
2973  return __LINE__;
2974  }
2975 #else /* not PRFS_STOPEXEC */
2976  /* Everyone else's (except OSF) method for tracing exec syscalls. */
2977  /* GW: Rationale...
2978  Not all systems with /proc have all the exec* syscalls with the same
2979  names. On the SGI, for example, there is no SYS_exec, but there
2980  *is* a SYS_execv. So, we try to account for that. */
2981 
2982  traced_syscall_exits = sysset_t_alloc (pi);
2983  gdb_premptysysset (traced_syscall_exits);
2984 #ifdef SYS_exec
2985  gdb_praddsysset (traced_syscall_exits, SYS_exec);
2986 #endif
2987 #ifdef SYS_execve
2988  gdb_praddsysset (traced_syscall_exits, SYS_execve);
2989 #endif
2990 #ifdef SYS_execv
2991  gdb_praddsysset (traced_syscall_exits, SYS_execv);
2992 #endif
2993 
2994 #ifdef SYS_lwpcreate
2995  gdb_praddsysset (traced_syscall_exits, SYS_lwpcreate);
2996  gdb_praddsysset (traced_syscall_exits, SYS_lwpexit);
2997 #endif
2998 
2999 #ifdef SYS_lwp_create /* FIXME: once only, please. */
3000  gdb_praddsysset (traced_syscall_exits, SYS_lwp_create);
3001  gdb_praddsysset (traced_syscall_exits, SYS_lwp_exit);
3002 #endif
3003 
3004 #ifdef DYNAMIC_SYSCALLS
3005  {
3006  int callnum = find_syscall (pi, "execve");
3007 
3008  if (callnum >= 0)
3009  gdb_praddsysset (traced_syscall_exits, callnum);
3010  callnum = find_syscall (pi, "ra_execve");
3011  if (callnum >= 0)
3012  gdb_praddsysset (traced_syscall_exits, callnum);
3013  }
3014 #endif
3015 
3016  status = proc_set_traced_sysexit (pi, traced_syscall_exits);
3017  xfree (traced_syscall_exits);
3018  if (!status)
3019  return __LINE__;
3020 
3021 #endif /* PRFS_STOPEXEC */
3022  return 0;
3023 }
3024 
3025 static void
3026 procfs_attach (struct target_ops *ops, const char *args, int from_tty)
3027 {
3028  char *exec_file;
3029  int pid;
3030 
3031  pid = parse_pid_to_attach (args);
3032 
3033  if (pid == getpid ())
3034  error (_("Attaching GDB to itself is not a good idea..."));
3035 
3036  if (from_tty)
3037  {
3038  exec_file = get_exec_file (0);
3039 
3040  if (exec_file)
3041  printf_filtered (_("Attaching to program `%s', %s\n"),
3042  exec_file, target_pid_to_str (pid_to_ptid (pid)));
3043  else
3044  printf_filtered (_("Attaching to %s\n"),
3045  target_pid_to_str (pid_to_ptid (pid)));
3046 
3047  fflush (stdout);
3048  }
3050  if (!target_is_pushed (ops))
3051  push_target (ops);
3052 }
3053 
3054 static void
3055 procfs_detach (struct target_ops *ops, const char *args, int from_tty)
3056 {
3057  int sig = 0;
3058  int pid = ptid_get_pid (inferior_ptid);
3059 
3060  if (args)
3061  sig = atoi (args);
3062 
3063  if (from_tty)
3064  {
3065  char *exec_file;
3066 
3067  exec_file = get_exec_file (0);
3068  if (exec_file == NULL)
3069  exec_file = "";
3070 
3071  printf_filtered (_("Detaching from program: %s, %s\n"), exec_file,
3072  target_pid_to_str (pid_to_ptid (pid)));
3074  }
3075 
3076  do_detach (sig);
3077 
3079  detach_inferior (pid);
3081 }
3082 
3083 static ptid_t
3085 {
3086  procinfo *pi;
3087  struct inferior *inf;
3088  int fail;
3089  int lwpid;
3090 
3091  if ((pi = create_procinfo (ptid_get_pid (ptid), 0)) == NULL)
3092  perror (_("procfs: out of memory in 'attach'"));
3093 
3094  if (!open_procinfo_files (pi, FD_CTL))
3095  {
3096  fprintf_filtered (gdb_stderr, "procfs:%d -- ", __LINE__);
3097  sprintf (errmsg, "do_attach: couldn't open /proc file for process %d",
3098  ptid_get_pid (ptid));
3099  dead_procinfo (pi, errmsg, NOKILL);
3100  }
3101 
3102  /* Stop the process (if it isn't already stopped). */
3103  if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
3104  {
3105  pi->was_stopped = 1;
3106  proc_prettyprint_why (proc_why (pi), proc_what (pi), 1);
3107  }
3108  else
3109  {
3110  pi->was_stopped = 0;
3111  /* Set the process to run again when we close it. */
3112  if (!proc_set_run_on_last_close (pi))
3113  dead_procinfo (pi, "do_attach: couldn't set RLC.", NOKILL);
3114 
3115  /* Now stop the process. */
3116  if (!proc_stop_process (pi))
3117  dead_procinfo (pi, "do_attach: couldn't stop the process.", NOKILL);
3118  pi->ignore_next_sigstop = 1;
3119  }
3120  /* Save some of the /proc state to be restored if we detach. */
3121  if (!proc_get_traced_faults (pi, &pi->saved_fltset))
3122  dead_procinfo (pi, "do_attach: couldn't save traced faults.", NOKILL);
3123  if (!proc_get_traced_signals (pi, &pi->saved_sigset))
3124  dead_procinfo (pi, "do_attach: couldn't save traced signals.", NOKILL);
3126  dead_procinfo (pi, "do_attach: couldn't save traced syscall entries.",
3127  NOKILL);
3128  if (!proc_get_traced_sysexit (pi, pi->saved_exitset))
3129  dead_procinfo (pi, "do_attach: couldn't save traced syscall exits.",
3130  NOKILL);
3131  if (!proc_get_held_signals (pi, &pi->saved_sighold))
3132  dead_procinfo (pi, "do_attach: couldn't save held signals.", NOKILL);
3133 
3134  if ((fail = procfs_debug_inferior (pi)) != 0)
3135  dead_procinfo (pi, "do_attach: failed in procfs_debug_inferior", NOKILL);
3136 
3137  inf = current_inferior ();
3138  inferior_appeared (inf, pi->pid);
3139  /* Let GDB know that the inferior was attached. */
3140  inf->attach_flag = 1;
3141 
3142  /* Create a procinfo for the current lwp. */
3143  lwpid = proc_get_current_thread (pi);
3144  create_procinfo (pi->pid, lwpid);
3145 
3146  /* Add it to gdb's thread list. */
3147  ptid = ptid_build (pi->pid, lwpid, 0);
3148  add_thread (ptid);
3149 
3150  return ptid;
3151 }
3152 
3153 static void
3154 do_detach (int signo)
3155 {
3156  procinfo *pi;
3157 
3158  /* Find procinfo for the main process. */
3160  0); /* FIXME: threads */
3161  if (signo)
3162  if (!proc_set_current_signal (pi, signo))
3163  proc_warn (pi, "do_detach, set_current_signal", __LINE__);
3164 
3165  if (!proc_set_traced_signals (pi, &pi->saved_sigset))
3166  proc_warn (pi, "do_detach, set_traced_signal", __LINE__);
3167 
3168  if (!proc_set_traced_faults (pi, &pi->saved_fltset))
3169  proc_warn (pi, "do_detach, set_traced_faults", __LINE__);
3170 
3172  proc_warn (pi, "do_detach, set_traced_sysentry", __LINE__);
3173 
3174  if (!proc_set_traced_sysexit (pi, pi->saved_exitset))
3175  proc_warn (pi, "do_detach, set_traced_sysexit", __LINE__);
3176 
3177  if (!proc_set_held_signals (pi, &pi->saved_sighold))
3178  proc_warn (pi, "do_detach, set_held_signals", __LINE__);
3179 
3180  if (signo || (proc_flags (pi) & (PR_STOPPED | PR_ISTOP)))
3181  if (signo || !(pi->was_stopped) ||
3182  query (_("Was stopped when attached, make it runnable again? ")))
3183  {
3184  /* Clear any pending signal. */
3185  if (!proc_clear_current_fault (pi))
3186  proc_warn (pi, "do_detach, clear_current_fault", __LINE__);
3187 
3188  if (signo == 0 && !proc_clear_current_signal (pi))
3189  proc_warn (pi, "do_detach, clear_current_signal", __LINE__);
3190 
3191  if (!proc_set_run_on_last_close (pi))
3192  proc_warn (pi, "do_detach, set_rlc", __LINE__);
3193  }
3194 
3195  destroy_procinfo (pi);
3196 }
3197 
3198 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
3199  for all registers.
3200 
3201  ??? Is the following note still relevant? We can't get individual
3202  registers with the PT_GETREGS ptrace(2) request either, yet we
3203  don't bother with caching at all in that case.
3204 
3205  NOTE: Since the /proc interface cannot give us individual
3206  registers, we pay no attention to REGNUM, and just fetch them all.
3207  This results in the possibility that we will do unnecessarily many
3208  fetches, since we may be called repeatedly for individual
3209  registers. So we cache the results, and mark the cache invalid
3210  when the process is resumed. */
3211 
3212 static void
3214  struct regcache *regcache, int regnum)
3215 {
3216  gdb_gregset_t *gregs;
3217  procinfo *pi;
3218  int pid = ptid_get_pid (inferior_ptid);
3219  int tid = ptid_get_lwp (inferior_ptid);
3220  struct gdbarch *gdbarch = get_regcache_arch (regcache);
3221 
3222  pi = find_procinfo_or_die (pid, tid);
3223 
3224  if (pi == NULL)
3225  error (_("procfs: fetch_registers failed to find procinfo for %s"),
3227 
3228  gregs = proc_get_gregs (pi);
3229  if (gregs == NULL)
3230  proc_error (pi, "fetch_registers, get_gregs", __LINE__);
3231 
3232  supply_gregset (regcache, (const gdb_gregset_t *) gregs);
3233 
3234  if (gdbarch_fp0_regnum (gdbarch) >= 0) /* Do we have an FPU? */
3235  {
3236  gdb_fpregset_t *fpregs;
3237 
3238  if ((regnum >= 0 && regnum < gdbarch_fp0_regnum (gdbarch))
3239  || regnum == gdbarch_pc_regnum (gdbarch)
3240  || regnum == gdbarch_sp_regnum (gdbarch))
3241  return; /* Not a floating point register. */
3242 
3243  fpregs = proc_get_fpregs (pi);
3244  if (fpregs == NULL)
3245  proc_error (pi, "fetch_registers, get_fpregs", __LINE__);
3246 
3247  supply_fpregset (regcache, (const gdb_fpregset_t *) fpregs);
3248  }
3249 }
3250 
3251 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
3252  this for all registers.
3253 
3254  NOTE: Since the /proc interface will not read individual registers,
3255  we will cache these requests until the process is resumed, and only
3256  then write them back to the inferior process.
3257 
3258  FIXME: is that a really bad idea? Have to think about cases where
3259  writing one register might affect the value of others, etc. */
3260 
3261 static void
3263  struct regcache *regcache, int regnum)
3264 {
3265  gdb_gregset_t *gregs;
3266  procinfo *pi;
3267  int pid = ptid_get_pid (inferior_ptid);
3268  int tid = ptid_get_lwp (inferior_ptid);
3269  struct gdbarch *gdbarch = get_regcache_arch (regcache);
3270 
3271  pi = find_procinfo_or_die (pid, tid);
3272 
3273  if (pi == NULL)
3274  error (_("procfs: store_registers: failed to find procinfo for %s"),
3276 
3277  gregs = proc_get_gregs (pi);
3278  if (gregs == NULL)
3279  proc_error (pi, "store_registers, get_gregs", __LINE__);
3280 
3281  fill_gregset (regcache, gregs, regnum);
3282  if (!proc_set_gregs (pi))
3283  proc_error (pi, "store_registers, set_gregs", __LINE__);
3284 
3285  if (gdbarch_fp0_regnum (gdbarch) >= 0) /* Do we have an FPU? */
3286  {
3287  gdb_fpregset_t *fpregs;
3288 
3289  if ((regnum >= 0 && regnum < gdbarch_fp0_regnum (gdbarch))
3290  || regnum == gdbarch_pc_regnum (gdbarch)
3291  || regnum == gdbarch_sp_regnum (gdbarch))
3292  return; /* Not a floating point register. */
3293 
3294  fpregs = proc_get_fpregs (pi);
3295  if (fpregs == NULL)
3296  proc_error (pi, "store_registers, get_fpregs", __LINE__);
3297 
3298  fill_fpregset (regcache, fpregs, regnum);
3299  if (!proc_set_fpregs (pi))
3300  proc_error (pi, "store_registers, set_fpregs", __LINE__);
3301  }
3302 }
3303 
3304 static int
3306 {
3307 #ifdef SYS_lwp_exit
3308  if (scall == SYS_lwp_exit)
3309  return 1;
3310 #endif
3311 #ifdef SYS_lwpexit
3312  if (scall == SYS_lwpexit)
3313  return 1;
3314 #endif
3315  return 0;
3316 }
3317 
3318 static int
3319 syscall_is_exit (procinfo *pi, int scall)
3320 {
3321 #ifdef SYS_exit
3322  if (scall == SYS_exit)
3323  return 1;
3324 #endif
3325 #ifdef DYNAMIC_SYSCALLS
3326  if (find_syscall (pi, "_exit") == scall)
3327  return 1;
3328 #endif
3329  return 0;
3330 }
3331 
3332 static int
3333 syscall_is_exec (procinfo *pi, int scall)
3334 {
3335 #ifdef SYS_exec
3336  if (scall == SYS_exec)
3337  return 1;
3338 #endif
3339 #ifdef SYS_execv
3340  if (scall == SYS_execv)
3341  return 1;
3342 #endif
3343 #ifdef SYS_execve
3344  if (scall == SYS_execve)
3345  return 1;
3346 #endif
3347 #ifdef DYNAMIC_SYSCALLS
3348  if (find_syscall (pi, "_execve"))
3349  return 1;
3350  if (find_syscall (pi, "ra_execve"))
3351  return 1;
3352 #endif
3353  return 0;
3354 }
3355 
3356 static int
3358 {
3359 #ifdef SYS_lwp_create
3360  if (scall == SYS_lwp_create)
3361  return 1;
3362 #endif
3363 #ifdef SYS_lwpcreate
3364  if (scall == SYS_lwpcreate)
3365  return 1;
3366 #endif
3367  return 0;
3368 }
3369 
3370 #ifdef SYS_syssgi
3371 /* Return the address of the __dbx_link() function in the file
3372  refernced by ABFD by scanning its symbol table. Return 0 if
3373  the symbol was not found. */
3374 
3375 static CORE_ADDR
3376 dbx_link_addr (bfd *abfd)
3377 {
3378  long storage_needed;
3379  asymbol **symbol_table;
3380  long number_of_symbols;
3381  long i;
3382 
3383  storage_needed = bfd_get_symtab_upper_bound (abfd);
3384  if (storage_needed <= 0)
3385  return 0;
3386 
3387  symbol_table = (asymbol **) xmalloc (storage_needed);
3388  make_cleanup (xfree, symbol_table);
3389 
3390  number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
3391 
3392  for (i = 0; i < number_of_symbols; i++)
3393  {
3394  asymbol *sym = symbol_table[i];
3395 
3396  if ((sym->flags & BSF_GLOBAL)
3397  && sym->name != NULL && strcmp (sym->name, "__dbx_link") == 0)
3398  return (sym->value + sym->section->vma);
3399  }
3400 
3401  /* Symbol not found, return NULL. */
3402  return 0;
3403 }
3404 
3405 /* Search the symbol table of the file referenced by FD for a symbol
3406  named __dbx_link(). If found, then insert a breakpoint at this location,
3407  and return nonzero. Return zero otherwise. */
3408 
3409 static int
3410 insert_dbx_link_bpt_in_file (int fd, CORE_ADDR ignored)
3411 {
3412  bfd *abfd;
3413  long storage_needed;
3414  CORE_ADDR sym_addr;
3415 
3416  abfd = gdb_bfd_fdopenr ("unamed", 0, fd);
3417  if (abfd == NULL)
3418  {
3419  warning (_("Failed to create a bfd: %s."), bfd_errmsg (bfd_get_error ()));
3420  return 0;
3421  }
3422 
3423  if (!bfd_check_format (abfd, bfd_object))
3424  {
3425  /* Not the correct format, so we can not possibly find the dbx_link
3426  symbol in it. */
3427  gdb_bfd_unref (abfd);
3428  return 0;
3429  }
3430 
3431  sym_addr = dbx_link_addr (abfd);
3432  if (sym_addr != 0)
3433  {
3434  struct breakpoint *dbx_link_bpt;
3435 
3436  /* Insert the breakpoint. */
3437  dbx_link_bpt
3439  sym_addr);
3440  if (dbx_link_bpt == NULL)
3441  {
3442  warning (_("Failed to insert dbx_link breakpoint."));
3443  gdb_bfd_unref (abfd);
3444  return 0;
3445  }
3446  gdb_bfd_unref (abfd);
3447  return 1;
3448  }
3449 
3450  gdb_bfd_unref (abfd);
3451  return 0;
3452 }
3453 
3454 /* Calls the supplied callback function once for each mapped address
3455  space in the process. The callback function receives an open file
3456  descriptor for the file corresponding to that mapped address space
3457  (if there is one), and the base address of the mapped space. Quit
3458  when the callback function returns a nonzero value, or at teh end
3459  of the mappings. Returns the first non-zero return value of the
3460  callback function, or zero. */
3461 
3462 static int
3463 solib_mappings_callback (struct prmap *map, int (*func) (int, CORE_ADDR),
3464  void *data)
3465 {
3466  procinfo *pi = data;
3467  int fd;
3468 
3469 #ifdef NEW_PROC_API
3470  char name[MAX_PROC_NAME_SIZE + sizeof (map->pr_mapname)];
3471 
3472  if (map->pr_vaddr == 0 && map->pr_size == 0)
3473  return -1; /* sanity */
3474 
3475  if (map->pr_mapname[0] == 0)
3476  {
3477  fd = -1; /* no map file */
3478  }
3479  else
3480  {
3481  sprintf (name, "/proc/%d/object/%s", pi->pid, map->pr_mapname);
3482  /* Note: caller's responsibility to close this fd! */
3483  fd = open_with_retry (name, O_RDONLY);
3484  /* Note: we don't test the above call for failure;
3485  we just pass the FD on as given. Sometimes there is
3486  no file, so the open may return failure, but that's
3487  not a problem. */
3488  }
3489 #else
3490  fd = ioctl (pi->ctl_fd, PIOCOPENM, &map->pr_vaddr);
3491  /* Note: we don't test the above call for failure;
3492  we just pass the FD on as given. Sometimes there is
3493  no file, so the ioctl may return failure, but that's
3494  not a problem. */
3495 #endif
3496  return (*func) (fd, (CORE_ADDR) map->pr_vaddr);
3497 }
3498 
3499 /* If the given memory region MAP contains a symbol named __dbx_link,
3500  insert a breakpoint at this location and return nonzero. Return
3501  zero otherwise. */
3502 
3503 static int
3504 insert_dbx_link_bpt_in_region (struct prmap *map,
3505  find_memory_region_ftype child_func,
3506  void *data)
3507 {
3508  procinfo *pi = (procinfo *) data;
3509 
3510  /* We know the symbol we're looking for is in a text region, so
3511  only look for it if the region is a text one. */
3512  if (map->pr_mflags & MA_EXEC)
3513  return solib_mappings_callback (map, insert_dbx_link_bpt_in_file, pi);
3514 
3515  return 0;
3516 }
3517 
3518 /* Search all memory regions for a symbol named __dbx_link. If found,
3519  insert a breakpoint at its location, and return nonzero. Return zero
3520  otherwise. */
3521 
3522 static int
3523 insert_dbx_link_breakpoint (procinfo *pi)
3524 {
3525  return iterate_over_mappings (pi, NULL, pi, insert_dbx_link_bpt_in_region);
3526 }
3527 #endif
3528 
3529 /* Retrieve the next stop event from the child process. If child has
3530  not stopped yet, wait for it to stop. Translate /proc eventcodes
3531  (or possibly wait eventcodes) into gdb internal event codes.
3532  Returns the id of process (and possibly thread) that incurred the
3533  event. Event codes are returned through a pointer parameter. */
3534 
3535 static ptid_t
3537  ptid_t ptid, struct target_waitstatus *status, int options)
3538 {
3539  /* First cut: loosely based on original version 2.1. */
3540  procinfo *pi;
3541  int wstat;
3542  int temp_tid;
3543  ptid_t retval, temp_ptid;
3544  int why, what, flags;
3545  int retry = 0;
3546 
3547 wait_again:
3548 
3549  retry++;
3550  wstat = 0;
3551  retval = pid_to_ptid (-1);
3552 
3553  /* Find procinfo for main process. */
3555  if (pi)
3556  {
3557  /* We must assume that the status is stale now... */
3558  pi->status_valid = 0;
3559  pi->gregs_valid = 0;
3560  pi->fpregs_valid = 0;
3561 
3562 #if 0 /* just try this out... */
3563  flags = proc_flags (pi);
3564  why = proc_why (pi);
3565  if ((flags & PR_STOPPED) && (why == PR_REQUESTED))
3566  pi->status_valid = 0; /* re-read again, IMMEDIATELY... */
3567 #endif
3568  /* If child is not stopped, wait for it to stop. */
3569  if (!(proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) &&
3570  !proc_wait_for_stop (pi))
3571  {
3572  /* wait_for_stop failed: has the child terminated? */
3573  if (errno == ENOENT)
3574  {
3575  int wait_retval;
3576 
3577  /* /proc file not found; presumably child has terminated. */
3578  wait_retval = wait (&wstat); /* "wait" for the child's exit. */
3579 
3580  /* Wrong child? */
3581  if (wait_retval != ptid_get_pid (inferior_ptid))
3582  error (_("procfs: couldn't stop "
3583  "process %d: wait returned %d."),
3584  ptid_get_pid (inferior_ptid), wait_retval);
3585  /* FIXME: might I not just use waitpid?
3586  Or try find_procinfo to see if I know about this child? */
3587  retval = pid_to_ptid (wait_retval);
3588  }
3589  else if (errno == EINTR)
3590  goto wait_again;
3591  else
3592  {
3593  /* Unknown error from wait_for_stop. */
3594  proc_error (pi, "target_wait (wait_for_stop)", __LINE__);
3595  }
3596  }
3597  else
3598  {
3599  /* This long block is reached if either:
3600  a) the child was already stopped, or
3601  b) we successfully waited for the child with wait_for_stop.
3602  This block will analyze the /proc status, and translate it
3603  into a waitstatus for GDB.
3604 
3605  If we actually had to call wait because the /proc file
3606  is gone (child terminated), then we skip this block,
3607  because we already have a waitstatus. */
3608 
3609  flags = proc_flags (pi);
3610  why = proc_why (pi);
3611  what = proc_what (pi);
3612 
3613  if (flags & (PR_STOPPED | PR_ISTOP))
3614  {
3615 #ifdef PR_ASYNC
3616  /* If it's running async (for single_thread control),
3617  set it back to normal again. */
3618  if (flags & PR_ASYNC)
3619  if (!proc_unset_async (pi))
3620  proc_error (pi, "target_wait, unset_async", __LINE__);
3621 #endif
3622 
3623  if (info_verbose)
3624  proc_prettyprint_why (why, what, 1);
3625 
3626  /* The 'pid' we will return to GDB is composed of
3627  the process ID plus the lwp ID. */
3628  retval = ptid_build (pi->pid, proc_get_current_thread (pi), 0);
3629 
3630  switch (why) {
3631  case PR_SIGNALLED:
3632  wstat = (what << 8) | 0177;
3633  break;
3634  case PR_SYSENTRY:
3635  if (syscall_is_lwp_exit (pi, what))
3636  {
3637  if (print_thread_events)
3638  printf_unfiltered (_("[%s exited]\n"),
3639  target_pid_to_str (retval));
3640  delete_thread (retval);
3641  status->kind = TARGET_WAITKIND_SPURIOUS;
3642  return retval;
3643  }
3644  else if (syscall_is_exit (pi, what))
3645  {
3646  struct inferior *inf;
3647 
3648  /* Handle SYS_exit call only. */
3649  /* Stopped at entry to SYS_exit.
3650  Make it runnable, resume it, then use
3651  the wait system call to get its exit code.
3652  Proc_run_process always clears the current
3653  fault and signal.
3654  Then return its exit status. */
3655  pi->status_valid = 0;
3656  wstat = 0;
3657  /* FIXME: what we should do is return
3658  TARGET_WAITKIND_SPURIOUS. */
3659  if (!proc_run_process (pi, 0, 0))
3660  proc_error (pi, "target_wait, run_process", __LINE__);
3661 
3662  inf = find_inferior_pid (pi->pid);
3663  if (inf->attach_flag)
3664  {
3665  /* Don't call wait: simulate waiting for exit,
3666  return a "success" exit code. Bogus: what if
3667  it returns something else? */
3668  wstat = 0;
3669  retval = inferior_ptid; /* ? ? ? */
3670  }
3671  else
3672  {
3673  int temp = wait (&wstat);
3674 
3675  /* FIXME: shouldn't I make sure I get the right
3676  event from the right process? If (for
3677  instance) I have killed an earlier inferior
3678  process but failed to clean up after it
3679  somehow, I could get its termination event
3680  here. */
3681 
3682  /* If wait returns -1, that's what we return
3683  to GDB. */
3684  if (temp < 0)
3685  retval = pid_to_ptid (temp);
3686  }
3687  }
3688  else
3689  {
3690  printf_filtered (_("procfs: trapped on entry to "));
3692  printf_filtered ("\n");
3693 #ifndef PIOCSSPCACT
3694  {
3695  long i, nsysargs, *sysargs;
3696 
3697  if ((nsysargs = proc_nsysarg (pi)) > 0 &&
3698  (sysargs = proc_sysargs (pi)) != NULL)
3699  {
3700  printf_filtered (_("%ld syscall arguments:\n"),
3701  nsysargs);
3702  for (i = 0; i < nsysargs; i++)
3703  printf_filtered ("#%ld: 0x%08lx\n",
3704  i, sysargs[i]);
3705  }
3706 
3707  }
3708 #endif
3709  if (status)
3710  {
3711  /* How to exit gracefully, returning "unknown
3712  event". */
3713  status->kind = TARGET_WAITKIND_SPURIOUS;
3714  return inferior_ptid;
3715  }
3716  else
3717  {
3718  /* How to keep going without returning to wfi: */
3719  target_resume (ptid, 0, GDB_SIGNAL_0);
3720  goto wait_again;
3721  }
3722  }
3723  break;
3724  case PR_SYSEXIT:
3725  if (syscall_is_exec (pi, what))
3726  {
3727  /* Hopefully this is our own "fork-child" execing
3728  the real child. Hoax this event into a trap, and
3729  GDB will see the child about to execute its start
3730  address. */
3731  wstat = (SIGTRAP << 8) | 0177;
3732  }
3733 #ifdef SYS_syssgi
3734  else if (what == SYS_syssgi)
3735  {
3736  /* see if we can break on dbx_link(). If yes, then
3737  we no longer need the SYS_syssgi notifications. */
3738  if (insert_dbx_link_breakpoint (pi))
3739  proc_trace_syscalls_1 (pi, SYS_syssgi, PR_SYSEXIT,
3740  FLAG_RESET, 0);
3741 
3742  /* This is an internal event and should be transparent
3743  to wfi, so resume the execution and wait again. See
3744  comment in procfs_init_inferior() for more details. */
3745  target_resume (ptid, 0, GDB_SIGNAL_0);
3746  goto wait_again;
3747  }
3748 #endif
3749  else if (syscall_is_lwp_create (pi, what))
3750  {
3751  /* This syscall is somewhat like fork/exec. We
3752  will get the event twice: once for the parent
3753  LWP, and once for the child. We should already
3754  know about the parent LWP, but the child will
3755  be new to us. So, whenever we get this event,
3756  if it represents a new thread, simply add the
3757  thread to the list. */
3758 
3759  /* If not in procinfo list, add it. */
3760  temp_tid = proc_get_current_thread (pi);
3761  if (!find_procinfo (pi->pid, temp_tid))
3762  create_procinfo (pi->pid, temp_tid);
3763 
3764  temp_ptid = ptid_build (pi->pid, temp_tid, 0);
3765  /* If not in GDB's thread list, add it. */
3766  if (!in_thread_list (temp_ptid))
3767  add_thread (temp_ptid);
3768 
3769  /* Return to WFI, but tell it to immediately resume. */
3770  status->kind = TARGET_WAITKIND_SPURIOUS;
3771  return inferior_ptid;
3772  }
3773  else if (syscall_is_lwp_exit (pi, what))
3774  {
3775  if (print_thread_events)
3776  printf_unfiltered (_("[%s exited]\n"),
3777  target_pid_to_str (retval));
3778  delete_thread (retval);
3779  status->kind = TARGET_WAITKIND_SPURIOUS;
3780  return retval;
3781  }
3782  else if (0)
3783  {
3784  /* FIXME: Do we need to handle SYS_sproc,
3785  SYS_fork, or SYS_vfork here? The old procfs
3786  seemed to use this event to handle threads on
3787  older (non-LWP) systems, where I'm assuming
3788  that threads were actually separate processes.
3789  Irix, maybe? Anyway, low priority for now. */
3790  }
3791  else
3792  {
3793  printf_filtered (_("procfs: trapped on exit from "));
3795  printf_filtered ("\n");
3796 #ifndef PIOCSSPCACT
3797  {
3798  long i, nsysargs, *sysargs;
3799 
3800  if ((nsysargs = proc_nsysarg (pi)) > 0 &&
3801  (sysargs = proc_sysargs (pi)) != NULL)
3802  {
3803  printf_filtered (_("%ld syscall arguments:\n"),
3804  nsysargs);
3805  for (i = 0; i < nsysargs; i++)
3806  printf_filtered ("#%ld: 0x%08lx\n",
3807  i, sysargs[i]);
3808  }
3809  }
3810 #endif
3811  status->kind = TARGET_WAITKIND_SPURIOUS;
3812  return inferior_ptid;
3813  }
3814  break;
3815  case PR_REQUESTED:
3816 #if 0 /* FIXME */
3817  wstat = (SIGSTOP << 8) | 0177;
3818  break;
3819 #else
3820  if (retry < 5)
3821  {
3822  printf_filtered (_("Retry #%d:\n"), retry);
3823  pi->status_valid = 0;
3824  goto wait_again;
3825  }
3826  else
3827  {
3828  /* If not in procinfo list, add it. */
3829  temp_tid = proc_get_current_thread (pi);
3830  if (!find_procinfo (pi->pid, temp_tid))
3831  create_procinfo (pi->pid, temp_tid);
3832 
3833  /* If not in GDB's thread list, add it. */
3834  temp_ptid = ptid_build (pi->pid, temp_tid, 0);
3835  if (!in_thread_list (temp_ptid))
3836  add_thread (temp_ptid);
3837 
3838  status->kind = TARGET_WAITKIND_STOPPED;
3839  status->value.sig = 0;
3840  return retval;
3841  }
3842 #endif
3843  case PR_JOBCONTROL:
3844  wstat = (what << 8) | 0177;
3845  break;
3846  case PR_FAULTED:
3847  switch (what) {
3848 #ifdef FLTWATCH
3849  case FLTWATCH:
3850  wstat = (SIGTRAP << 8) | 0177;
3851  break;
3852 #endif
3853 #ifdef FLTKWATCH
3854  case FLTKWATCH:
3855  wstat = (SIGTRAP << 8) | 0177;
3856  break;
3857 #endif
3858  /* FIXME: use si_signo where possible. */
3859  case FLTPRIV:
3860 #if (FLTILL != FLTPRIV) /* Avoid "duplicate case" error. */
3861  case FLTILL:
3862 #endif
3863  wstat = (SIGILL << 8) | 0177;
3864  break;
3865  case FLTBPT:
3866 #if (FLTTRACE != FLTBPT) /* Avoid "duplicate case" error. */
3867  case FLTTRACE:
3868 #endif
3869  wstat = (SIGTRAP << 8) | 0177;
3870  break;
3871  case FLTSTACK:
3872  case FLTACCESS:
3873 #if (FLTBOUNDS != FLTSTACK) /* Avoid "duplicate case" error. */
3874  case FLTBOUNDS:
3875 #endif
3876  wstat = (SIGSEGV << 8) | 0177;
3877  break;
3878  case FLTIOVF:
3879  case FLTIZDIV:
3880 #if (FLTFPE != FLTIOVF) /* Avoid "duplicate case" error. */
3881  case FLTFPE:
3882 #endif
3883  wstat = (SIGFPE << 8) | 0177;
3884  break;
3885  case FLTPAGE: /* Recoverable page fault */
3886  default: /* FIXME: use si_signo if possible for
3887  fault. */
3888  retval = pid_to_ptid (-1);
3889  printf_filtered ("procfs:%d -- ", __LINE__);
3890  printf_filtered (_("child stopped for unknown reason:\n"));
3891  proc_prettyprint_why (why, what, 1);
3892  error (_("... giving up..."));
3893  break;
3894  }
3895  break; /* case PR_FAULTED: */
3896  default: /* switch (why) unmatched */
3897  printf_filtered ("procfs:%d -- ", __LINE__);
3898  printf_filtered (_("child stopped for unknown reason:\n"));
3899  proc_prettyprint_why (why, what, 1);
3900  error (_("... giving up..."));
3901  break;
3902  }
3903  /* Got this far without error: If retval isn't in the
3904  threads database, add it. */
3905  if (ptid_get_pid (retval) > 0 &&
3906  !ptid_equal (retval, inferior_ptid) &&
3907  !in_thread_list (retval))
3908  {
3909  /* We have a new thread. We need to add it both to
3910  GDB's list and to our own. If we don't create a
3911  procinfo, resume may be unhappy later. */
3912  add_thread (retval);
3913  if (find_procinfo (ptid_get_pid (retval),
3914  ptid_get_lwp (retval)) == NULL)
3915  create_procinfo (ptid_get_pid (retval),
3916  ptid_get_lwp (retval));
3917  }
3918  }
3919  else /* Flags do not indicate STOPPED. */
3920  {
3921  /* surely this can't happen... */
3922  printf_filtered ("procfs:%d -- process not stopped.\n",
3923  __LINE__);
3924  proc_prettyprint_flags (flags, 1);
3925  error (_("procfs: ...giving up..."));
3926  }
3927  }
3928 
3929  if (status)
3930  store_waitstatus (status, wstat);
3931  }
3932 
3933  return retval;
3934 }
3935 
3936 /* Perform a partial transfer to/from the specified object. For
3937  memory transfers, fall back to the old memory xfer functions. */
3938 
3939 static enum target_xfer_status
3941  const char *annex, gdb_byte *readbuf,
3942  const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
3943  ULONGEST *xfered_len)
3944 {
3945  switch (object)
3946  {
3947  case TARGET_OBJECT_MEMORY:
3948  return procfs_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
3949 
3950 #ifdef NEW_PROC_API
3951  case TARGET_OBJECT_AUXV:
3952  return memory_xfer_auxv (ops, object, annex, readbuf, writebuf,
3953  offset, len, xfered_len);
3954 #endif
3955 
3956  default:
3957  return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
3958  readbuf, writebuf, offset, len,
3959  xfered_len);
3960  }
3961 }
3962 
3963 /* Helper for procfs_xfer_partial that handles memory transfers.
3964  Arguments are like target_xfer_partial. */
3965 
3966 static enum target_xfer_status
3967 procfs_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
3968  ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
3969 {
3970  procinfo *pi;
3971  int nbytes;
3972 
3973  /* Find procinfo for main process. */
3975  if (pi->as_fd == 0 &&
3976  open_procinfo_files (pi, FD_AS) == 0)
3977  {
3978  proc_warn (pi, "xfer_memory, open_proc_files", __LINE__);
3979  return TARGET_XFER_E_IO;
3980  }
3981 
3982  if (lseek (pi->as_fd, (off_t) memaddr, SEEK_SET) != (off_t) memaddr)
3983  return TARGET_XFER_E_IO;
3984 
3985  if (writebuf != NULL)
3986  {
3987  PROCFS_NOTE ("write memory:\n");
3988  nbytes = write (pi->as_fd, writebuf, len);
3989  }
3990  else
3991  {
3992  PROCFS_NOTE ("read memory:\n");
3993  nbytes = read (pi->as_fd, readbuf, len);
3994  }
3995  if (nbytes <= 0)
3996  return TARGET_XFER_E_IO;
3997  *xfered_len = nbytes;
3998  return TARGET_XFER_OK;
3999 }
4000 
4001 /* Called by target_resume before making child runnable. Mark cached
4002  registers and status's invalid. If there are "dirty" caches that
4003  need to be written back to the child process, do that.
4004 
4005  File descriptors are also cached. As they are a limited resource,
4006  we cannot hold onto them indefinitely. However, as they are
4007  expensive to open, we don't want to throw them away
4008  indescriminately either. As a compromise, we will keep the file
4009  descriptors for the parent process, but discard any file
4010  descriptors we may have accumulated for the threads.
4011 
4012  As this function is called by iterate_over_threads, it always
4013  returns zero (so that iterate_over_threads will keep
4014  iterating). */
4015 
4016 static int
4017 invalidate_cache (procinfo *parent, procinfo *pi, void *ptr)
4018 {
4019  /* About to run the child; invalidate caches and do any other
4020  cleanup. */
4021 
4022 #if 0
4023  if (pi->gregs_dirty)
4024  if (parent == NULL ||
4025  proc_get_current_thread (parent) != pi->tid)
4026  if (!proc_set_gregs (pi)) /* flush gregs cache */
4027  proc_warn (pi, "target_resume, set_gregs",
4028  __LINE__);
4029  if (gdbarch_fp0_regnum (target_gdbarch ()) >= 0)
4030  if (pi->fpregs_dirty)
4031  if (parent == NULL ||
4032  proc_get_current_thread (parent) != pi->tid)
4033  if (!proc_set_fpregs (pi)) /* flush fpregs cache */
4034  proc_warn (pi, "target_resume, set_fpregs",
4035  __LINE__);
4036 #endif
4037 
4038  if (parent != NULL)
4039  {
4040  /* The presence of a parent indicates that this is an LWP.
4041  Close any file descriptors that it might have open.
4042  We don't do this to the master (parent) procinfo. */
4043 
4044  close_procinfo_files (pi);
4045  }
4046  pi->gregs_valid = 0;
4047  pi->fpregs_valid = 0;
4048 #if 0
4049  pi->gregs_dirty = 0;
4050  pi->fpregs_dirty = 0;
4051 #endif
4052  pi->status_valid = 0;
4053  pi->threads_valid = 0;
4054 
4055  return 0;
4056 }
4057 
4058 #if 0
4059 /* A callback function for iterate_over_threads. Find the
4060  asynchronous signal thread, and make it runnable. See if that
4061  helps matters any. */
4062 
4063 static int
4064 make_signal_thread_runnable (procinfo *process, procinfo *pi, void *ptr)
4065 {
4066 #ifdef PR_ASLWP
4067  if (proc_flags (pi) & PR_ASLWP)
4068  {
4069  if (!proc_run_process (pi, 0, -1))
4070  proc_error (pi, "make_signal_thread_runnable", __LINE__);
4071  return 1;
4072  }
4073 #endif
4074  return 0;
4075 }
4076 #endif
4077 
4078 /* Make the child process runnable. Normally we will then call
4079  procfs_wait and wait for it to stop again (unless gdb is async).
4080 
4081  If STEP is true, then arrange for the child to stop again after
4082  executing a single instruction. If SIGNO is zero, then cancel any
4083  pending signal; if non-zero, then arrange for the indicated signal
4084  to be delivered to the child when it runs. If PID is -1, then
4085  allow any child thread to run; if non-zero, then allow only the
4086  indicated thread to run. (not implemented yet). */
4087 
4088 static void
4090  ptid_t ptid, int step, enum gdb_signal signo)
4091 {
4092  procinfo *pi, *thread;
4093  int native_signo;
4094 
4095  /* 2.1:
4096  prrun.prflags |= PRSVADDR;
4097  prrun.pr_vaddr = $PC; set resume address
4098  prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
4099  prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
4100  prrun.prflags |= PRCFAULT; clear current fault.
4101 
4102  PRSTRACE and PRSFAULT can be done by other means
4103  (proc_trace_signals, proc_trace_faults)
4104  PRSVADDR is unnecessary.
4105  PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
4106  This basically leaves PRSTEP and PRCSIG.
4107  PRCSIG is like PIOCSSIG (proc_clear_current_signal).
4108  So basically PR_STEP is the sole argument that must be passed
4109  to proc_run_process (for use in the prrun struct by ioctl). */
4110 
4111  /* Find procinfo for main process. */
4113 
4114  /* First cut: ignore pid argument. */
4115  errno = 0;
4116 
4117  /* Convert signal to host numbering. */
4118  if (signo == 0 ||
4119  (signo == GDB_SIGNAL_STOP && pi->ignore_next_sigstop))
4120  native_signo = 0;
4121  else
4122  native_signo = gdb_signal_to_host (signo);
4123 
4124  pi->ignore_next_sigstop = 0;
4125 
4126  /* Running the process voids all cached registers and status. */
4127  /* Void the threads' caches first. */
4129  /* Void the process procinfo's caches. */
4130  invalidate_cache (NULL, pi, NULL);
4131 
4132  if (ptid_get_pid (ptid) != -1)
4133  {
4134  /* Resume a specific thread, presumably suppressing the
4135  others. */
4136  thread = find_procinfo (ptid_get_pid (ptid), ptid_get_lwp (ptid));
4137  if (thread != NULL)
4138  {
4139  if (thread->tid != 0)
4140  {
4141  /* We're to resume a specific thread, and not the
4142  others. Set the child process's PR_ASYNC flag. */
4143 #ifdef PR_ASYNC
4144  if (!proc_set_async (pi))
4145  proc_error (pi, "target_resume, set_async", __LINE__);
4146 #endif
4147 #if 0
4149  make_signal_thread_runnable,
4150  NULL);
4151 #endif
4152  pi = thread; /* Substitute the thread's procinfo
4153  for run. */
4154  }
4155  }
4156  }
4157 
4158  if (!proc_run_process (pi, step, native_signo))
4159  {
4160  if (errno == EBUSY)
4161  warning (_("resume: target already running. "
4162  "Pretend to resume, and hope for the best!"));
4163  else
4164  proc_error (pi, "target_resume", __LINE__);
4165  }
4166 }
4167 
4168 /* Set up to trace signals in the child process. */
4169 
4170 static void
4172  int numsigs, unsigned char *pass_signals)
4173 {
4174  gdb_sigset_t signals;
4176  int signo;
4177 
4178  prfillset (&signals);
4179 
4180  for (signo = 0; signo < NSIG; signo++)
4181  {
4182  int target_signo = gdb_signal_from_host (signo);
4183  if (target_signo < numsigs && pass_signals[target_signo])
4184  gdb_prdelset (&signals, signo);
4185  }
4186 
4187  if (!proc_set_traced_signals (pi, &signals))
4188  proc_error (pi, "pass_signals", __LINE__);
4189 }
4190 
4191 /* Print status information about the child process. */
4192 
4193 static void
4195 {
4196  struct inferior *inf = current_inferior ();
4197 
4198  printf_filtered (_("\tUsing the running image of %s %s via /proc.\n"),
4199  inf->attach_flag? "attached": "child",
4201 }
4202 
4203 /* Stop the child process asynchronously, as when the gdb user types
4204  control-c or presses a "stop" button. Works by sending
4205  kill(SIGINT) to the child's process group. */
4206 
4207 static void
4208 procfs_stop (struct target_ops *self, ptid_t ptid)
4209 {
4210  kill (-inferior_process_group (), SIGINT);
4211 }
4212 
4213 /* Make it die. Wait for it to die. Clean up after it. Note: this
4214  should only be applied to the real process, not to an LWP, because
4215  of the check for parent-process. If we need this to work for an
4216  LWP, it needs some more logic. */
4217 
4218 static void
4220 {
4221  int parent_pid;
4222 
4223  parent_pid = proc_parent_pid (pi);
4224 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
4225  /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
4226  to kill the inferior, otherwise it might remain stopped with a
4227  pending SIGKILL.
4228  We do not check the result of the PIOCSSIG, the inferior might have
4229  died already. */
4230  {
4231  gdb_siginfo_t newsiginfo;
4232 
4233  memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
4234  newsiginfo.si_signo = SIGKILL;
4235  newsiginfo.si_code = 0;
4236  newsiginfo.si_errno = 0;
4237  newsiginfo.si_pid = getpid ();
4238  newsiginfo.si_uid = getuid ();
4239  /* FIXME: use proc_set_current_signal. */
4240  ioctl (pi->ctl_fd, PIOCSSIG, &newsiginfo);
4241  }
4242 #else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4243  if (!proc_kill (pi, SIGKILL))
4244  proc_error (pi, "unconditionally_kill, proc_kill", __LINE__);
4245 #endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4246  destroy_procinfo (pi);
4247 
4248  /* If pi is GDB's child, wait for it to die. */
4249  if (parent_pid == getpid ())
4250  /* FIXME: should we use waitpid to make sure we get the right event?
4251  Should we check the returned event? */
4252  {
4253 #if 0
4254  int status, ret;
4255 
4256  ret = waitpid (pi->pid, &status, 0);
4257 #else
4258  wait (NULL);
4259 #endif
4260  }
4261 }
4262 
4263 /* We're done debugging it, and we want it to go away. Then we want
4264  GDB to forget all about it. */
4265 
4266 static void
4268 {
4269  if (!ptid_equal (inferior_ptid, null_ptid)) /* ? */
4270  {
4271  /* Find procinfo for main process. */
4273 
4274  if (pi)
4277  }
4278 }
4279 
4280 /* Forget we ever debugged this thing! */
4281 
4282 static void
4284 {
4285  procinfo *pi;
4286 
4288  {
4289  /* Find procinfo for main process. */
4291  if (pi)
4292  destroy_procinfo (pi);
4293  }
4294 
4296 
4298 }
4299 
4300 /* When GDB forks to create a runnable inferior process, this function
4301  is called on the parent side of the fork. It's job is to do
4302  whatever is necessary to make the child ready to be debugged, and
4303  then wait for the child to synchronize. */
4304 
4305 static void
4307 {
4308  procinfo *pi;
4309  gdb_sigset_t signals;
4310  int fail;
4311  int lwpid;
4312 
4313  /* This routine called on the parent side (GDB side)
4314  after GDB forks the inferior. */
4315  if (!target_is_pushed (ops))
4316  push_target (ops);
4317 
4318  if ((pi = create_procinfo (pid, 0)) == NULL)
4319  perror (_("procfs: out of memory in 'init_inferior'"));
4320 
4321  if (!open_procinfo_files (pi, FD_CTL))
4322  proc_error (pi, "init_inferior, open_proc_files", __LINE__);
4323 
4324  /*
4325  xmalloc // done
4326  open_procinfo_files // done
4327  link list // done
4328  prfillset (trace)
4329  procfs_notice_signals
4330  prfillset (fault)
4331  prdelset (FLTPAGE)
4332  PIOCWSTOP
4333  PIOCSFAULT
4334  */
4335 
4336  /* If not stopped yet, wait for it to stop. */
4337  if (!(proc_flags (pi) & PR_STOPPED) &&
4338  !(proc_wait_for_stop (pi)))
4339  dead_procinfo (pi, "init_inferior: wait_for_stop failed", KILL);
4340 
4341  /* Save some of the /proc state to be restored if we detach. */
4342  /* FIXME: Why? In case another debugger was debugging it?
4343  We're it's parent, for Ghu's sake! */
4344  if (!proc_get_traced_signals (pi, &pi->saved_sigset))
4345  proc_error (pi, "init_inferior, get_traced_signals", __LINE__);
4346  if (!proc_get_held_signals (pi, &pi->saved_sighold))
4347  proc_error (pi, "init_inferior, get_held_signals", __LINE__);
4348  if (!proc_get_traced_faults (pi, &pi->saved_fltset))
4349  proc_error (pi, "init_inferior, get_traced_faults", __LINE__);
4351  proc_error (pi, "init_inferior, get_traced_sysentry", __LINE__);
4352  if (!proc_get_traced_sysexit (pi, pi->saved_exitset))
4353  proc_error (pi, "init_inferior, get_traced_sysexit", __LINE__);
4354 
4355  if ((fail = procfs_debug_inferior (pi)) != 0)
4356  proc_error (pi, "init_inferior (procfs_debug_inferior)", fail);
4357 
4358  /* FIXME: logically, we should really be turning OFF run-on-last-close,
4359  and possibly even turning ON kill-on-last-close at this point. But
4360  I can't make that change without careful testing which I don't have
4361  time to do right now... */
4362  /* Turn on run-on-last-close flag so that the child
4363  will die if GDB goes away for some reason. */
4364  if (!proc_set_run_on_last_close (pi))
4365  proc_error (pi, "init_inferior, set_RLC", __LINE__);
4366 
4367  /* We now have have access to the lwpid of the main thread/lwp. */
4368  lwpid = proc_get_current_thread (pi);
4369 
4370  /* Create a procinfo for the main lwp. */
4371  create_procinfo (pid, lwpid);
4372 
4373  /* We already have a main thread registered in the thread table at
4374  this point, but it didn't have any lwp info yet. Notify the core
4375  about it. This changes inferior_ptid as well. */
4377  ptid_build (pid, lwpid, 0));
4378 
4380 
4381 #ifdef SYS_syssgi
4382  /* On mips-irix, we need to stop the inferior early enough during
4383  the startup phase in order to be able to load the shared library
4384  symbols and insert the breakpoints that are located in these shared
4385  libraries. Stopping at the program entry point is not good enough
4386  because the -init code is executed before the execution reaches
4387  that point.
4388 
4389  So what we need to do is to insert a breakpoint in the runtime
4390  loader (rld), more precisely in __dbx_link(). This procedure is
4391  called by rld once all shared libraries have been mapped, but before
4392  the -init code is executed. Unfortuantely, this is not straightforward,
4393  as rld is not part of the executable we are running, and thus we need
4394  the inferior to run until rld itself has been mapped in memory.
4395 
4396  For this, we trace all syssgi() syscall exit events. Each time
4397  we detect such an event, we iterate over each text memory maps,
4398  get its associated fd, and scan the symbol table for __dbx_link().
4399  When found, we know that rld has been mapped, and that we can insert
4400  the breakpoint at the symbol address. Once the dbx_link() breakpoint
4401  has been inserted, the syssgi() notifications are no longer necessary,
4402  so they should be canceled. */
4403  proc_trace_syscalls_1 (pi, SYS_syssgi, PR_SYSEXIT, FLAG_SET, 0);
4404 #endif
4405 }
4406 
4407 /* When GDB forks to create a new process, this function is called on
4408  the child side of the fork before GDB exec's the user program. Its
4409  job is to make the child minimally debuggable, so that the parent
4410  GDB process can connect to the child and take over. This function
4411  should do only the minimum to make that possible, and to
4412  synchronize with the parent process. The parent process should
4413  take care of the details. */
4414 
4415 static void
4417 {
4418  /* This routine called on the child side (inferior side)
4419  after GDB forks the inferior. It must use only local variables,
4420  because it may be sharing data space with its parent. */
4421 
4422  procinfo *pi;
4423  sysset_t *exitset;
4424 
4425  if ((pi = create_procinfo (getpid (), 0)) == NULL)
4426  perror_with_name (_("procfs: create_procinfo failed in child."));
4427 
4428  if (open_procinfo_files (pi, FD_CTL) == 0)
4429  {
4430  proc_warn (pi, "set_exec_trap, open_proc_files", __LINE__);
4432  /* No need to call "dead_procinfo", because we're going to
4433  exit. */
4434  _exit (127);
4435  }
4436 
4437 #ifdef PRFS_STOPEXEC /* defined on OSF */
4438  /* OSF method for tracing exec syscalls. Quoting:
4439  Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
4440  exits from exec system calls because of the user level loader. */
4441  /* FIXME: make nice and maybe move into an access function. */
4442  {
4443  int prfs_flags;
4444 
4445  if (ioctl (pi->ctl_fd, PIOCGSPCACT, &prfs_flags) < 0)
4446  {
4447  proc_warn (pi, "set_exec_trap (PIOCGSPCACT)", __LINE__);
4449  _exit (127);
4450  }
4451  prfs_flags |= PRFS_STOPEXEC;
4452 
4453  if (ioctl (pi->ctl_fd, PIOCSSPCACT, &prfs_flags) < 0)
4454  {
4455  proc_warn (pi, "set_exec_trap (PIOCSSPCACT)", __LINE__);
4457  _exit (127);
4458  }
4459  }
4460 #else /* not PRFS_STOPEXEC */
4461  /* Everyone else's (except OSF) method for tracing exec syscalls. */
4462  /* GW: Rationale...
4463  Not all systems with /proc have all the exec* syscalls with the same
4464  names. On the SGI, for example, there is no SYS_exec, but there
4465  *is* a SYS_execv. So, we try to account for that. */
4466 
4467  exitset = sysset_t_alloc (pi);
4468  gdb_premptysysset (exitset);
4469 #ifdef SYS_exec
4470  gdb_praddsysset (exitset, SYS_exec);
4471 #endif
4472 #ifdef SYS_execve
4473  gdb_praddsysset (exitset, SYS_execve);
4474 #endif
4475 #ifdef SYS_execv
4476  gdb_praddsysset (exitset, SYS_execv);
4477 #endif
4478 #ifdef DYNAMIC_SYSCALLS
4479  {
4480  int callnum = find_syscall (pi, "execve");
4481 
4482  if (callnum >= 0)
4483  gdb_praddsysset (exitset, callnum);
4484 
4485  callnum = find_syscall (pi, "ra_execve");
4486  if (callnum >= 0)
4487  gdb_praddsysset (exitset, callnum);
4488  }
4489 #endif /* DYNAMIC_SYSCALLS */
4490 
4491  if (!proc_set_traced_sysexit (pi, exitset))
4492  {
4493  proc_warn (pi, "set_exec_trap, set_traced_sysexit", __LINE__);
4495  _exit (127);
4496  }
4497 #endif /* PRFS_STOPEXEC */
4498 
4499  /* FIXME: should this be done in the parent instead? */
4500  /* Turn off inherit on fork flag so that all grand-children
4501  of gdb start with tracing flags cleared. */
4502  if (!proc_unset_inherit_on_fork (pi))
4503  proc_warn (pi, "set_exec_trap, unset_inherit", __LINE__);
4504 
4505  /* Turn off run on last close flag, so that the child process
4506  cannot run away just because we close our handle on it.
4507  We want it to wait for the parent to attach. */
4508  if (!proc_unset_run_on_last_close (pi))
4509  proc_warn (pi, "set_exec_trap, unset_RLC", __LINE__);
4510 
4511  /* FIXME: No need to destroy the procinfo --
4512  we have our own address space, and we're about to do an exec! */
4513  /*destroy_procinfo (pi);*/
4514 }
4515 
4516 /* This function is called BEFORE gdb forks the inferior process. Its
4517  only real responsibility is to set things up for the fork, and tell
4518  GDB which two functions to call after the fork (one for the parent,
4519  and one for the child).
4520 
4521  This function does a complicated search for a unix shell program,
4522  which it then uses to parse arguments and environment variables to
4523  be sent to the child. I wonder whether this code could not be
4524  abstracted out and shared with other unix targets such as
4525  inf-ptrace? */
4526 
4527 static void
4528 procfs_create_inferior (struct target_ops *ops, char *exec_file,
4529  char *allargs, char **env, int from_tty)
4530 {
4531  char *shell_file = getenv ("SHELL");
4532  char *tryname;
4533  int pid;
4534 
4535  if (shell_file != NULL && strchr (shell_file, '/') == NULL)
4536  {
4537 
4538  /* We will be looking down the PATH to find shell_file. If we
4539  just do this the normal way (via execlp, which operates by
4540  attempting an exec for each element of the PATH until it
4541  finds one which succeeds), then there will be an exec for
4542  each failed attempt, each of which will cause a PR_SYSEXIT
4543  stop, and we won't know how to distinguish the PR_SYSEXIT's
4544  for these failed execs with the ones for successful execs
4545  (whether the exec has succeeded is stored at that time in the
4546  carry bit or some such architecture-specific and
4547  non-ABI-specified place).
4548 
4549  So I can't think of anything better than to search the PATH
4550  now. This has several disadvantages: (1) There is a race
4551  condition; if we find a file now and it is deleted before we
4552  exec it, we lose, even if the deletion leaves a valid file
4553  further down in the PATH, (2) there is no way to know exactly
4554  what an executable (in the sense of "capable of being
4555  exec'd") file is. Using access() loses because it may lose
4556  if the caller is the superuser; failing to use it loses if
4557  there are ACLs or some such. */
4558 
4559  char *p;
4560  char *p1;
4561  /* FIXME-maybe: might want "set path" command so user can change what
4562  path is used from within GDB. */
4563  char *path = getenv ("PATH");
4564  int len;
4565  struct stat statbuf;
4566 
4567  if (path == NULL)
4568  path = "/bin:/usr/bin";
4569 
4570  tryname = alloca (strlen (path) + strlen (shell_file) + 2);
4571  for (p = path; p != NULL; p = p1 ? p1 + 1: NULL)
4572  {
4573  p1 = strchr (p, ':');
4574  if (p1 != NULL)
4575  len = p1 - p;
4576  else
4577  len = strlen (p);
4578  strncpy (tryname, p, len);
4579  tryname[len] = '\0';
4580  strcat (tryname, "/");
4581  strcat (tryname, shell_file);
4582  if (access (tryname, X_OK) < 0)
4583  continue;
4584  if (stat (tryname, &statbuf) < 0)
4585  continue;
4586  if (!S_ISREG (statbuf.st_mode))
4587  /* We certainly need to reject directories. I'm not quite
4588  as sure about FIFOs, sockets, etc., but I kind of doubt
4589  that people want to exec() these things. */
4590  continue;
4591  break;
4592  }
4593  if (p == NULL)
4594  /* Not found. This must be an error rather than merely passing
4595  the file to execlp(), because execlp() would try all the
4596  exec()s, causing GDB to get confused. */
4597  error (_("procfs:%d -- Can't find shell %s in PATH"),
4598  __LINE__, shell_file);
4599 
4600  shell_file = tryname;
4601  }
4602 
4603  pid = fork_inferior (exec_file, allargs, env, procfs_set_exec_trap,
4604  NULL, NULL, shell_file, NULL);
4605 
4606  procfs_init_inferior (ops, pid);
4607 }
4608 
4609 /* An observer for the "inferior_created" event. */
4610 
4611 static void
4612 procfs_inferior_created (struct target_ops *ops, int from_tty)
4613 {
4614 #ifdef SYS_syssgi
4615  /* Make sure to cancel the syssgi() syscall-exit notifications.
4616  They should normally have been removed by now, but they may still
4617  be activated if the inferior doesn't use shared libraries, or if
4618  we didn't locate __dbx_link, or if we never stopped in __dbx_link.
4619  See procfs_init_inferior() for more details.
4620 
4621  Since these notifications are only ever enabled when we spawned
4622  the inferior ourselves, there is nothing to do when the inferior
4623  was created by attaching to an already running process, or when
4624  debugging a core file. */
4625  if (current_inferior ()->attach_flag || !target_can_run (&current_target))
4626  return;
4627 
4629  0), SYS_syssgi, PR_SYSEXIT, FLAG_RESET, 0);
4630 #endif
4631 }
4632 
4633 /* Callback for update_thread_list. Calls "add_thread". */
4634 
4635 static int
4636 procfs_notice_thread (procinfo *pi, procinfo *thread, void *ptr)
4637 {
4638  ptid_t gdb_threadid = ptid_build (pi->pid, thread->tid, 0);
4639 
4640  if (!in_thread_list (gdb_threadid) || is_exited (gdb_threadid))
4641  add_thread (gdb_threadid);
4642 
4643  return 0;
4644 }
4645 
4646 /* Query all the threads that the target knows about, and give them
4647  back to GDB to add to its list. */
4648 
4649 static void
4651 {
4652  procinfo *pi;
4653 
4654  prune_threads ();
4655 
4656  /* Find procinfo for main process. */
4658  proc_update_threads (pi);
4660 }
4661 
4662 /* Return true if the thread is still 'alive'. This guy doesn't
4663  really seem to be doing his job. Got to investigate how to tell
4664  when a thread is really gone. */
4665 
4666 static int
4668 {
4669  int proc, thread;
4670  procinfo *pi;
4671 
4672  proc = ptid_get_pid (ptid);
4673  thread = ptid_get_lwp (ptid);
4674  /* If I don't know it, it ain't alive! */
4675  if ((pi = find_procinfo (proc, thread)) == NULL)
4676  return 0;
4677 
4678  /* If I can't get its status, it ain't alive!
4679  What's more, I need to forget about it! */
4680  if (!proc_get_status (pi))
4681  {
4682  destroy_procinfo (pi);
4683  return 0;
4684  }
4685  /* I couldn't have got its status if it weren't alive, so it's
4686  alive. */
4687  return 1;
4688 }
4689 
4690 /* Convert PTID to a string. Returns the string in a static
4691  buffer. */
4692 
4693 static char *
4695 {
4696  static char buf[80];
4697 
4698  if (ptid_get_lwp (ptid) == 0)
4699  sprintf (buf, "process %d", ptid_get_pid (ptid));
4700  else
4701  sprintf (buf, "LWP %ld", ptid_get_lwp (ptid));
4702 
4703  return buf;
4704 }
4705 
4706 /* Insert a watchpoint. */
4707 
4708 static int
4709 procfs_set_watchpoint (ptid_t ptid, CORE_ADDR addr, int len, int rwflag,
4710  int after)
4711 {
4712 #ifndef AIX5
4713  int pflags = 0;
4714  procinfo *pi;
4715 
4716  pi = find_procinfo_or_die (ptid_get_pid (ptid) == -1 ?
4718  0);
4719 
4720  /* Translate from GDB's flags to /proc's. */
4721  if (len > 0) /* len == 0 means delete watchpoint. */
4722  {
4723  switch (rwflag) { /* FIXME: need an enum! */
4724  case hw_write: /* default watchpoint (write) */
4725  pflags = WRITE_WATCHFLAG;
4726  break;
4727  case hw_read: /* read watchpoint */
4728  pflags = READ_WATCHFLAG;
4729  break;
4730  case hw_access: /* access watchpoint */
4731  pflags = READ_WATCHFLAG | WRITE_WATCHFLAG;
4732  break;
4733  case hw_execute: /* execution HW breakpoint */
4734  pflags = EXEC_WATCHFLAG;
4735  break;
4736  default: /* Something weird. Return error. */
4737  return -1;
4738  }
4739  if (after) /* Stop after r/w access is completed. */
4740  pflags |= AFTER_WATCHFLAG;
4741  }
4742 
4743  if (!proc_set_watchpoint (pi, addr, len, pflags))
4744  {
4745  if (errno == E2BIG) /* Typical error for no resources. */
4746  return -1; /* fail */
4747  /* GDB may try to remove the same watchpoint twice.
4748  If a remove request returns no match, don't error. */
4749  if (errno == ESRCH && len == 0)
4750  return 0; /* ignore */
4751  proc_error (pi, "set_watchpoint", __LINE__);
4752  }
4753 #endif /* AIX5 */
4754  return 0;
4755 }
4756 
4757 /* Return non-zero if we can set a hardware watchpoint of type TYPE. TYPE
4758  is one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint,
4759  or bp_hardware_watchpoint. CNT is the number of watchpoints used so
4760  far.
4761 
4762  Note: procfs_can_use_hw_breakpoint() is not yet used by all
4763  procfs.c targets due to the fact that some of them still define
4764  target_can_use_hardware_watchpoint. */
4765 
4766 static int
4768  int type, int cnt, int othertype)
4769 {
4770  /* Due to the way that proc_set_watchpoint() is implemented, host
4771  and target pointers must be of the same size. If they are not,
4772  we can't use hardware watchpoints. This limitation is due to the
4773  fact that proc_set_watchpoint() calls
4774  procfs_address_to_host_pointer(); a close inspection of
4775  procfs_address_to_host_pointer will reveal that an internal error
4776  will be generated when the host and target pointer sizes are
4777  different. */
4778  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
4779 
4780  if (sizeof (void *) != TYPE_LENGTH (ptr_type))
4781  return 0;
4782 
4783  /* Other tests here??? */
4784 
4785  return 1;
4786 }
4787 
4788 /* Returns non-zero if process is stopped on a hardware watchpoint
4789  fault, else returns zero. */
4790 
4791 static int
4793 {
4794  procinfo *pi;
4795 
4797 
4798  if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
4799  {
4800  if (proc_why (pi) == PR_FAULTED)
4801  {
4802 #ifdef FLTWATCH
4803  if (proc_what (pi) == FLTWATCH)
4804  return 1;
4805 #endif
4806 #ifdef FLTKWATCH
4807  if (proc_what (pi) == FLTKWATCH)
4808  return 1;
4809 #endif
4810  }
4811  }
4812  return 0;
4813 }
4814 
4815 /* Returns 1 if the OS knows the position of the triggered watchpoint,
4816  and sets *ADDR to that address. Returns 0 if OS cannot report that
4817  address. This function is only called if
4818  procfs_stopped_by_watchpoint returned 1, thus no further checks are
4819  done. The function also assumes that ADDR is not NULL. */
4820 
4821 static int
4823 {
4824  procinfo *pi;
4825 
4827  return proc_watchpoint_address (pi, addr);
4828 }
4829 
4830 static int
4832  CORE_ADDR addr, int len, int type,
4833  struct expression *cond)
4834 {
4837  {
4838  /* When a hardware watchpoint fires off the PC will be left at
4839  the instruction following the one which caused the
4840  watchpoint. It will *NOT* be necessary for GDB to step over
4841  the watchpoint. */
4842  return procfs_set_watchpoint (inferior_ptid, addr, len, type, 1);
4843  }
4844  else
4845  {
4846  /* When a hardware watchpoint fires off the PC will be left at
4847  the instruction which caused the watchpoint. It will be
4848  necessary for GDB to step over the watchpoint. */
4849  return procfs_set_watchpoint (inferior_ptid, addr, len, type, 0);
4850  }
4851 }
4852 
4853 static int
4855  CORE_ADDR addr, int len, int type,
4856  struct expression *cond)
4857 {
4858  return procfs_set_watchpoint (inferior_ptid, addr, 0, 0, 0);
4859 }
4860 
4861 static int
4863  CORE_ADDR addr, int len)
4864 {
4865  /* The man page for proc(4) on Solaris 2.6 and up says that the
4866  system can support "thousands" of hardware watchpoints, but gives
4867  no method for finding out how many; It doesn't say anything about
4868  the allowed size for the watched area either. So we just tell
4869  GDB 'yes'. */
4870  return 1;
4871 }
4872 
4873 void
4875 {
4882 }
4883 
4884 /* Memory Mappings Functions: */
4885 
4886 /* Call a callback function once for each mapping, passing it the
4887  mapping, an optional secondary callback function, and some optional
4888  opaque data. Quit and return the first non-zero value returned
4889  from the callback.
4890 
4891  PI is the procinfo struct for the process to be mapped. FUNC is
4892  the callback function to be called by this iterator. DATA is the
4893  optional opaque data to be passed to the callback function.
4894  CHILD_FUNC is the optional secondary function pointer to be passed
4895  to the child function. Returns the first non-zero return value
4896  from the callback function, or zero. */
4897 
4898 static int
4900  void *data,
4901  int (*func) (struct prmap *map,
4902  find_memory_region_ftype child_func,
4903  void *data))
4904 {
4905  char pathname[MAX_PROC_NAME_SIZE];
4906  struct prmap *prmaps;
4907  struct prmap *prmap;
4908  int funcstat;
4909  int map_fd;
4910  int nmap;
4911  struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
4912 #ifdef NEW_PROC_API
4913  struct stat sbuf;
4914 #endif
4915 
4916  /* Get the number of mappings, allocate space,
4917  and read the mappings into prmaps. */
4918 #ifdef NEW_PROC_API
4919  /* Open map fd. */
4920  sprintf (pathname, "/proc/%d/map", pi->pid);
4921  if ((map_fd = open (pathname, O_RDONLY)) < 0)
4922  proc_error (pi, "iterate_over_mappings (open)", __LINE__);
4923 
4924  /* Make sure it gets closed again. */
4925  make_cleanup_close (map_fd);
4926 
4927  /* Use stat to determine the file size, and compute
4928  the number of prmap_t objects it contains. */
4929  if (fstat (map_fd, &sbuf) != 0)
4930  proc_error (pi, "iterate_over_mappings (fstat)", __LINE__);
4931 
4932  nmap = sbuf.st_size / sizeof (prmap_t);
4933  prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
4934  if (read (map_fd, (char *) prmaps, nmap * sizeof (*prmaps))
4935  != (nmap * sizeof (*prmaps)))
4936  proc_error (pi, "iterate_over_mappings (read)", __LINE__);
4937 #else
4938  /* Use ioctl command PIOCNMAP to get number of mappings. */
4939  if (ioctl (pi->ctl_fd, PIOCNMAP, &nmap) != 0)
4940  proc_error (pi, "iterate_over_mappings (PIOCNMAP)", __LINE__);
4941 
4942  prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
4943  if (ioctl (pi->ctl_fd, PIOCMAP, prmaps) != 0)
4944  proc_error (pi, "iterate_over_mappings (PIOCMAP)", __LINE__);
4945 #endif
4946 
4947  for (prmap = prmaps; nmap > 0; prmap++, nmap--)
4948  if ((funcstat = (*func) (prmap, child_func, data)) != 0)
4949  {
4950  do_cleanups (cleanups);
4951  return funcstat;
4952  }
4953 
4954  do_cleanups (cleanups);
4955  return 0;
4956 }
4957 
4958 /* Implements the to_find_memory_regions method. Calls an external
4959  function for each memory region.
4960  Returns the integer value returned by the callback. */
4961 
4962 static int
4963 find_memory_regions_callback (struct prmap *map,
4964  find_memory_region_ftype func, void *data)
4965 {
4966  return (*func) ((CORE_ADDR) map->pr_vaddr,
4967  map->pr_size,
4968  (map->pr_mflags & MA_READ) != 0,
4969  (map->pr_mflags & MA_WRITE) != 0,
4970  (map->pr_mflags & MA_EXEC) != 0,
4971  1, /* MODIFIED is unknown, pass it as true. */
4972  data);
4973 }
4974 
4975 /* External interface. Calls a callback function once for each
4976  mapped memory region in the child process, passing as arguments:
4977 
4978  CORE_ADDR virtual_address,
4979  unsigned long size,
4980  int read, TRUE if region is readable by the child
4981  int write, TRUE if region is writable by the child
4982  int execute TRUE if region is executable by the child.
4983 
4984  Stops iterating and returns the first non-zero value returned by
4985  the callback. */
4986 
4987 static int
4989  find_memory_region_ftype func, void *data)
4990 {
4992 
4993  return iterate_over_mappings (pi, func, data,
4995 }
4996 
4997 /* Returns an ascii representation of a memory mapping's flags. */
4998 
4999 static char *
5001 {
5002  static char asciiflags[8];
5003 
5004  strcpy (asciiflags, "-------");
5005 #if defined (MA_PHYS)
5006  if (flags & MA_PHYS)
5007  asciiflags[0] = 'd';
5008 #endif
5009  if (flags & MA_STACK)
5010  asciiflags[1] = 's';
5011  if (flags & MA_BREAK)
5012  asciiflags[2] = 'b';
5013  if (flags & MA_SHARED)
5014  asciiflags[3] = 's';
5015  if (flags & MA_READ)
5016  asciiflags[4] = 'r';
5017  if (flags & MA_WRITE)
5018  asciiflags[5] = 'w';
5019  if (flags & MA_EXEC)
5020  asciiflags[6] = 'x';
5021  return (asciiflags);
5022 }
5023 
5024 /* Callback function, does the actual work for 'info proc
5025  mappings'. */
5026 
5027 static int
5029  void *unused)
5030 {
5031  unsigned int pr_off;
5032 
5033 #ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */
5034  pr_off = (unsigned int) map->pr_offset;
5035 #else
5036  pr_off = map->pr_off;
5037 #endif
5038 
5039  if (gdbarch_addr_bit (target_gdbarch ()) == 32)
5040  printf_filtered ("\t%#10lx %#10lx %#10lx %#10x %7s\n",
5041  (unsigned long) map->pr_vaddr,
5042  (unsigned long) map->pr_vaddr + map->pr_size - 1,
5043  (unsigned long) map->pr_size,
5044  pr_off,
5045  mappingflags (map->pr_mflags));
5046  else
5047  printf_filtered (" %#18lx %#18lx %#10lx %#10x %7s\n",
5048  (unsigned long) map->pr_vaddr,
5049  (unsigned long) map->pr_vaddr + map->pr_size - 1,
5050  (unsigned long) map->pr_size,
5051  pr_off,
5052  mappingflags (map->pr_mflags));
5053 
5054  return 0;
5055 }
5056 
5057 /* Implement the "info proc mappings" subcommand. */
5058 
5059 static void
5060 info_proc_mappings (procinfo *pi, int summary)
5061 {
5062  if (summary)
5063  return; /* No output for summary mode. */
5064 
5065  printf_filtered (_("Mapped address spaces:\n\n"));
5066  if (gdbarch_ptr_bit (target_gdbarch ()) == 32)
5067  printf_filtered ("\t%10s %10s %10s %10s %7s\n",
5068  "Start Addr",
5069  " End Addr",
5070  " Size",
5071  " Offset",
5072  "Flags");
5073  else
5074  printf_filtered (" %18s %18s %10s %10s %7s\n",
5075  "Start Addr",
5076  " End Addr",
5077  " Size",
5078  " Offset",
5079  "Flags");
5080 
5082  printf_filtered ("\n");
5083 }
5084 
5085 /* Implement the "info proc" command. */
5086 
5087 static void
5088 procfs_info_proc (struct target_ops *ops, const char *args,
5089  enum info_proc_what what)
5090 {
5091  struct cleanup *old_chain;
5092  procinfo *process = NULL;
5093  procinfo *thread = NULL;
5094  char **argv = NULL;
5095  char *tmp = NULL;
5096  int pid = 0;
5097  int tid = 0;
5098  int mappings = 0;
5099 
5100  switch (what)
5101  {
5102  case IP_MINIMAL:
5103  break;
5104 
5105  case IP_MAPPINGS:
5106  case IP_ALL:
5107  mappings = 1;
5108  break;
5109 
5110  default:
5111  error (_("Not supported on this target."));
5112  }
5113 
5114  old_chain = make_cleanup (null_cleanup, 0);
5115  if (args)
5116  {
5117  argv = gdb_buildargv (args);
5118  make_cleanup_freeargv (argv);
5119  }
5120  while (argv != NULL && *argv != NULL)
5121  {
5122  if (isdigit (argv[0][0]))
5123  {
5124  pid = strtoul (argv[0], &tmp, 10);
5125  if (*tmp == '/')
5126  tid = strtoul (++tmp, NULL, 10);
5127  }
5128  else if (argv[0][0] == '/')
5129  {
5130  tid = strtoul (argv[0] + 1, NULL, 10);
5131  }
5132  argv++;
5133  }
5134  if (pid == 0)
5135  pid = ptid_get_pid (inferior_ptid);
5136  if (pid == 0)
5137  error (_("No current process: you must name one."));
5138  else
5139  {
5140  /* Have pid, will travel.
5141  First see if it's a process we're already debugging. */
5142  process = find_procinfo (pid, 0);
5143  if (process == NULL)
5144  {
5145  /* No. So open a procinfo for it, but
5146  remember to close it again when finished. */
5147  process = create_procinfo (pid, 0);
5149  if (!open_procinfo_files (process, FD_CTL))
5150  proc_error (process, "info proc, open_procinfo_files", __LINE__);
5151  }
5152  }
5153  if (tid != 0)
5154  thread = create_procinfo (pid, tid);
5155 
5156  if (process)
5157  {
5158  printf_filtered (_("process %d flags:\n"), process->pid);
5159  proc_prettyprint_flags (proc_flags (process), 1);
5160  if (proc_flags (process) & (PR_STOPPED | PR_ISTOP))
5161  proc_prettyprint_why (proc_why (process), proc_what (process), 1);
5162  if (proc_get_nthreads (process) > 1)
5163  printf_filtered ("Process has %d threads.\n",
5164  proc_get_nthreads (process));
5165  }
5166  if (thread)
5167  {
5168  printf_filtered (_("thread %d flags:\n"), thread->tid);
5169  proc_prettyprint_flags (proc_flags (thread), 1);
5170  if (proc_flags (thread) & (PR_STOPPED | PR_ISTOP))
5171  proc_prettyprint_why (proc_why (thread), proc_what (thread), 1);
5172  }
5173 
5174  if (mappings)
5175  {
5176  info_proc_mappings (process, 0);
5177  }
5178 
5179  do_cleanups (old_chain);
5180 }
5181 
5182 /* Modify the status of the system call identified by SYSCALLNUM in
5183  the set of syscalls that are currently traced/debugged.
5184 
5185  If ENTRY_OR_EXIT is set to PR_SYSENTRY, then the entry syscalls set
5186  will be updated. Otherwise, the exit syscalls set will be updated.
5187 
5188  If MODE is FLAG_SET, then traces will be enabled. Otherwise, they
5189  will be disabled. */
5190 
5191 static void
5192 proc_trace_syscalls_1 (procinfo *pi, int syscallnum, int entry_or_exit,
5193  int mode, int from_tty)
5194 {
5195  sysset_t *sysset;
5196 
5197  if (entry_or_exit == PR_SYSENTRY)
5198  sysset = proc_get_traced_sysentry (pi, NULL);
5199  else
5200  sysset = proc_get_traced_sysexit (pi, NULL);
5201 
5202  if (sysset == NULL)
5203  proc_error (pi, "proc-trace, get_traced_sysset", __LINE__);
5204 
5205  if (mode == FLAG_SET)
5206  gdb_praddsysset (sysset, syscallnum);
5207  else
5208  gdb_prdelsysset (sysset, syscallnum);
5209 
5210  if (entry_or_exit == PR_SYSENTRY)
5211  {
5212  if (!proc_set_traced_sysentry (pi, sysset))
5213  proc_error (pi, "proc-trace, set_traced_sysentry", __LINE__);
5214  }
5215  else
5216  {
5217  if (!proc_set_traced_sysexit (pi, sysset))
5218  proc_error (pi, "proc-trace, set_traced_sysexit", __LINE__);
5219  }
5220 }
5221 
5222 static void
5223 proc_trace_syscalls (char *args, int from_tty, int entry_or_exit, int mode)
5224 {
5225  procinfo *pi;
5226 
5227  if (ptid_get_pid (inferior_ptid) <= 0)
5228  error (_("you must be debugging a process to use this command."));
5229 
5230  if (args == NULL || args[0] == 0)
5231  error_no_arg (_("system call to trace"));
5232 
5234  if (isdigit (args[0]))
5235  {
5236  const int syscallnum = atoi (args);
5237 
5238  proc_trace_syscalls_1 (pi, syscallnum, entry_or_exit, mode, from_tty);
5239  }
5240 }
5241 
5242 static void
5243 proc_trace_sysentry_cmd (char *args, int from_tty)
5244 {
5245  proc_trace_syscalls (args, from_tty, PR_SYSENTRY, FLAG_SET);
5246 }
5247 
5248 static void
5249 proc_trace_sysexit_cmd (char *args, int from_tty)
5250 {
5251  proc_trace_syscalls (args, from_tty, PR_SYSEXIT, FLAG_SET);
5252 }
5253 
5254 static void
5255 proc_untrace_sysentry_cmd (char *args, int from_tty)
5256 {
5257  proc_trace_syscalls (args, from_tty, PR_SYSENTRY, FLAG_RESET);
5258 }
5259 
5260 static void
5261 proc_untrace_sysexit_cmd (char *args, int from_tty)
5262 {
5263  proc_trace_syscalls (args, from_tty, PR_SYSEXIT, FLAG_RESET);
5264 }
5265 
5266 
5267 /* Provide a prototype to silence -Wmissing-prototypes. */
5268 extern void _initialize_procfs (void);
5269 
5270 void
5272 {
5274 
5275  add_com ("proc-trace-entry", no_class, proc_trace_sysentry_cmd,
5276  _("Give a trace of entries into the syscall."));
5277  add_com ("proc-trace-exit", no_class, proc_trace_sysexit_cmd,
5278  _("Give a trace of exits from the syscall."));
5279  add_com ("proc-untrace-entry", no_class, proc_untrace_sysentry_cmd,
5280  _("Cancel a trace of entries into the syscall."));
5281  add_com ("proc-untrace-exit", no_class, proc_untrace_sysexit_cmd,
5282  _("Cancel a trace of exits from the syscall."));
5283 }
5284 
5285 /* =================== END, GDB "MODULE" =================== */
5286 
5287 
5288 
5289 /* miscellaneous stubs: */
5290 
5291 /* The following satisfy a few random symbols mostly created by the
5292  solaris threads implementation, which I will chase down later. */
5293 
5294 /* Return a pid for which we guarantee we will be able to find a
5295  'live' procinfo. */
5296 
5297 ptid_t
5299 {
5300  return pid_to_ptid (procinfo_list ? procinfo_list->pid : -1);
5301 }
5302 
5303 /* =================== GCORE .NOTE "MODULE" =================== */
5304 #if defined (PIOCOPENLWP) || defined (PCAGENT)
5305 /* gcore only implemented on solaris (so far) */
5306 
5307 static char *
5308 procfs_do_thread_registers (bfd *obfd, ptid_t ptid,
5309  char *note_data, int *note_size,
5310  enum gdb_signal stop_signal)
5311 {
5312  struct regcache *regcache = get_thread_regcache (ptid);
5313  gdb_gregset_t gregs;
5314  gdb_fpregset_t fpregs;
5315  unsigned long merged_pid;
5316  struct cleanup *old_chain;
5317 
5318  merged_pid = ptid_get_lwp (ptid) << 16 | ptid_get_pid (ptid);
5319 
5320  /* This part is the old method for fetching registers.
5321  It should be replaced by the newer one using regsets
5322  once it is implemented in this platform:
5323  gdbarch_iterate_over_regset_sections(). */
5324 
5325  old_chain = save_inferior_ptid ();
5326  inferior_ptid = ptid;
5327  target_fetch_registers (regcache, -1);
5328 
5329  fill_gregset (regcache, &gregs, -1);
5330 #if defined (NEW_PROC_API)
5331  note_data = (char *) elfcore_write_lwpstatus (obfd,
5332  note_data,
5333  note_size,
5334  merged_pid,
5335  stop_signal,
5336  &gregs);
5337 #else
5338  note_data = (char *) elfcore_write_prstatus (obfd,
5339  note_data,
5340  note_size,
5341  merged_pid,
5342  stop_signal,
5343  &gregs);
5344 #endif
5345  fill_fpregset (regcache, &fpregs, -1);
5346  note_data = (char *) elfcore_write_prfpreg (obfd,
5347  note_data,
5348  note_size,
5349  &fpregs,
5350  sizeof (fpregs));
5351 
5352  do_cleanups (old_chain);
5353 
5354  return note_data;
5355 }
5356 
5357 struct procfs_corefile_thread_data {
5358  bfd *obfd;
5359  char *note_data;
5360  int *note_size;
5361  enum gdb_signal stop_signal;
5362 };
5363 
5364 static int
5365 procfs_corefile_thread_callback (procinfo *pi, procinfo *thread, void *data)
5366 {
5367  struct procfs_corefile_thread_data *args = data;
5368 
5369  if (pi != NULL)
5370  {
5371  ptid_t ptid = ptid_build (pi->pid, thread->tid, 0);
5372 
5373  args->note_data = procfs_do_thread_registers (args->obfd, ptid,
5374  args->note_data,
5375  args->note_size,
5376  args->stop_signal);
5377  }
5378  return 0;
5379 }
5380 
5381 static int
5382 find_signalled_thread (struct thread_info *info, void *data)
5383 {
5384  if (info->suspend.stop_signal != GDB_SIGNAL_0
5385  && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
5386  return 1;
5387 
5388  return 0;
5389 }
5390 
5391 static enum gdb_signal
5392 find_stop_signal (void)
5393 {
5394  struct thread_info *info =
5396 
5397  if (info)
5398  return info->suspend.stop_signal;
5399  else
5400  return GDB_SIGNAL_0;
5401 }
5402 
5403 static char *
5404 procfs_make_note_section (struct target_ops *self, bfd *obfd, int *note_size)
5405 {
5406  struct cleanup *old_chain;
5407  gdb_gregset_t gregs;
5408  gdb_fpregset_t fpregs;
5409  char fname[16] = {'\0'};
5410  char psargs[80] = {'\0'};
5412  char *note_data = NULL;
5413  char *inf_args;
5414  struct procfs_corefile_thread_data thread_args;
5415  gdb_byte *auxv;
5416  int auxv_len;
5417  enum gdb_signal stop_signal;
5418 
5419  if (get_exec_file (0))
5420  {
5421  strncpy (fname, lbasename (get_exec_file (0)), sizeof (fname));
5422  fname[sizeof (fname) - 1] = 0;
5423  strncpy (psargs, get_exec_file (0), sizeof (psargs));
5424  psargs[sizeof (psargs) - 1] = 0;
5425 
5426  inf_args = get_inferior_args ();
5427  if (inf_args && *inf_args &&
5428  strlen (inf_args) < ((int) sizeof (psargs) - (int) strlen (psargs)))
5429  {
5430  strncat (psargs, " ",
5431  sizeof (psargs) - strlen (psargs));
5432  strncat (psargs, inf_args,
5433  sizeof (psargs) - strlen (psargs));
5434  }
5435  }
5436 
5437  note_data = (char *) elfcore_write_prpsinfo (obfd,
5438  note_data,
5439  note_size,
5440  fname,
5441  psargs);
5442 
5443  stop_signal = find_stop_signal ();
5444 
5445 #ifdef NEW_PROC_API
5446  fill_gregset (get_current_regcache (), &gregs, -1);
5447  note_data = elfcore_write_pstatus (obfd, note_data, note_size,
5449  stop_signal, &gregs);
5450 #endif
5451 
5452  thread_args.obfd = obfd;
5453  thread_args.note_data = note_data;
5454  thread_args.note_size = note_size;
5455  thread_args.stop_signal = stop_signal;
5456  proc_iterate_over_threads (pi, procfs_corefile_thread_callback,
5457  &thread_args);
5458  note_data = thread_args.note_data;
5459 
5461  NULL, &auxv);
5462  if (auxv_len > 0)
5463  {
5464  note_data = elfcore_write_note (obfd, note_data, note_size,
5465  "CORE", NT_AUXV, auxv, auxv_len);
5466  xfree (auxv);
5467  }
5468 
5469  return note_data;
5470 }
5471 #else /* !Solaris */
5472 static char *
5473 procfs_make_note_section (struct target_ops *self, bfd *obfd, int *note_size)
5474 {
5475  error (_("gcore not implemented for this host."));
5476  return NULL; /* lint */
5477 }
5478 #endif /* Solaris */
5479 /* =================== END GCORE .NOTE "MODULE" =================== */
void error_no_arg(const char *why)
Definition: cli-cmds.c:205
void get_last_target_status(ptid_t *ptidp, struct target_waitstatus *status)
Definition: infrun.c:3408
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
struct cleanup * make_cleanup_freeargv(char **arg)
Definition: utils.c:165
Definition: procfs.c:797
static ptid_t procfs_wait(struct target_ops *, ptid_t, struct target_waitstatus *, int)
Definition: procfs.c:3536
int threads_valid
Definition: procfs.c:412
static void destroy_procinfo(procinfo *p)
Definition: procfs.c:772
ssize_t read(int fd, void *buf, size_t count)
Definition: expect-read1.c:26
ptid_t procfs_first_available(void)
Definition: procfs.c:5298
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
static int open_procinfo_files(procinfo *p, int which)
Definition: procfs.c:535
int status_fd
Definition: procfs.c:385
long procfs_ctl_t
Definition: proc-utils.h:118
int fpregs_valid
Definition: procfs.c:411
static int procfs_region_ok_for_hw_watchpoint(struct target_ops *self, CORE_ADDR addr, int len)
Definition: procfs.c:4862
Definition: procfs.c:797
struct thread_info * add_thread(ptid_t ptid)
Definition: thread.c:305
static target_xfer_partial_ftype procfs_xfer_partial
Definition: procfs.c:133
static void destroy_one_procinfo(procinfo **list, procinfo *pi)
Definition: procfs.c:744
static int proc_what(procinfo *pi)
Definition: procfs.c:1159
static int procfs_insert_watchpoint(struct target_ops *self, CORE_ADDR addr, int len, int type, struct expression *cond)
Definition: procfs.c:4831
static int sysset_t_size(procinfo *p)
Definition: procfs.c:829
static void proc_warn(procinfo *pi, char *func, int line)
Definition: procfs.c:1023
#define MAIN_PROC_NAME_FMT
Definition: procfs.c:352
static void do_destroy_procinfo_cleanup(void *)
Definition: procfs.c:792
int status_valid
Definition: procfs.c:409
#define gdb_premptysysset
Definition: procfs.c:275
siginfo_t gdb_siginfo_t
Definition: procfs.c:259
static int syscall_is_lwp_create(procinfo *pi, int scall)
Definition: procfs.c:3357
int ptid_equal(ptid_t ptid1, ptid_t ptid2)
Definition: ptid.c:76
int(* to_find_memory_regions)(struct target_ops *, find_memory_region_ftype func, void *data) TARGET_DEFAULT_FUNC(dummy_find_memory_regions)
Definition: target.h:671
bfd_vma CORE_ADDR
Definition: common-types.h:41
gdb_prstatus_t prstatus
Definition: procfs.c:396
struct regcache * get_thread_regcache(ptid_t ptid)
Definition: regcache.c:529
void fill_gregset(const struct regcache *regcache, gdb_gregset_t *gregsetp, int regno)
void delete_thread(ptid_t)
Definition: thread.c:368
void xfree(void *)
Definition: common-utils.c:97
char * get_inferior_args(void)
Definition: infcmd.c:187
struct cleanup * next
Definition: cleanups.c:40
static int proc_set_traced_faults(procinfo *pi, fltset_t *fltset)
Definition: procfs.c:1617
static int procfs_notice_thread(procinfo *pi, procinfo *thread, void *ptr)
Definition: procfs.c:4636
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
void(* func)(char *)
if(!(yy_init))
Definition: ada-lex.c:1072
static void procfs_mourn_inferior(struct target_ops *ops)
Definition: procfs.c:4283
void warning(const char *fmt,...)
Definition: errors.c:26
static int proc_get_current_thread(procinfo *pi)
Definition: procfs.c:2686
static long * proc_sysargs(procinfo *pi)
Definition: procfs.c:1219
char *(* to_pid_to_str)(struct target_ops *, ptid_t) TARGET_DEFAULT_FUNC(default_pid_to_str)
Definition: target.h:631
static int procfs_remove_watchpoint(struct target_ops *self, CORE_ADDR addr, int len, int type, struct expression *cond)
Definition: procfs.c:4854
int query(const char *ctlstr,...)
Definition: utils.c:1364
static procinfo * find_procinfo(int pid, int tid)
Definition: procfs.c:447
tuple inf
Definition: arm-linux.py:13
static const struct @41 signals[]
static int proc_watchpoint_address(procinfo *pi, CORE_ADDR *addr)
Definition: procfs.c:1178
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1690
void push_target(struct target_ops *t)
Definition: target.c:664
LONGEST target_read_alloc(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte **buf_p)
Definition: target.c:1971
static int iterate_over_mappings(procinfo *pi, find_memory_region_ftype child_func, void *data, int(*func)(struct prmap *map, find_memory_region_ftype child_func, void *data))
struct ui_file * gdb_stdout
Definition: main.c:71
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
static void procfs_info_proc(struct target_ops *, const char *, enum info_proc_what)
Definition: procfs.c:5088
void print_sys_errmsg(const char *string, int errcode)
Definition: utils.c:1001
#define target_can_run(t)
Definition: target.h:1624
int info_verbose
Definition: top.c:1699
void generic_mourn_inferior(void)
Definition: target.c:3171
void proc_prettyprint_syscall(int num, int verbose)
Definition: proc-events.c:1370
static int procfs_thread_alive(struct target_ops *ops, ptid_t)
Definition: procfs.c:4667
int was_stopped
Definition: procfs.c:370
static void procfs_attach(struct target_ops *, const char *, int)
Definition: procfs.c:3026
void _initialize_procfs(void)
Definition: procfs.c:5271
static int procfs_debug_inferior(procinfo *pi)
Definition: procfs.c:2913
static int proc_get_status(procinfo *pi)
Definition: procfs.c:1043
int(* to_region_ok_for_hw_watchpoint)(struct target_ops *, CORE_ADDR, int) TARGET_DEFAULT_FUNC(default_region_ok_for_hw_watchpoint)
Definition: target.h:554
ptid_t(* to_wait)(struct target_ops *, ptid_t, struct target_waitstatus *, int TARGET_DEBUG_PRINTER(target_debug_print_options)) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:468
void target_fetch_registers(struct regcache *regcache, int regno)
Definition: target.c:3419
char * target_pid_to_str(ptid_t ptid)
Definition: target.c:2233
#define _(String)
Definition: gdb_locale.h:40
enum gdb_signal stop_signal
Definition: gdbthread.h:159
static int syscall_is_exit(procinfo *pi, int scall)
Definition: procfs.c:3319
static int proc_iterate_over_threads(procinfo *pi, int(*func)(procinfo *, procinfo *, void *), void *ptr)
Definition: procfs.c:2867
int gdbarch_have_nonsteppable_watchpoint(struct gdbarch *gdbarch)
Definition: gdbarch.c:3251
static void do_closedir_cleanup(void *dir)
Definition: nto-procfs.c:349
static int info_mappings_callback(struct prmap *map, find_memory_region_ftype ignore, void *unused)
Definition: procfs.c:5028
void inf_child_maybe_unpush_target(struct target_ops *ops)
Definition: inf-child.c:172
int ignore_next_sigstop
Definition: procfs.c:371
static procinfo * find_procinfo_or_die(int pid, int tid)
Definition: procfs.c:476
void fill_fpregset(const struct regcache *regcache, gdb_fpregset_t *fpregsetp, int regno)
struct regcache * get_current_regcache(void)
Definition: regcache.c:541
gdb_sigset_t saved_sighold
Definition: procfs.c:392
int gregs_valid
Definition: procfs.c:410
static int proc_why(procinfo *pi)
Definition: procfs.c:1143
static gdb_sigset_t * proc_get_traced_signals(procinfo *pi, gdb_sigset_t *save)
Definition: procfs.c:1819
void printf_filtered(const char *format,...)
Definition: utils.c:2388
static void procfs_pass_signals(struct target_ops *self, int, unsigned char *)
Definition: procfs.c:4171
Definition: ptid.h:35
int ctl_fd
Definition: procfs.c:377
static int proc_set_traced_signals(procinfo *pi, gdb_sigset_t *sigset)
Definition: procfs.c:1577
ptid_t ptid_build(int pid, long lwp, long tid)
Definition: ptid.c:31
gdb_sigset_t saved_sigset
Definition: procfs.c:391
void(* to_files_info)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:479
static void close_procinfo_files(procinfo *p)
Definition: procfs.c:728
static gdb_fpregset_t * proc_get_fpregs(procinfo *pi)
Definition: procfs.c:2193
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1885
struct procinfo procinfo
void null_cleanup(void *arg)
Definition: cleanups.c:295
struct observer * observer_attach_inferior_created(observer_inferior_created_ftype *f)
int in_thread_list(ptid_t ptid)
Definition: thread.c:482
static sysset_t * proc_get_traced_sysexit(procinfo *pi, sysset_t *save)
Definition: procfs.c:1958
struct thread_info * iterate_over_threads(thread_callback_func, void *)
Definition: thread.c:419
#define gdb_prdelset(sp, flag)
Definition: procfs.c:269
static void proc_untrace_sysexit_cmd(char *args, int from_tty)
Definition: procfs.c:5261
struct procinfo * next
Definition: procfs.c:365
int(* to_insert_watchpoint)(struct target_ops *, CORE_ADDR, int, int, struct expression *) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:532
static int proc_set_gregs(procinfo *pi)
Definition: procfs.c:2262
struct cleanup * save_inferior_ptid(void)
Definition: infrun.c:7538
#define OPS_MAGIC
Definition: target.h:1233
static int proc_clear_current_signal(procinfo *pi)
Definition: procfs.c:2133
sigset_t gdb_sigset_t
Definition: procfs.c:245
static enum gdb_signal find_stop_signal(void)
Definition: fbsd-tdep.c:42
Definition: gnu-nat.h:42
static void procfs_set_exec_trap(void)
Definition: procfs.c:4416
static gdb_sigset_t * proc_get_held_signals(procinfo *pi, gdb_sigset_t *save)
Definition: procfs.c:1783
struct target_ops current_target
void gdb_bfd_unref(struct bfd *abfd)
Definition: gdb_bfd.c:475
static void procfs_resume(struct target_ops *, ptid_t, int, enum gdb_signal)
Definition: procfs.c:4089
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:1981
sysset_t * saved_exitset
Definition: procfs.c:393
void startup_inferior(int ntraps)
Definition: fork-child.c:414
static char * procfs_pid_to_str(struct target_ops *, ptid_t)
Definition: procfs.c:4694
#define MAX_SYSCALLS
Definition: proc-events.c:66
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
static void procfs_files_info(struct target_ops *)
Definition: procfs.c:4194
struct procinfo * thread_list
Definition: procfs.c:407
bfd * gdb_bfd_fdopenr(const char *filename, const char *target, int fd)
Definition: gdb_bfd.c:789
enum gdb_signal sig
Definition: waitstatus.h:108
GDB_GREGSET_T gdb_gregset_t
Definition: gregset.h:34
static void procfs_detach(struct target_ops *, const char *, int)
Definition: procfs.c:3055
int(* to_remove_watchpoint)(struct target_ops *, CORE_ADDR, int, int, struct expression *) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:529
#define gdb_praddsysset
Definition: procfs.c:282
void target_resume(ptid_t ptid, int step, enum gdb_signal signal)
Definition: target.c:2245
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
void(* to_resume)(struct target_ops *, ptid_t, int TARGET_DEBUG_PRINTER(target_debug_print_step), enum gdb_signal) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:464
static enum target_xfer_status procfs_xfer_memory(gdb_byte *, const gdb_byte *, ULONGEST, ULONGEST, ULONGEST *)
Definition: procfs.c:3967
static int proc_set_traced_sysexit(procinfo *pi, sysset_t *sysset)
Definition: procfs.c:1700
GDB_FPREGSET_T gdb_fpregset_t
Definition: gregset.h:35
void free_current_contents(void *ptr)
Definition: utils.c:476
ptid_t pid_to_ptid(int pid)
Definition: ptid.c:44
void supply_gregset(struct regcache *regcache, const gdb_gregset_t *gregsetp)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
void proc_prettyprint_why(unsigned long why, unsigned long what, int verbose)
Definition: proc-why.c:170
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
void store_waitstatus(struct target_waitstatus *ourstatus, int hoststatus)
Definition: inf-child.c:51
union target_waitstatus::@161 value
static int proc_modify_flag(procinfo *pi, long flag, long mode)
Definition: procfs.c:1283
target_xfer_status
Definition: target.h:219
sysset_t * saved_entryset
Definition: procfs.c:394
static void do_detach(int signo)
Definition: procfs.c:3154
static int proc_nsysarg(procinfo *pi)
Definition: procfs.c:1202
#define PROCFS_NOTE(X)
Definition: proc-utils.h:109
struct inferior * find_inferior_pid(int pid)
Definition: inferior.c:354
Definition: gdbtypes.h:749
int gdb_signal_to_host(enum gdb_signal)
Definition: signals.c:631
static void procfs_update_thread_list(struct target_ops *ops)
Definition: procfs.c:4650
struct cleanup * make_cleanup_close(int fd)
Definition: filestuff.c:421
int tid
Definition: procfs.c:367
enum gdb_signal gdb_signal_from_host(int)
Definition: signals.c:116
Definition: gnu-nat.c:163
enum target_xfer_status target_xfer_partial_ftype(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
void target_mourn_inferior(void)
Definition: target.c:2300
#define gdb_assert(expr)
Definition: gdb_assert.h:33
void thread_change_ptid(ptid_t old_ptid, ptid_t new_ptid)
Definition: thread.c:754
static void procfs_fetch_registers(struct target_ops *, struct regcache *, int)
Definition: procfs.c:3213
static void proc_trace_syscalls(char *args, int from_tty, int entry_or_exit, int mode)
Definition: procfs.c:5223
static sysset_t * sysset_t_alloc(procinfo *pi)
Definition: procfs.c:843
static int proc_stop_process(procinfo *pi)
Definition: procfs.c:1437
Definition: procfs.c:532
static void procfs_store_registers(struct target_ops *, struct regcache *, int)
Definition: procfs.c:3262
int fork_inferior(char *exec_file_arg, char *allargs, char **env, void(*traceme_fun)(void), void(*init_trace_fun)(int), void(*pre_trace_fun)(void), char *shell_file_arg, void(*exec_fun)(const char *file, char *const *argv, char *const *env))
Definition: fork-child.c:122
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1707
enum target_xfer_status(* to_xfer_partial)(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) TARGET_DEFAULT_RETURN(TARGET_XFER_E_IO)
Definition: target.h:724
static void unconditionally_kill_inferior(procinfo *pi)
Definition: procfs.c:4219
int regnum
Definition: aarch64-tdep.c:69
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
info_proc_what
Definition: defs.h:431
void(* to_detach)(struct target_ops *ops, const char *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:460
static sysset_t * proc_get_traced_sysentry(procinfo *pi, sysset_t *save)
Definition: procfs.c:1891
static char * procfs_make_note_section(struct target_ops *self, bfd *, int *)
Definition: procfs.c:5473
void * xmalloc(YYSIZE_T)
char *(* to_make_corefile_notes)(struct target_ops *, bfd *, int *) TARGET_DEFAULT_FUNC(dummy_make_corefile_notes)
Definition: target.h:675
CORE_ADDR gdbarch_pointer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
Definition: gdbarch.c:2481
static int proc_set_traced_sysentry(procinfo *pi, sysset_t *sysset)
Definition: procfs.c:1655
target_object
Definition: target.h:136
int pid
Definition: procfs.c:366
int target_is_pushed(struct target_ops *t)
Definition: target.c:775
int attach_flag
Definition: inferior.h:340
static int proc_wait_for_stop(procinfo *pi)
Definition: procfs.c:1474
static int proc_parent_pid(procinfo *pi)
Definition: procfs.c:2394
int ptid_get_pid(ptid_t ptid)
Definition: ptid.c:52
static int proc_delete_dead_threads(procinfo *parent, procinfo *thread, void *ignore)
Definition: procfs.c:2700
#define PROC_PRETTYFPRINT_STATUS(X, Y, Z, T)
Definition: proc-utils.h:110
int(* to_auxv_parse)(struct target_ops *ops, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) TARGET_DEFAULT_FUNC(default_auxv_parse)
Definition: target.h:784
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
static gdb_gregset_t * proc_get_gregs(procinfo *pi)
Definition: procfs.c:2176
static int proc_run_process(procinfo *pi, int step, int signo)
Definition: procfs.c:1530
static char * mappingflags(long flags)
Definition: procfs.c:5000
const char const char int
Definition: command.h:229
static int proc_clear_current_fault(procinfo *pi)
Definition: procfs.c:2026
bfd_byte gdb_byte
Definition: common-types.h:38
struct target_ops * inf_child_target(void)
Definition: inf-child.c:393
static void proc_trace_sysentry_cmd(char *args, int from_tty)
Definition: procfs.c:5243
static int proc_unset_run_on_last_close(procinfo *pi)
Definition: procfs.c:1395
ptid_t null_ptid
Definition: ptid.c:25
void(* to_fetch_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:472
static int syscall_is_lwp_exit(procinfo *pi, int scall)
Definition: procfs.c:3305
static int procfs_can_use_hw_breakpoint(struct target_ops *self, int, int, int)
Definition: procfs.c:4767
void(* to_mourn_inferior)(struct target_ops *) TARGET_DEFAULT_FUNC(default_mourn_inferior)
Definition: target.h:607
static int proc_set_held_signals(procinfo *pi, gdb_sigset_t *sighold)
Definition: procfs.c:1745
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
Definition: utils.c:979
static int proc_set_fpregs(procinfo *pi)
Definition: procfs.c:2302
int(* to_can_use_hw_breakpoint)(struct target_ops *, int, int, int) TARGET_DEFAULT_RETURN(0)
Definition: target.h:516
#define SEEK_SET
Definition: defs.h:87
static int find_memory_regions_callback(struct prmap *map, find_memory_region_ftype func, void *data)
Definition: procfs.c:4963
void prune_threads(void)
Definition: thread.c:626
int gdbarch_fp0_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:2032
Definition: procfs.c:532
void(* to_pass_signals)(struct target_ops *, int, unsigned char *TARGET_DEBUG_PRINTER(target_debug_print_signals)) TARGET_DEFAULT_IGNORE()
Definition: target.h:617
void(* to_stop)(struct target_ops *, ptid_t) TARGET_DEFAULT_IGNORE()
Definition: target.h:637
ptid_t ptid
Definition: gdbthread.h:169
static int procfs_stopped_data_address(struct target_ops *targ, CORE_ADDR *addr)
Definition: procfs.c:4822
#define START_INFERIOR_TRAPS_EXPECTED
Definition: inferior.h:265
enum target_waitkind kind
Definition: waitstatus.h:100
void(* to_kill)(struct target_ops *) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:575
static void procfs_init_inferior(struct target_ops *ops, int pid)
Definition: procfs.c:4306
struct ui_file * gdb_stderr
Definition: main.c:72
ptid_t inferior_ptid
Definition: infcmd.c:124
struct type * builtin_data_ptr
Definition: gdbtypes.h:1533
int as_fd
Definition: procfs.c:386
void detach_inferior(int pid)
Definition: inferior.c:309
static procinfo * procinfo_list
Definition: procfs.c:441
void procfs_use_watchpoints(struct target_ops *t)
Definition: procfs.c:4874
static int proc_kill(procinfo *pi, int signo)
Definition: procfs.c:2360
static long proc_flags(procinfo *pi)
Definition: procfs.c:1127
static int proc_get_nthreads(procinfo *pi)
Definition: procfs.c:2632
static int syscall_is_exec(procinfo *pi, int scall)
Definition: procfs.c:3333
int offset
Definition: agent.c:65
static int invalidate_cache(procinfo *parent, procinfo *pi, void *ptr)
Definition: procfs.c:4017
void(* to_create_inferior)(struct target_ops *, char *, char *, char **, int)
Definition: target.h:584
static int proc_set_current_signal(procinfo *pi, int signo)
Definition: procfs.c:2060
char ** gdb_buildargv(const char *s)
Definition: utils.c:3036
int line
Definition: symtab.h:1570
struct thread_suspend_state suspend
Definition: gdbthread.h:202
int parse_pid_to_attach(const char *args)
Definition: utils.c:3108
struct target_ops * procfs_target(void)
Definition: procfs.c:182
int(* to_stopped_by_watchpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:542
static void dead_procinfo(procinfo *p, char *msg, int killp)
Definition: procfs.c:804
static int open_with_retry(const char *pathname, int flags)
Definition: procfs.c:503
static void procfs_inferior_created(struct target_ops *ops, int from_tty)
Definition: procfs.c:4612
static void procfs_create_inferior(struct target_ops *, char *, char *, char **, int)
Definition: procfs.c:4528
fltset_t saved_fltset
Definition: procfs.c:390
static void proc_error(procinfo *pi, char *func, int line)
Definition: procfs.c:1030
static const int mappings[]
struct inferior * current_inferior(void)
Definition: inferior.c:57
int is_exited(ptid_t ptid)
Definition: thread.c:828
static int proc_set_watchpoint(procinfo *pi, CORE_ADDR addr, int len, int wflags)
Definition: procfs.c:2430
char * get_exec_file(int err)
Definition: corefile.c:179
static procinfo * create_procinfo(int pid, int tid)
Definition: procfs.c:680
unsigned long long ULONGEST
Definition: common-types.h:53
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:917
int to_magic
Definition: target.h:1224
static void procfs_kill_inferior(struct target_ops *ops)
Definition: procfs.c:4267
long ptid_get_lwp(ptid_t ptid)
Definition: ptid.c:60
void proc_prettyprint_flags(unsigned long flags, int verbose)
Definition: proc-flags.c:288
static int procfs_stopped_by_watchpoint(struct target_ops *ops)
Definition: procfs.c:4792
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:1998
struct sigaction gdb_sigaction_t
Definition: procfs.c:252
static int proc_set_run_on_last_close(procinfo *pi)
Definition: procfs.c:1385
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
int to_has_thread_control
Definition: target.h:656
#define MAX_PROC_NAME_SIZE
Definition: procfs.c:357
int(* to_thread_alive)(struct target_ops *, ptid_t ptid) TARGET_DEFAULT_RETURN(0)
Definition: target.h:627
void(* to_info_proc)(struct target_ops *, const char *, enum info_proc_what)
Definition: target.h:922
void(* to_attach)(struct target_ops *ops, const char *, int)
Definition: target.h:457
#define target_have_steppable_watchpoint
Definition: target.h:1849
Definition: defs.h:455
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
PROCESS_GROUP_TYPE inferior_process_group(void)
Definition: inflow.c:93
int(* to_stopped_data_address)(struct target_ops *, CORE_ADDR *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:546
void(* to_update_thread_list)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:629
static void info_proc_mappings(procinfo *pi, int summary)
Definition: procfs.c:5060
static ptid_t do_attach(ptid_t ptid)
Definition: procfs.c:3084
static void proc_untrace_sysentry_cmd(char *args, int from_tty)
Definition: procfs.c:5255
void(* to_store_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:474
int(* find_memory_region_ftype)(CORE_ADDR addr, unsigned long size, int read, int write, int exec, int modified, void *data)
Definition: defs.h:343
static void procfs_stop(struct target_ops *self, ptid_t)
Definition: procfs.c:4208
static int proc_unset_inherit_on_fork(procinfo *pi)
Definition: procfs.c:1406
static int find_signalled_thread(struct thread_info *info, void *data)
Definition: fbsd-tdep.c:32
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
gdb_fpregset_t fpregset
Definition: procfs.c:399
void gdbarch_address_to_pointer(struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
Definition: gdbarch.c:2498
struct breakpoint * create_and_insert_solib_event_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: breakpoint.c:7729
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:873
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1818
static int procfs_set_watchpoint(ptid_t ptid, CORE_ADDR addr, int len, int rwflag, int after)
Definition: procfs.c:4709
prstatus_t gdb_lwpstatus_t
Definition: procfs.c:361
int print_thread_events
Definition: thread.c:1653
static void proc_trace_syscalls_1(procinfo *pi, int syscallnum, int entry_or_exit, int mode, int from_tty)
Definition: procfs.c:5192
static void proc_trace_sysexit_cmd(char *args, int from_tty)
Definition: procfs.c:5249
struct target_ops * beneath
Definition: target.h:431
static int proc_update_threads(procinfo *pi)
Definition: procfs.c:2845
void inferior_appeared(struct inferior *inf, int pid)
Definition: inferior.c:320
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
static fltset_t * proc_get_traced_faults(procinfo *pi, fltset_t *save)
Definition: procfs.c:1855
target_xfer_partial_ftype memory_xfer_auxv
#define gdb_prdelsysset
Definition: procfs.c:289
void supply_fpregset(struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
prstatus_t gdb_prstatus_t
Definition: procfs.c:360
const ULONGEST const LONGEST len
Definition: target.h:309
static int proc_find_memory_regions(struct target_ops *self, find_memory_region_ftype, void *)
Definition: procfs.c:4988
char pathname[MAX_PROC_NAME_SIZE]
Definition: procfs.c:388