Fix Solaris build
[deliverable/binutils-gdb.git] / gdb / procfs.c
CommitLineData
44122162 1/* Machine independent support for Solaris /proc (process file system) for GDB.
2555fe1a 2
e2882c85 3 Copyright (C) 1999-2018 Free Software Foundation, Inc.
2555fe1a 4
c3f6f71d
JM
5 Written by Michael Snyder at Cygnus Solutions.
6 Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
c906108c 7
a9762ec7
JB
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/>. */
c906108c 22
c3f6f71d
JM
23#include "defs.h"
24#include "inferior.h"
45741a9c 25#include "infrun.h"
c3f6f71d
JM
26#include "target.h"
27#include "gdbcore.h"
65554fef 28#include "elf-bfd.h" /* for elfcore_write_* */
c3f6f71d 29#include "gdbcmd.h"
0fda6bd2 30#include "gdbthread.h"
7f7fe91e 31#include "regcache.h"
28439f5e 32#include "inf-child.h"
4fa7574e 33#include "nat/fork-inferior.h"
88fc5eb7 34#include "filestuff.h"
c906108c 35
0df8b418 36#define _STRUCTURED_PROC 1 /* Should be done by configure script. */
c906108c 37
c3f6f71d
JM
38#include <sys/procfs.h>
39#include <sys/fault.h>
40#include <sys/syscall.h>
2555fe1a 41#include "gdb_wait.h"
0fda6bd2
JM
42#include <signal.h>
43#include <ctype.h>
92107356 44#include "gdb_bfd.h"
44270758 45#include "inflow.h"
4e73f23d 46#include "auxv.h"
d1a7880c 47#include "procfs.h"
76727919 48#include "observable.h"
5dc1a704 49#include "common/scoped_fd.h"
0fda6bd2 50
77382aee
PA
51/* This module provides the interface between GDB and the
52 /proc file system, which is used on many versions of Unix
53 as a means for debuggers to control other processes.
54
77382aee
PA
55 /proc works by imitating a file system: you open a simulated file
56 that represents the process you wish to interact with, and perform
57 operations on that "file" in order to examine or change the state
58 of the other process.
59
60 The most important thing to know about /proc and this module is
61 that there are two very different interfaces to /proc:
62
63 One that uses the ioctl system call, and another that uses read
64 and write system calls.
65
44122162
RO
66 This module supports only the Solaris version of the read/write
67 interface. */
77382aee 68
c906108c 69#include <sys/types.h>
2978b111 70#include <dirent.h> /* opendir/readdir, for listing the LWP's */
c906108c 71
c3f6f71d
JM
72#include <fcntl.h> /* for O_RDONLY */
73#include <unistd.h> /* for "X_OK" */
53ce3c39 74#include <sys/stat.h> /* for struct stat */
c906108c 75
103b3ef5
MS
76/* Note: procfs-utils.h must be included after the above system header
77 files, because it redefines various system calls using macros.
78 This may be incompatible with the prototype declarations. */
79
103b3ef5
MS
80#include "proc-utils.h"
81
77382aee 82/* Prototypes for supply_gregset etc. */
c60c0f5f
MS
83#include "gregset.h"
84
c3f6f71d 85/* =================== TARGET_OPS "MODULE" =================== */
c906108c 86
77382aee 87/* This module defines the GDB target vector and its methods. */
c906108c 88
c0939df1 89static void procfs_attach (struct target_ops *, const char *, int);
70b33f19 90static void procfs_detach (struct target_ops *, inferior *, int);
28439f5e 91static void procfs_resume (struct target_ops *,
2ea28649 92 ptid_t, int, enum gdb_signal);
a14ed312 93static void procfs_files_info (struct target_ops *);
28439f5e
PA
94static void procfs_fetch_registers (struct target_ops *,
95 struct regcache *, int);
96static void procfs_store_registers (struct target_ops *,
97 struct regcache *, int);
94bedb42
TT
98static void procfs_pass_signals (struct target_ops *self,
99 int, unsigned char *);
7d85a9c0 100static void procfs_kill_inferior (struct target_ops *ops);
136d6dae 101static void procfs_mourn_inferior (struct target_ops *ops);
5f2ad7a3
RO
102static void procfs_create_inferior (struct target_ops *, const char *,
103 const std::string &, char **, int);
117de6a9 104static ptid_t procfs_wait (struct target_ops *,
4fcbb494 105 ptid_t, struct target_waitstatus *, int);
e96027e0
PA
106static enum target_xfer_status procfs_xfer_memory (gdb_byte *,
107 const gdb_byte *,
108 ULONGEST, ULONGEST,
109 ULONGEST *);
4ac248ca 110static target_xfer_partial_ftype procfs_xfer_partial;
a14ed312 111
28439f5e 112static int procfs_thread_alive (struct target_ops *ops, ptid_t);
a14ed312 113
e8032dde 114static void procfs_update_thread_list (struct target_ops *ops);
7a114964 115static const char *procfs_pid_to_str (struct target_ops *, ptid_t);
c3f6f71d 116
2e73927c
TT
117static int proc_find_memory_regions (struct target_ops *self,
118 find_memory_region_ftype, void *);
be4d1333 119
44122162
RO
120static char *procfs_make_note_section (struct target_ops *self,
121 bfd *, int *);
be4d1333 122
5461485a 123static int procfs_can_use_hw_breakpoint (struct target_ops *self,
f486487f 124 enum bptype, int, int);
1e03ad20 125
7bc112c1 126static void procfs_info_proc (struct target_ops *, const char *,
145b16a9
UW
127 enum info_proc_what);
128
c47ffbe3 129#if defined (PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
77382aee
PA
130/* When GDB is built as 64-bit application on Solaris, the auxv data
131 is presented in 64-bit format. We need to provide a custom parser
132 to handle that. */
c47ffbe3
VP
133static int
134procfs_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
77382aee 135 gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
c47ffbe3 136{
f5656ead 137 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
c47ffbe3
VP
138 gdb_byte *ptr = *readptr;
139
140 if (endptr == ptr)
141 return 0;
77382aee 142
c47ffbe3
VP
143 if (endptr - ptr < 8 * 2)
144 return -1;
145
e17a4113 146 *typep = extract_unsigned_integer (ptr, 4, byte_order);
c47ffbe3
VP
147 ptr += 8;
148 /* The size of data is always 64-bit. If the application is 32-bit,
149 it will be zero extended, as expected. */
e17a4113 150 *valp = extract_unsigned_integer (ptr, 8, byte_order);
c47ffbe3
VP
151 ptr += 8;
152
153 *readptr = ptr;
154 return 1;
155}
156#endif
157
d1a7880c 158struct target_ops *
28439f5e 159procfs_target (void)
c3f6f71d 160{
28439f5e
PA
161 struct target_ops *t = inf_child_target ();
162
77382aee
PA
163 t->to_create_inferior = procfs_create_inferior;
164 t->to_kill = procfs_kill_inferior;
165 t->to_mourn_inferior = procfs_mourn_inferior;
166 t->to_attach = procfs_attach;
167 t->to_detach = procfs_detach;
168 t->to_wait = procfs_wait;
169 t->to_resume = procfs_resume;
170 t->to_fetch_registers = procfs_fetch_registers;
171 t->to_store_registers = procfs_store_registers;
172 t->to_xfer_partial = procfs_xfer_partial;
2455069d 173 t->to_pass_signals = procfs_pass_signals;
77382aee 174 t->to_files_info = procfs_files_info;
28439f5e 175
e8032dde 176 t->to_update_thread_list = procfs_update_thread_list;
77382aee
PA
177 t->to_thread_alive = procfs_thread_alive;
178 t->to_pid_to_str = procfs_pid_to_str;
28439f5e 179
77382aee 180 t->to_has_thread_control = tc_schedlock;
28439f5e
PA
181 t->to_find_memory_regions = proc_find_memory_regions;
182 t->to_make_corefile_notes = procfs_make_note_section;
145b16a9 183 t->to_info_proc = procfs_info_proc;
c47ffbe3
VP
184
185#if defined(PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
28439f5e 186 t->to_auxv_parse = procfs_auxv_parse;
c47ffbe3
VP
187#endif
188
77382aee 189 t->to_magic = OPS_MAGIC;
28439f5e
PA
190
191 return t;
c3f6f71d 192}
c906108c 193
c3f6f71d
JM
194/* =================== END, TARGET_OPS "MODULE" =================== */
195
77382aee
PA
196/* World Unification:
197
198 Put any typedefs, defines etc. here that are required for the
199 unification of code that handles different versions of /proc. */
c3f6f71d 200
44122162
RO
201enum { READ_WATCHFLAG = WA_READ,
202 WRITE_WATCHFLAG = WA_WRITE,
203 EXEC_WATCHFLAG = WA_EXEC,
204 AFTER_WATCHFLAG = WA_TRAPAFTER
205};
c3f6f71d
JM
206
207
208/* =================== STRUCT PROCINFO "MODULE" =================== */
209
210 /* FIXME: this comment will soon be out of date W.R.T. threads. */
211
212/* The procinfo struct is a wrapper to hold all the state information
213 concerning a /proc process. There should be exactly one procinfo
214 for each process, and since GDB currently can debug only one
215 process at a time, that means there should be only one procinfo.
216 All of the LWP's of a process can be accessed indirectly thru the
217 single process procinfo.
218
219 However, against the day when GDB may debug more than one process,
220 this data structure is kept in a list (which for now will hold no
221 more than one member), and many functions will have a pointer to a
222 procinfo as an argument.
223
224 There will be a separate procinfo structure for use by the (not yet
225 implemented) "info proc" command, so that we can print useful
226 information about any random process without interfering with the
0df8b418 227 inferior's procinfo information. */
c3f6f71d 228
c3f6f71d 229/* format strings for /proc paths */
44122162
RO
230#define MAIN_PROC_NAME_FMT "/proc/%d"
231#define CTL_PROC_NAME_FMT "/proc/%d/ctl"
232#define AS_PROC_NAME_FMT "/proc/%d/as"
233#define MAP_PROC_NAME_FMT "/proc/%d/map"
234#define STATUS_PROC_NAME_FMT "/proc/%d/status"
235#define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus")
c906108c 236
c3f6f71d
JM
237typedef struct procinfo {
238 struct procinfo *next;
239 int pid; /* Process ID */
240 int tid; /* Thread/LWP id */
c906108c 241
c3f6f71d
JM
242 /* process state */
243 int was_stopped;
244 int ignore_next_sigstop;
c906108c 245
c3f6f71d 246 int ctl_fd; /* File descriptor for /proc control file */
c3f6f71d
JM
247 int status_fd; /* File descriptor for /proc status file */
248 int as_fd; /* File descriptor for /proc as file */
c906108c 249
c3f6f71d 250 char pathname[MAX_PROC_NAME_SIZE]; /* Pathname to /proc entry */
c906108c 251
c3f6f71d 252 fltset_t saved_fltset; /* Saved traced hardware fault set */
44122162
RO
253 sigset_t saved_sigset; /* Saved traced signal set */
254 sigset_t saved_sighold; /* Saved held signal set */
37de36c6
KB
255 sysset_t *saved_exitset; /* Saved traced system call exit set */
256 sysset_t *saved_entryset; /* Saved traced system call entry set */
c906108c 257
44122162 258 pstatus_t prstatus; /* Current process status info */
19958708 259
c3f6f71d 260 struct procinfo *thread_list;
c906108c 261
c3f6f71d
JM
262 int status_valid : 1;
263 int gregs_valid : 1;
264 int fpregs_valid : 1;
265 int threads_valid: 1;
266} procinfo;
c906108c 267
c3f6f71d 268static char errmsg[128]; /* shared error msg buffer */
c906108c 269
c3f6f71d 270/* Function prototypes for procinfo module: */
c906108c 271
a14ed312
KB
272static procinfo *find_procinfo_or_die (int pid, int tid);
273static procinfo *find_procinfo (int pid, int tid);
274static procinfo *create_procinfo (int pid, int tid);
44122162 275static void destroy_procinfo (procinfo *p);
004527cb 276static void do_destroy_procinfo_cleanup (void *);
44122162
RO
277static void dead_procinfo (procinfo *p, const char *msg, int killp);
278static int open_procinfo_files (procinfo *p, int which);
279static void close_procinfo_files (procinfo *p);
280static sysset_t *sysset_t_alloc (procinfo *pi);
c906108c 281
e9ef4f39 282static int iterate_over_mappings
b8edc417
JK
283 (procinfo *pi, find_memory_region_ftype child_func, void *data,
284 int (*func) (struct prmap *map, find_memory_region_ftype child_func,
77382aee 285 void *data));
e9ef4f39 286
c3f6f71d 287/* The head of the procinfo list: */
44122162 288static procinfo *procinfo_list;
c906108c 289
77382aee
PA
290/* Search the procinfo list. Return a pointer to procinfo, or NULL if
291 not found. */
c906108c 292
19958708 293static procinfo *
fba45db2 294find_procinfo (int pid, int tid)
c5aa993b 295{
c3f6f71d 296 procinfo *pi;
c906108c 297
c3f6f71d
JM
298 for (pi = procinfo_list; pi; pi = pi->next)
299 if (pi->pid == pid)
300 break;
c906108c 301
c3f6f71d
JM
302 if (pi)
303 if (tid)
304 {
305 /* Don't check threads_valid. If we're updating the
306 thread_list, we want to find whatever threads are already
307 here. This means that in general it is the caller's
308 responsibility to check threads_valid and update before
309 calling find_procinfo, if the caller wants to find a new
77382aee 310 thread. */
c3f6f71d
JM
311
312 for (pi = pi->thread_list; pi; pi = pi->next)
313 if (pi->tid == tid)
314 break;
315 }
c906108c 316
c3f6f71d
JM
317 return pi;
318}
c906108c 319
77382aee 320/* Calls find_procinfo, but errors on failure. */
c906108c 321
c3f6f71d 322static procinfo *
fba45db2 323find_procinfo_or_die (int pid, int tid)
c3f6f71d
JM
324{
325 procinfo *pi = find_procinfo (pid, tid);
c906108c 326
c3f6f71d 327 if (pi == NULL)
0fda6bd2
JM
328 {
329 if (tid)
3e43a32a
MS
330 error (_("procfs: couldn't find pid %d "
331 "(kernel thread %d) in procinfo list."),
0fda6bd2
JM
332 pid, tid);
333 else
8a3fe4f8 334 error (_("procfs: couldn't find pid %d in procinfo list."), pid);
0fda6bd2 335 }
c3f6f71d
JM
336 return pi;
337}
c906108c 338
77382aee
PA
339/* Wrapper for `open'. The appropriate open call is attempted; if
340 unsuccessful, it will be retried as many times as needed for the
341 EAGAIN and EINTR conditions.
19958708 342
77382aee
PA
343 For other conditions, retry the open a limited number of times. In
344 addition, a short sleep is imposed prior to retrying the open. The
345 reason for this sleep is to give the kernel a chance to catch up
346 and create the file in question in the event that GDB "wins" the
347 race to open a file before the kernel has created it. */
19958708 348
4d1bcd09
KB
349static int
350open_with_retry (const char *pathname, int flags)
351{
352 int retries_remaining, status;
353
354 retries_remaining = 2;
355
356 while (1)
357 {
358 status = open (pathname, flags);
359
360 if (status >= 0 || retries_remaining == 0)
361 break;
362 else if (errno != EINTR && errno != EAGAIN)
363 {
364 retries_remaining--;
365 sleep (1);
366 }
367 }
368
369 return status;
370}
371
44122162
RO
372/* Open the file descriptor for the process or LWP. We only open the
373 control file descriptor; the others are opened lazily as needed.
77382aee 374 Returns the file descriptor, or zero for failure. */
c906108c 375
c3f6f71d 376enum { FD_CTL, FD_STATUS, FD_AS };
c906108c 377
c3f6f71d 378static int
fba45db2 379open_procinfo_files (procinfo *pi, int which)
c3f6f71d
JM
380{
381 char tmp[MAX_PROC_NAME_SIZE];
382 int fd;
383
77382aee
PA
384 /* This function is getting ALMOST long enough to break up into
385 several. Here is some rationale:
386
77382aee
PA
387 There are several file descriptors that may need to be open
388 for any given process or LWP. The ones we're intereted in are:
389 - control (ctl) write-only change the state
390 - status (status) read-only query the state
391 - address space (as) read/write access memory
392 - map (map) read-only virtual addr map
393 Most of these are opened lazily as they are needed.
394 The pathnames for the 'files' for an LWP look slightly
395 different from those of a first-class process:
396 Pathnames for a process (<proc-id>):
397 /proc/<proc-id>/ctl
398 /proc/<proc-id>/status
399 /proc/<proc-id>/as
400 /proc/<proc-id>/map
401 Pathnames for an LWP (lwp-id):
402 /proc/<proc-id>/lwp/<lwp-id>/lwpctl
403 /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
404 An LWP has no map or address space file descriptor, since
44122162
RO
405 the memory map and address space are shared by all LWPs. */
406
77382aee
PA
407 /* In this case, there are several different file descriptors that
408 we might be asked to open. The control file descriptor will be
409 opened early, but the others will be opened lazily as they are
410 needed. */
c3f6f71d
JM
411
412 strcpy (tmp, pi->pathname);
0df8b418 413 switch (which) { /* Which file descriptor to open? */
c3f6f71d
JM
414 case FD_CTL:
415 if (pi->tid)
416 strcat (tmp, "/lwpctl");
417 else
418 strcat (tmp, "/ctl");
4d1bcd09 419 fd = open_with_retry (tmp, O_WRONLY);
e28cade7 420 if (fd < 0)
c3f6f71d
JM
421 return 0; /* fail */
422 pi->ctl_fd = fd;
423 break;
424 case FD_AS:
425 if (pi->tid)
0df8b418 426 return 0; /* There is no 'as' file descriptor for an lwp. */
c3f6f71d 427 strcat (tmp, "/as");
4d1bcd09 428 fd = open_with_retry (tmp, O_RDWR);
e28cade7 429 if (fd < 0)
c3f6f71d
JM
430 return 0; /* fail */
431 pi->as_fd = fd;
432 break;
433 case FD_STATUS:
434 if (pi->tid)
435 strcat (tmp, "/lwpstatus");
436 else
437 strcat (tmp, "/status");
4d1bcd09 438 fd = open_with_retry (tmp, O_RDONLY);
e28cade7 439 if (fd < 0)
c3f6f71d
JM
440 return 0; /* fail */
441 pi->status_fd = fd;
442 break;
443 default:
444 return 0; /* unknown file descriptor */
445 }
c906108c 446
c3f6f71d
JM
447 return 1; /* success */
448}
c906108c 449
77382aee
PA
450/* Allocate a data structure and link it into the procinfo list.
451 First tries to find a pre-existing one (FIXME: why?). Returns the
452 pointer to new procinfo struct. */
c906108c 453
c3f6f71d 454static procinfo *
fba45db2 455create_procinfo (int pid, int tid)
c3f6f71d 456{
0b62613e 457 procinfo *pi, *parent = NULL;
c906108c 458
0d06e24b 459 if ((pi = find_procinfo (pid, tid)))
0df8b418 460 return pi; /* Already exists, nothing to do. */
c906108c 461
0df8b418 462 /* Find parent before doing malloc, to save having to cleanup. */
c3f6f71d
JM
463 if (tid != 0)
464 parent = find_procinfo_or_die (pid, 0); /* FIXME: should I
465 create it if it
0df8b418 466 doesn't exist yet? */
c906108c 467
8d749320 468 pi = XNEW (procinfo);
c3f6f71d
JM
469 memset (pi, 0, sizeof (procinfo));
470 pi->pid = pid;
471 pi->tid = tid;
c906108c 472
1d5e0602
KB
473 pi->saved_entryset = sysset_t_alloc (pi);
474 pi->saved_exitset = sysset_t_alloc (pi);
475
c3f6f71d
JM
476 /* Chain into list. */
477 if (tid == 0)
478 {
479 sprintf (pi->pathname, MAIN_PROC_NAME_FMT, pid);
480 pi->next = procinfo_list;
481 procinfo_list = pi;
482 }
483 else
484 {
c3f6f71d 485 sprintf (pi->pathname, "/proc/%05d/lwp/%d", pid, tid);
c3f6f71d
JM
486 pi->next = parent->thread_list;
487 parent->thread_list = pi;
488 }
489 return pi;
490}
c906108c 491
77382aee 492/* Close all file descriptors associated with the procinfo. */
c906108c 493
c3f6f71d 494static void
fba45db2 495close_procinfo_files (procinfo *pi)
c3f6f71d
JM
496{
497 if (pi->ctl_fd > 0)
498 close (pi->ctl_fd);
c3f6f71d
JM
499 if (pi->as_fd > 0)
500 close (pi->as_fd);
501 if (pi->status_fd > 0)
502 close (pi->status_fd);
c3f6f71d
JM
503 pi->ctl_fd = pi->as_fd = pi->status_fd = 0;
504}
c906108c 505
77382aee 506/* Destructor function. Close, unlink and deallocate the object. */
c906108c 507
c3f6f71d 508static void
fba45db2 509destroy_one_procinfo (procinfo **list, procinfo *pi)
c3f6f71d
JM
510{
511 procinfo *ptr;
512
77382aee 513 /* Step one: unlink the procinfo from its list. */
c3f6f71d
JM
514 if (pi == *list)
515 *list = pi->next;
19958708 516 else
c3f6f71d
JM
517 for (ptr = *list; ptr; ptr = ptr->next)
518 if (ptr->next == pi)
519 {
520 ptr->next = pi->next;
521 break;
522 }
7a292a7a 523
77382aee 524 /* Step two: close any open file descriptors. */
c3f6f71d 525 close_procinfo_files (pi);
7a292a7a 526
77382aee 527 /* Step three: free the memory. */
1d5e0602
KB
528 xfree (pi->saved_entryset);
529 xfree (pi->saved_exitset);
b8c9b27d 530 xfree (pi);
c3f6f71d 531}
c906108c 532
c3f6f71d 533static void
fba45db2 534destroy_procinfo (procinfo *pi)
c3f6f71d
JM
535{
536 procinfo *tmp;
c906108c 537
0df8b418 538 if (pi->tid != 0) /* Destroy a thread procinfo. */
c3f6f71d 539 {
0df8b418 540 tmp = find_procinfo (pi->pid, 0); /* Find the parent process. */
c3f6f71d
JM
541 destroy_one_procinfo (&tmp->thread_list, pi);
542 }
0df8b418 543 else /* Destroy a process procinfo and all its threads. */
c3f6f71d
JM
544 {
545 /* First destroy the children, if any; */
546 while (pi->thread_list != NULL)
547 destroy_one_procinfo (&pi->thread_list, pi->thread_list);
548 /* Then destroy the parent. Genocide!!! */
549 destroy_one_procinfo (&procinfo_list, pi);
550 }
551}
c906108c 552
004527cb
AC
553static void
554do_destroy_procinfo_cleanup (void *pi)
555{
b196bc4c 556 destroy_procinfo ((procinfo *) pi);
004527cb
AC
557}
558
c3f6f71d 559enum { NOKILL, KILL };
c906108c 560
77382aee
PA
561/* To be called on a non_recoverable error for a procinfo. Prints
562 error messages, optionally sends a SIGKILL to the process, then
563 destroys the data structure. */
c906108c 564
c3f6f71d 565static void
995816ba 566dead_procinfo (procinfo *pi, const char *msg, int kill_p)
c3f6f71d
JM
567{
568 char procfile[80];
c906108c 569
c3f6f71d
JM
570 if (pi->pathname)
571 {
572 print_sys_errmsg (pi->pathname, errno);
573 }
574 else
575 {
576 sprintf (procfile, "process %d", pi->pid);
577 print_sys_errmsg (procfile, errno);
578 }
579 if (kill_p == KILL)
580 kill (pi->pid, SIGKILL);
c906108c 581
c3f6f71d 582 destroy_procinfo (pi);
0b62613e 583 error ("%s", msg);
c3f6f71d 584}
c906108c 585
77382aee 586/* Allocate and (partially) initialize a sysset_t struct. */
37de36c6
KB
587
588static sysset_t *
44122162 589sysset_t_alloc (procinfo *pi)
37de36c6 590{
44122162 591 return (sysset_t *) xmalloc (sizeof (sysset_t));
37de36c6
KB
592}
593
c3f6f71d 594/* =================== END, STRUCT PROCINFO "MODULE" =================== */
c906108c 595
c3f6f71d 596/* =================== /proc "MODULE" =================== */
c906108c 597
77382aee
PA
598/* This "module" is the interface layer between the /proc system API
599 and the gdb target vector functions. This layer consists of access
600 functions that encapsulate each of the basic operations that we
601 need to use from the /proc API.
602
603 The main motivation for this layer is to hide the fact that there
604 are two very different implementations of the /proc API. Rather
605 than have a bunch of #ifdefs all thru the gdb target vector
606 functions, we do our best to hide them all in here. */
c906108c 607
44122162
RO
608static long proc_flags (procinfo *pi);
609static int proc_why (procinfo *pi);
610static int proc_what (procinfo *pi);
611static int proc_set_current_signal (procinfo *pi, int signo);
612static int proc_get_current_thread (procinfo *pi);
d3581e61 613static int proc_iterate_over_threads
44122162 614 (procinfo *pi,
d3581e61
JB
615 int (*func) (procinfo *, procinfo *, void *),
616 void *ptr);
617
618static void
995816ba 619proc_warn (procinfo *pi, const char *func, int line)
c3f6f71d
JM
620{
621 sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
622 print_sys_errmsg (errmsg, errno);
623}
c906108c 624
d3581e61 625static void
995816ba 626proc_error (procinfo *pi, const char *func, int line)
c3f6f71d
JM
627{
628 sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
629 perror_with_name (errmsg);
630}
c906108c 631
77382aee
PA
632/* Updates the status struct in the procinfo. There is a 'valid'
633 flag, to let other functions know when this function needs to be
634 called (so the status is only read when it is needed). The status
635 file descriptor is also only opened when it is needed. Returns
636 non-zero for success, zero for failure. */
c906108c 637
d3581e61 638static int
fba45db2 639proc_get_status (procinfo *pi)
c3f6f71d 640{
0df8b418 641 /* Status file descriptor is opened "lazily". */
c3f6f71d
JM
642 if (pi->status_fd == 0 &&
643 open_procinfo_files (pi, FD_STATUS) == 0)
644 {
645 pi->status_valid = 0;
646 return 0;
647 }
c906108c 648
c3f6f71d
JM
649 if (lseek (pi->status_fd, 0, SEEK_SET) < 0)
650 pi->status_valid = 0; /* fail */
651 else
652 {
19958708 653 /* Sigh... I have to read a different data structure,
0df8b418 654 depending on whether this is a main process or an LWP. */
c3f6f71d 655 if (pi->tid)
19958708
RM
656 pi->status_valid = (read (pi->status_fd,
657 (char *) &pi->prstatus.pr_lwp,
c3f6f71d
JM
658 sizeof (lwpstatus_t))
659 == sizeof (lwpstatus_t));
660 else
661 {
19958708 662 pi->status_valid = (read (pi->status_fd,
c3f6f71d 663 (char *) &pi->prstatus,
44122162
RO
664 sizeof (pstatus_t))
665 == sizeof (pstatus_t));
c3f6f71d
JM
666 }
667 }
c906108c 668
c3f6f71d
JM
669 if (pi->status_valid)
670 {
19958708 671 PROC_PRETTYFPRINT_STATUS (proc_flags (pi),
c3f6f71d 672 proc_why (pi),
19958708 673 proc_what (pi),
c3f6f71d
JM
674 proc_get_current_thread (pi));
675 }
c906108c 676
77382aee 677 /* The status struct includes general regs, so mark them valid too. */
c3f6f71d 678 pi->gregs_valid = pi->status_valid;
77382aee
PA
679 /* In the read/write multiple-fd model, the status struct includes
680 the fp regs too, so mark them valid too. */
c3f6f71d 681 pi->fpregs_valid = pi->status_valid;
77382aee 682 return pi->status_valid; /* True if success, false if failure. */
c3f6f71d 683}
c906108c 684
77382aee 685/* Returns the process flags (pr_flags field). */
c3f6f71d 686
d3581e61 687static long
fba45db2 688proc_flags (procinfo *pi)
c3f6f71d
JM
689{
690 if (!pi->status_valid)
691 if (!proc_get_status (pi))
0df8b418 692 return 0; /* FIXME: not a good failure value (but what is?) */
c906108c 693
c3f6f71d 694 return pi->prstatus.pr_lwp.pr_flags;
c3f6f71d 695}
c906108c 696
77382aee 697/* Returns the pr_why field (why the process stopped). */
c906108c 698
d3581e61 699static int
fba45db2 700proc_why (procinfo *pi)
c3f6f71d
JM
701{
702 if (!pi->status_valid)
703 if (!proc_get_status (pi))
0df8b418 704 return 0; /* FIXME: not a good failure value (but what is?) */
c906108c 705
c3f6f71d 706 return pi->prstatus.pr_lwp.pr_why;
c3f6f71d 707}
c906108c 708
77382aee 709/* Returns the pr_what field (details of why the process stopped). */
c906108c 710
d3581e61 711static int
fba45db2 712proc_what (procinfo *pi)
c3f6f71d
JM
713{
714 if (!pi->status_valid)
715 if (!proc_get_status (pi))
0df8b418 716 return 0; /* FIXME: not a good failure value (but what is?) */
c906108c 717
c3f6f71d 718 return pi->prstatus.pr_lwp.pr_what;
c3f6f71d 719}
c906108c 720
77382aee
PA
721/* This function is only called when PI is stopped by a watchpoint.
722 Assuming the OS supports it, write to *ADDR the data address which
723 triggered it and return 1. Return 0 if it is not possible to know
724 the address. */
bf701c2c
PM
725
726static int
727proc_watchpoint_address (procinfo *pi, CORE_ADDR *addr)
728{
729 if (!pi->status_valid)
730 if (!proc_get_status (pi))
731 return 0;
732
f5656ead
TT
733 *addr = (CORE_ADDR) gdbarch_pointer_to_address (target_gdbarch (),
734 builtin_type (target_gdbarch ())->builtin_data_ptr,
bf701c2c 735 (gdb_byte *) &pi->prstatus.pr_lwp.pr_info.si_addr);
bf701c2c
PM
736 return 1;
737}
738
77382aee
PA
739/* Returns the pr_nsysarg field (number of args to the current
740 syscall). */
c3f6f71d 741
d3581e61 742static int
fba45db2 743proc_nsysarg (procinfo *pi)
c3f6f71d
JM
744{
745 if (!pi->status_valid)
746 if (!proc_get_status (pi))
747 return 0;
19958708 748
c3f6f71d 749 return pi->prstatus.pr_lwp.pr_nsysarg;
c3f6f71d 750}
c906108c 751
77382aee
PA
752/* Returns the pr_sysarg field (pointer to the arguments of current
753 syscall). */
c906108c 754
d3581e61 755static long *
fba45db2 756proc_sysargs (procinfo *pi)
c3f6f71d
JM
757{
758 if (!pi->status_valid)
759 if (!proc_get_status (pi))
760 return NULL;
19958708 761
c3f6f71d 762 return (long *) &pi->prstatus.pr_lwp.pr_sysarg;
c3f6f71d 763}
77382aee 764
44122162 765/* Set or reset any of the following process flags:
77382aee
PA
766 PR_FORK -- forked child will inherit trace flags
767 PR_RLC -- traced process runs when last /proc file closed.
768 PR_KLC -- traced process is killed when last /proc file closed.
769 PR_ASYNC -- LWP's get to run/stop independently.
770
44122162 771 This function is done using read/write [PCSET/PCRESET/PCUNSET].
77382aee
PA
772
773 Arguments:
774 pi -- the procinfo
775 flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
776 mode -- 1 for set, 0 for reset.
777
778 Returns non-zero for success, zero for failure. */
c906108c 779
c3f6f71d 780enum { FLAG_RESET, FLAG_SET };
c906108c 781
c3f6f71d 782static int
fba45db2 783proc_modify_flag (procinfo *pi, long flag, long mode)
c3f6f71d
JM
784{
785 long win = 0; /* default to fail */
786
77382aee
PA
787 /* These operations affect the process as a whole, and applying them
788 to an individual LWP has the same meaning as applying them to the
789 main process. Therefore, if we're ever called with a pointer to
790 an LWP's procinfo, let's substitute the process's procinfo and
791 avoid opening the LWP's file descriptor unnecessarily. */
c3f6f71d
JM
792
793 if (pi->pid != 0)
794 pi = find_procinfo_or_die (pi->pid, 0);
795
44122162 796 procfs_ctl_t arg[2];
c5aa993b 797
44122162
RO
798 if (mode == FLAG_SET) /* Set the flag (RLC, FORK, or ASYNC). */
799 arg[0] = PCSET;
0df8b418 800 else /* Reset the flag. */
44122162
RO
801 arg[0] = PCUNSET;
802
803 arg[1] = flag;
804 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
c906108c 805
77382aee
PA
806 /* The above operation renders the procinfo's cached pstatus
807 obsolete. */
c3f6f71d 808 pi->status_valid = 0;
c906108c 809
c3f6f71d 810 if (!win)
8a3fe4f8 811 warning (_("procfs: modify_flag failed to turn %s %s"),
c3f6f71d
JM
812 flag == PR_FORK ? "PR_FORK" :
813 flag == PR_RLC ? "PR_RLC" :
c3f6f71d 814 flag == PR_ASYNC ? "PR_ASYNC" :
0d06e24b 815 flag == PR_KLC ? "PR_KLC" :
c3f6f71d
JM
816 "<unknown flag>",
817 mode == FLAG_RESET ? "off" : "on");
c906108c 818
c3f6f71d
JM
819 return win;
820}
c906108c 821
77382aee
PA
822/* Set the run_on_last_close flag. Process with all threads will
823 become runnable when debugger closes all /proc fds. Returns
824 non-zero for success, zero for failure. */
c906108c 825
d3581e61 826static int
fba45db2 827proc_set_run_on_last_close (procinfo *pi)
c906108c 828{
c3f6f71d
JM
829 return proc_modify_flag (pi, PR_RLC, FLAG_SET);
830}
c906108c 831
77382aee
PA
832/* Reset the run_on_last_close flag. The process will NOT become
833 runnable when debugger closes its file handles. Returns non-zero
834 for success, zero for failure. */
c906108c 835
d3581e61 836static int
fba45db2 837proc_unset_run_on_last_close (procinfo *pi)
c3f6f71d
JM
838{
839 return proc_modify_flag (pi, PR_RLC, FLAG_RESET);
c906108c
SS
840}
841
77382aee
PA
842/* Reset inherit_on_fork flag. If the process forks a child while we
843 are registered for events in the parent, then we will NOT recieve
844 events from the child. Returns non-zero for success, zero for
845 failure. */
c906108c 846
d3581e61 847static int
fba45db2 848proc_unset_inherit_on_fork (procinfo *pi)
c3f6f71d
JM
849{
850 return proc_modify_flag (pi, PR_FORK, FLAG_RESET);
851}
c906108c 852
77382aee
PA
853/* Set PR_ASYNC flag. If one LWP stops because of a debug event
854 (signal etc.), the remaining LWPs will continue to run. Returns
855 non-zero for success, zero for failure. */
c906108c 856
d3581e61 857static int
fba45db2 858proc_set_async (procinfo *pi)
c3f6f71d
JM
859{
860 return proc_modify_flag (pi, PR_ASYNC, FLAG_SET);
861}
c906108c 862
77382aee
PA
863/* Reset PR_ASYNC flag. If one LWP stops because of a debug event
864 (signal etc.), then all other LWPs will stop as well. Returns
865 non-zero for success, zero for failure. */
c906108c 866
d3581e61 867static int
fba45db2 868proc_unset_async (procinfo *pi)
c3f6f71d
JM
869{
870 return proc_modify_flag (pi, PR_ASYNC, FLAG_RESET);
871}
c906108c 872
77382aee
PA
873/* Request the process/LWP to stop. Does not wait. Returns non-zero
874 for success, zero for failure. */
c906108c 875
d3581e61 876static int
fba45db2 877proc_stop_process (procinfo *pi)
c3f6f71d
JM
878{
879 int win;
c906108c 880
77382aee
PA
881 /* We might conceivably apply this operation to an LWP, and the
882 LWP's ctl file descriptor might not be open. */
c906108c 883
c3f6f71d
JM
884 if (pi->ctl_fd == 0 &&
885 open_procinfo_files (pi, FD_CTL) == 0)
886 return 0;
887 else
888 {
37de36c6 889 procfs_ctl_t cmd = PCSTOP;
f4a14ae6 890
c3f6f71d 891 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
c3f6f71d 892 }
c906108c 893
c3f6f71d
JM
894 return win;
895}
c5aa993b 896
77382aee
PA
897/* Wait for the process or LWP to stop (block until it does). Returns
898 non-zero for success, zero for failure. */
c906108c 899
d3581e61 900static int
fba45db2 901proc_wait_for_stop (procinfo *pi)
c906108c 902{
c3f6f71d
JM
903 int win;
904
77382aee
PA
905 /* We should never have to apply this operation to any procinfo
906 except the one for the main process. If that ever changes for
907 any reason, then take out the following clause and replace it
908 with one that makes sure the ctl_fd is open. */
19958708 909
c3f6f71d
JM
910 if (pi->tid != 0)
911 pi = find_procinfo_or_die (pi->pid, 0);
912
44122162 913 procfs_ctl_t cmd = PCWSTOP;
f4a14ae6 914
44122162
RO
915 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
916 /* We been runnin' and we stopped -- need to update status. */
917 pi->status_valid = 0;
c906108c 918
c3f6f71d 919 return win;
c906108c
SS
920}
921
77382aee
PA
922/* Make the process or LWP runnable.
923
924 Options (not all are implemented):
925 - single-step
926 - clear current fault
927 - clear current signal
928 - abort the current system call
929 - stop as soon as finished with system call
930 - (ioctl): set traced signal set
931 - (ioctl): set held signal set
932 - (ioctl): set traced fault set
933 - (ioctl): set start pc (vaddr)
934
935 Always clears the current fault. PI is the process or LWP to
936 operate on. If STEP is true, set the process or LWP to trap after
937 one instruction. If SIGNO is zero, clear the current signal if
938 any; if non-zero, set the current signal to this one. Returns
939 non-zero for success, zero for failure. */
c3f6f71d 940
d3581e61 941static int
fba45db2 942proc_run_process (procinfo *pi, int step, int signo)
c3f6f71d
JM
943{
944 int win;
945 int runflags;
946
77382aee
PA
947 /* We will probably have to apply this operation to individual
948 threads, so make sure the control file descriptor is open. */
19958708 949
c3f6f71d
JM
950 if (pi->ctl_fd == 0 &&
951 open_procinfo_files (pi, FD_CTL) == 0)
952 {
953 return 0;
954 }
c906108c 955
0df8b418 956 runflags = PRCFAULT; /* Always clear current fault. */
c3f6f71d
JM
957 if (step)
958 runflags |= PRSTEP;
959 if (signo == 0)
960 runflags |= PRCSIG;
0df8b418 961 else if (signo != -1) /* -1 means do nothing W.R.T. signals. */
c3f6f71d 962 proc_set_current_signal (pi, signo);
c5aa993b 963
44122162 964 procfs_ctl_t cmd[2];
c906108c 965
44122162
RO
966 cmd[0] = PCRUN;
967 cmd[1] = runflags;
968 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
c906108c 969
c3f6f71d
JM
970 return win;
971}
c906108c 972
77382aee
PA
973/* Register to trace signals in the process or LWP. Returns non-zero
974 for success, zero for failure. */
c906108c 975
d3581e61 976static int
44122162 977proc_set_traced_signals (procinfo *pi, sigset_t *sigset)
c906108c 978{
c3f6f71d
JM
979 int win;
980
77382aee
PA
981 /* We should never have to apply this operation to any procinfo
982 except the one for the main process. If that ever changes for
983 any reason, then take out the following clause and replace it
984 with one that makes sure the ctl_fd is open. */
19958708 985
c3f6f71d
JM
986 if (pi->tid != 0)
987 pi = find_procinfo_or_die (pi->pid, 0);
988
44122162
RO
989 struct {
990 procfs_ctl_t cmd;
991 /* Use char array to avoid alignment issues. */
992 char sigset[sizeof (sigset_t)];
993 } arg;
c906108c 994
44122162
RO
995 arg.cmd = PCSTRACE;
996 memcpy (&arg.sigset, sigset, sizeof (sigset_t));
997
998 win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
c906108c 999
0df8b418 1000 /* The above operation renders the procinfo's cached pstatus obsolete. */
c3f6f71d 1001 pi->status_valid = 0;
c906108c 1002
c3f6f71d 1003 if (!win)
8a3fe4f8 1004 warning (_("procfs: set_traced_signals failed"));
c3f6f71d 1005 return win;
c906108c
SS
1006}
1007
77382aee
PA
1008/* Register to trace hardware faults in the process or LWP. Returns
1009 non-zero for success, zero for failure. */
c906108c 1010
d3581e61 1011static int
fba45db2 1012proc_set_traced_faults (procinfo *pi, fltset_t *fltset)
c3f6f71d
JM
1013{
1014 int win;
1015
77382aee
PA
1016 /* We should never have to apply this operation to any procinfo
1017 except the one for the main process. If that ever changes for
1018 any reason, then take out the following clause and replace it
1019 with one that makes sure the ctl_fd is open. */
19958708 1020
c3f6f71d
JM
1021 if (pi->tid != 0)
1022 pi = find_procinfo_or_die (pi->pid, 0);
1023
44122162
RO
1024 struct {
1025 procfs_ctl_t cmd;
1026 /* Use char array to avoid alignment issues. */
1027 char fltset[sizeof (fltset_t)];
1028 } arg;
1029
1030 arg.cmd = PCSFAULT;
1031 memcpy (&arg.fltset, fltset, sizeof (fltset_t));
c906108c 1032
44122162 1033 win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
c906108c 1034
0df8b418 1035 /* The above operation renders the procinfo's cached pstatus obsolete. */
c3f6f71d 1036 pi->status_valid = 0;
c906108c 1037
c3f6f71d
JM
1038 return win;
1039}
c5aa993b 1040
77382aee
PA
1041/* Register to trace entry to system calls in the process or LWP.
1042 Returns non-zero for success, zero for failure. */
c906108c 1043
d3581e61 1044static int
fba45db2 1045proc_set_traced_sysentry (procinfo *pi, sysset_t *sysset)
c906108c 1046{
c3f6f71d
JM
1047 int win;
1048
77382aee
PA
1049 /* We should never have to apply this operation to any procinfo
1050 except the one for the main process. If that ever changes for
1051 any reason, then take out the following clause and replace it
1052 with one that makes sure the ctl_fd is open. */
19958708 1053
c3f6f71d
JM
1054 if (pi->tid != 0)
1055 pi = find_procinfo_or_die (pi->pid, 0);
1056
44122162
RO
1057 struct gdb_proc_ctl_pcsentry {
1058 procfs_ctl_t cmd;
1059 /* Use char array to avoid alignment issues. */
1060 char sysset[sizeof (sysset_t)];
1061 } *argp;
1062 int argp_size = sizeof (struct gdb_proc_ctl_pcsentry);
c3f6f71d 1063
44122162 1064 argp = (struct gdb_proc_ctl_pcsentry *) xmalloc (argp_size);
c3f6f71d 1065
44122162
RO
1066 argp->cmd = PCSENTRY;
1067 memcpy (&argp->sysset, sysset, sizeof (sysset_t));
1068
1069 win = (write (pi->ctl_fd, (char *) argp, argp_size) == argp_size);
1070 xfree (argp);
37de36c6 1071
77382aee
PA
1072 /* The above operation renders the procinfo's cached pstatus
1073 obsolete. */
c3f6f71d 1074 pi->status_valid = 0;
19958708 1075
c3f6f71d 1076 return win;
c906108c
SS
1077}
1078
77382aee
PA
1079/* Register to trace exit from system calls in the process or LWP.
1080 Returns non-zero for success, zero for failure. */
c906108c 1081
d3581e61 1082static int
fba45db2 1083proc_set_traced_sysexit (procinfo *pi, sysset_t *sysset)
c3f6f71d
JM
1084{
1085 int win;
1086
77382aee
PA
1087 /* We should never have to apply this operation to any procinfo
1088 except the one for the main process. If that ever changes for
1089 any reason, then take out the following clause and replace it
1090 with one that makes sure the ctl_fd is open. */
19958708 1091
c3f6f71d
JM
1092 if (pi->tid != 0)
1093 pi = find_procinfo_or_die (pi->pid, 0);
1094
44122162
RO
1095 struct gdb_proc_ctl_pcsexit {
1096 procfs_ctl_t cmd;
1097 /* Use char array to avoid alignment issues. */
1098 char sysset[sizeof (sysset_t)];
1099 } *argp;
1100 int argp_size = sizeof (struct gdb_proc_ctl_pcsexit);
1101
1102 argp = (struct gdb_proc_ctl_pcsexit *) xmalloc (argp_size);
c906108c 1103
44122162
RO
1104 argp->cmd = PCSEXIT;
1105 memcpy (&argp->sysset, sysset, sizeof (sysset_t));
c906108c 1106
44122162
RO
1107 win = (write (pi->ctl_fd, (char *) argp, argp_size) == argp_size);
1108 xfree (argp);
37de36c6 1109
77382aee
PA
1110 /* The above operation renders the procinfo's cached pstatus
1111 obsolete. */
c3f6f71d 1112 pi->status_valid = 0;
c906108c 1113
c3f6f71d
JM
1114 return win;
1115}
c906108c 1116
77382aee
PA
1117/* Specify the set of blocked / held signals in the process or LWP.
1118 Returns non-zero for success, zero for failure. */
c906108c 1119
d3581e61 1120static int
44122162 1121proc_set_held_signals (procinfo *pi, sigset_t *sighold)
c906108c 1122{
c3f6f71d
JM
1123 int win;
1124
77382aee
PA
1125 /* We should never have to apply this operation to any procinfo
1126 except the one for the main process. If that ever changes for
1127 any reason, then take out the following clause and replace it
1128 with one that makes sure the ctl_fd is open. */
19958708 1129
c3f6f71d
JM
1130 if (pi->tid != 0)
1131 pi = find_procinfo_or_die (pi->pid, 0);
1132
44122162
RO
1133 struct {
1134 procfs_ctl_t cmd;
1135 /* Use char array to avoid alignment issues. */
1136 char hold[sizeof (sigset_t)];
1137 } arg;
1138
1139 arg.cmd = PCSHOLD;
1140 memcpy (&arg.hold, sighold, sizeof (sigset_t));
1141 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
1142
77382aee
PA
1143 /* The above operation renders the procinfo's cached pstatus
1144 obsolete. */
c3f6f71d
JM
1145 pi->status_valid = 0;
1146
1147 return win;
c906108c
SS
1148}
1149
77382aee
PA
1150/* Returns the set of signals that are held / blocked. Will also copy
1151 the sigset if SAVE is non-zero. */
c906108c 1152
44122162
RO
1153static sigset_t *
1154proc_get_held_signals (procinfo *pi, sigset_t *save)
c906108c 1155{
44122162 1156 sigset_t *ret = NULL;
c3f6f71d 1157
77382aee
PA
1158 /* We should never have to apply this operation to any procinfo
1159 except the one for the main process. If that ever changes for
1160 any reason, then take out the following clause and replace it
1161 with one that makes sure the ctl_fd is open. */
19958708 1162
c3f6f71d
JM
1163 if (pi->tid != 0)
1164 pi = find_procinfo_or_die (pi->pid, 0);
1165
c3f6f71d
JM
1166 if (!pi->status_valid)
1167 if (!proc_get_status (pi))
1168 return NULL;
1169
c3f6f71d 1170 ret = &pi->prstatus.pr_lwp.pr_lwphold;
c3f6f71d 1171 if (save && ret)
44122162 1172 memcpy (save, ret, sizeof (sigset_t));
c3f6f71d
JM
1173
1174 return ret;
c906108c
SS
1175}
1176
77382aee
PA
1177/* Returns the set of signals that are traced / debugged. Will also
1178 copy the sigset if SAVE is non-zero. */
c3f6f71d 1179
44122162
RO
1180static sigset_t *
1181proc_get_traced_signals (procinfo *pi, sigset_t *save)
c906108c 1182{
44122162 1183 sigset_t *ret = NULL;
c3f6f71d 1184
77382aee
PA
1185 /* We should never have to apply this operation to any procinfo
1186 except the one for the main process. If that ever changes for
1187 any reason, then take out the following clause and replace it
1188 with one that makes sure the ctl_fd is open. */
19958708 1189
c3f6f71d
JM
1190 if (pi->tid != 0)
1191 pi = find_procinfo_or_die (pi->pid, 0);
1192
c3f6f71d
JM
1193 if (!pi->status_valid)
1194 if (!proc_get_status (pi))
1195 return NULL;
1196
1197 ret = &pi->prstatus.pr_sigtrace;
c3f6f71d 1198 if (save && ret)
44122162 1199 memcpy (save, ret, sizeof (sigset_t));
c906108c 1200
c3f6f71d
JM
1201 return ret;
1202}
c906108c 1203
77382aee
PA
1204/* Returns the set of hardware faults that are traced /debugged. Will
1205 also copy the faultset if SAVE is non-zero. */
c3f6f71d 1206
d3581e61 1207static fltset_t *
fba45db2 1208proc_get_traced_faults (procinfo *pi, fltset_t *save)
c3f6f71d
JM
1209{
1210 fltset_t *ret = NULL;
1211
77382aee
PA
1212 /* We should never have to apply this operation to any procinfo
1213 except the one for the main process. If that ever changes for
1214 any reason, then take out the following clause and replace it
1215 with one that makes sure the ctl_fd is open. */
19958708 1216
c3f6f71d
JM
1217 if (pi->tid != 0)
1218 pi = find_procinfo_or_die (pi->pid, 0);
1219
c3f6f71d
JM
1220 if (!pi->status_valid)
1221 if (!proc_get_status (pi))
1222 return NULL;
1223
1224 ret = &pi->prstatus.pr_flttrace;
c3f6f71d
JM
1225 if (save && ret)
1226 memcpy (save, ret, sizeof (fltset_t));
c906108c 1227
c3f6f71d
JM
1228 return ret;
1229}
c906108c 1230
77382aee
PA
1231/* Returns the set of syscalls that are traced /debugged on entry.
1232 Will also copy the syscall set if SAVE is non-zero. */
c906108c 1233
d3581e61 1234static sysset_t *
fba45db2 1235proc_get_traced_sysentry (procinfo *pi, sysset_t *save)
c3f6f71d
JM
1236{
1237 sysset_t *ret = NULL;
1238
77382aee
PA
1239 /* We should never have to apply this operation to any procinfo
1240 except the one for the main process. If that ever changes for
1241 any reason, then take out the following clause and replace it
1242 with one that makes sure the ctl_fd is open. */
19958708 1243
c3f6f71d
JM
1244 if (pi->tid != 0)
1245 pi = find_procinfo_or_die (pi->pid, 0);
1246
c3f6f71d
JM
1247 if (!pi->status_valid)
1248 if (!proc_get_status (pi))
1249 return NULL;
1250
1251 ret = &pi->prstatus.pr_sysentry;
c3f6f71d 1252 if (save && ret)
44122162 1253 memcpy (save, ret, sizeof (sysset_t));
c906108c 1254
c3f6f71d
JM
1255 return ret;
1256}
c5aa993b 1257
77382aee
PA
1258/* Returns the set of syscalls that are traced /debugged on exit.
1259 Will also copy the syscall set if SAVE is non-zero. */
c906108c 1260
d3581e61 1261static sysset_t *
fba45db2 1262proc_get_traced_sysexit (procinfo *pi, sysset_t *save)
c906108c 1263{
44122162 1264 sysset_t *ret = NULL;
c3f6f71d 1265
77382aee
PA
1266 /* We should never have to apply this operation to any procinfo
1267 except the one for the main process. If that ever changes for
1268 any reason, then take out the following clause and replace it
1269 with one that makes sure the ctl_fd is open. */
19958708 1270
c3f6f71d
JM
1271 if (pi->tid != 0)
1272 pi = find_procinfo_or_die (pi->pid, 0);
1273
c3f6f71d
JM
1274 if (!pi->status_valid)
1275 if (!proc_get_status (pi))
1276 return NULL;
1277
1278 ret = &pi->prstatus.pr_sysexit;
c3f6f71d 1279 if (save && ret)
44122162 1280 memcpy (save, ret, sizeof (sysset_t));
c3f6f71d
JM
1281
1282 return ret;
1283}
c906108c 1284
77382aee
PA
1285/* The current fault (if any) is cleared; the associated signal will
1286 not be sent to the process or LWP when it resumes. Returns
1287 non-zero for success, zero for failure. */
c906108c 1288
d3581e61 1289static int
fba45db2 1290proc_clear_current_fault (procinfo *pi)
c3f6f71d
JM
1291{
1292 int win;
1293
77382aee
PA
1294 /* We should never have to apply this operation to any procinfo
1295 except the one for the main process. If that ever changes for
1296 any reason, then take out the following clause and replace it
1297 with one that makes sure the ctl_fd is open. */
19958708 1298
c3f6f71d
JM
1299 if (pi->tid != 0)
1300 pi = find_procinfo_or_die (pi->pid, 0);
1301
44122162 1302 procfs_ctl_t cmd = PCCFAULT;
f4a14ae6 1303
44122162 1304 win = (write (pi->ctl_fd, (void *) &cmd, sizeof (cmd)) == sizeof (cmd));
c3f6f71d
JM
1305
1306 return win;
c906108c
SS
1307}
1308
77382aee
PA
1309/* Set the "current signal" that will be delivered next to the
1310 process. NOTE: semantics are different from those of KILL. This
1311 signal will be delivered to the process or LWP immediately when it
1312 is resumed (even if the signal is held/blocked); it will NOT
1313 immediately cause another event of interest, and will NOT first
1314 trap back to the debugger. Returns non-zero for success, zero for
1315 failure. */
c3f6f71d 1316
d3581e61 1317static int
fba45db2 1318proc_set_current_signal (procinfo *pi, int signo)
c3f6f71d
JM
1319{
1320 int win;
1321 struct {
37de36c6 1322 procfs_ctl_t cmd;
c3f6f71d 1323 /* Use char array to avoid alignment issues. */
44122162 1324 char sinfo[sizeof (siginfo_t)];
c3f6f71d 1325 } arg;
44122162 1326 siginfo_t mysinfo;
c162e8c9
JM
1327 ptid_t wait_ptid;
1328 struct target_waitstatus wait_status;
c3f6f71d 1329
77382aee
PA
1330 /* We should never have to apply this operation to any procinfo
1331 except the one for the main process. If that ever changes for
1332 any reason, then take out the following clause and replace it
1333 with one that makes sure the ctl_fd is open. */
19958708 1334
c3f6f71d
JM
1335 if (pi->tid != 0)
1336 pi = find_procinfo_or_die (pi->pid, 0);
1337
c3f6f71d 1338 /* The pointer is just a type alias. */
c162e8c9
JM
1339 get_last_target_status (&wait_ptid, &wait_status);
1340 if (ptid_equal (wait_ptid, inferior_ptid)
1341 && wait_status.kind == TARGET_WAITKIND_STOPPED
2ea28649 1342 && wait_status.value.sig == gdb_signal_from_host (signo)
c162e8c9 1343 && proc_get_status (pi)
c162e8c9 1344 && pi->prstatus.pr_lwp.pr_info.si_signo == signo
c162e8c9
JM
1345 )
1346 /* Use the siginfo associated with the signal being
1347 redelivered. */
44122162 1348 memcpy (arg.sinfo, &pi->prstatus.pr_lwp.pr_info, sizeof (siginfo_t));
c162e8c9
JM
1349 else
1350 {
73930d4d
KH
1351 mysinfo.si_signo = signo;
1352 mysinfo.si_code = 0;
1353 mysinfo.si_pid = getpid (); /* ?why? */
1354 mysinfo.si_uid = getuid (); /* ?why? */
44122162 1355 memcpy (arg.sinfo, &mysinfo, sizeof (siginfo_t));
c162e8c9 1356 }
c3f6f71d 1357
c3f6f71d
JM
1358 arg.cmd = PCSSIG;
1359 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
c906108c 1360
c3f6f71d
JM
1361 return win;
1362}
c906108c 1363
77382aee
PA
1364/* The current signal (if any) is cleared, and is not sent to the
1365 process or LWP when it resumes. Returns non-zero for success, zero
1366 for failure. */
c906108c 1367
d3581e61 1368static int
fba45db2 1369proc_clear_current_signal (procinfo *pi)
c3f6f71d
JM
1370{
1371 int win;
1372
77382aee
PA
1373 /* We should never have to apply this operation to any procinfo
1374 except the one for the main process. If that ever changes for
1375 any reason, then take out the following clause and replace it
1376 with one that makes sure the ctl_fd is open. */
19958708 1377
c3f6f71d
JM
1378 if (pi->tid != 0)
1379 pi = find_procinfo_or_die (pi->pid, 0);
1380
44122162
RO
1381 struct {
1382 procfs_ctl_t cmd;
1383 /* Use char array to avoid alignment issues. */
1384 char sinfo[sizeof (siginfo_t)];
1385 } arg;
1386 siginfo_t mysinfo;
1387
1388 arg.cmd = PCSSIG;
1389 /* The pointer is just a type alias. */
1390 mysinfo.si_signo = 0;
1391 mysinfo.si_code = 0;
1392 mysinfo.si_errno = 0;
1393 mysinfo.si_pid = getpid (); /* ?why? */
1394 mysinfo.si_uid = getuid (); /* ?why? */
1395 memcpy (arg.sinfo, &mysinfo, sizeof (siginfo_t));
1396
1397 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
c906108c 1398
c3f6f71d
JM
1399 return win;
1400}
c906108c 1401
772cf8be
MK
1402/* Return the general-purpose registers for the process or LWP
1403 corresponding to PI. Upon failure, return NULL. */
c906108c 1404
d3581e61 1405static gdb_gregset_t *
fba45db2 1406proc_get_gregs (procinfo *pi)
c3f6f71d
JM
1407{
1408 if (!pi->status_valid || !pi->gregs_valid)
1409 if (!proc_get_status (pi))
1410 return NULL;
1411
c3f6f71d 1412 return &pi->prstatus.pr_lwp.pr_reg;
c3f6f71d 1413}
c5aa993b 1414
772cf8be
MK
1415/* Return the general-purpose registers for the process or LWP
1416 corresponding to PI. Upon failure, return NULL. */
c906108c 1417
d3581e61 1418static gdb_fpregset_t *
fba45db2 1419proc_get_fpregs (procinfo *pi)
c906108c 1420{
c3f6f71d
JM
1421 if (!pi->status_valid || !pi->fpregs_valid)
1422 if (!proc_get_status (pi))
1423 return NULL;
1424
c3f6f71d 1425 return &pi->prstatus.pr_lwp.pr_fpreg;
c906108c
SS
1426}
1427
772cf8be
MK
1428/* Write the general-purpose registers back to the process or LWP
1429 corresponding to PI. Return non-zero for success, zero for
1430 failure. */
c3f6f71d 1431
d3581e61 1432static int
fba45db2 1433proc_set_gregs (procinfo *pi)
c906108c 1434{
c3f6f71d
JM
1435 gdb_gregset_t *gregs;
1436 int win;
c5aa993b 1437
772cf8be
MK
1438 gregs = proc_get_gregs (pi);
1439 if (gregs == NULL)
1440 return 0; /* proc_get_regs has already warned. */
c3f6f71d 1441
772cf8be 1442 if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0)
c906108c 1443 {
c3f6f71d 1444 return 0;
c906108c 1445 }
c3f6f71d 1446 else
c906108c 1447 {
c3f6f71d 1448 struct {
37de36c6 1449 procfs_ctl_t cmd;
c3f6f71d
JM
1450 /* Use char array to avoid alignment issues. */
1451 char gregs[sizeof (gdb_gregset_t)];
1452 } arg;
1453
772cf8be 1454 arg.cmd = PCSREG;
c3f6f71d
JM
1455 memcpy (&arg.gregs, gregs, sizeof (arg.gregs));
1456 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
c906108c 1457 }
c3f6f71d 1458
772cf8be 1459 /* Policy: writing the registers invalidates our cache. */
c3f6f71d
JM
1460 pi->gregs_valid = 0;
1461 return win;
c906108c
SS
1462}
1463
772cf8be
MK
1464/* Write the floating-pointer registers back to the process or LWP
1465 corresponding to PI. Return non-zero for success, zero for
1466 failure. */
c3f6f71d 1467
d3581e61 1468static int
fba45db2 1469proc_set_fpregs (procinfo *pi)
c906108c 1470{
c3f6f71d
JM
1471 gdb_fpregset_t *fpregs;
1472 int win;
1473
772cf8be
MK
1474 fpregs = proc_get_fpregs (pi);
1475 if (fpregs == NULL)
1476 return 0; /* proc_get_fpregs has already warned. */
c5aa993b 1477
772cf8be 1478 if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0)
c906108c 1479 {
c3f6f71d 1480 return 0;
c906108c 1481 }
c3f6f71d 1482 else
c906108c 1483 {
c3f6f71d 1484 struct {
37de36c6 1485 procfs_ctl_t cmd;
c3f6f71d
JM
1486 /* Use char array to avoid alignment issues. */
1487 char fpregs[sizeof (gdb_fpregset_t)];
1488 } arg;
1489
772cf8be 1490 arg.cmd = PCSFPREG;
c3f6f71d
JM
1491 memcpy (&arg.fpregs, fpregs, sizeof (arg.fpregs));
1492 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
c906108c 1493 }
c3f6f71d 1494
772cf8be 1495 /* Policy: writing the registers invalidates our cache. */
c3f6f71d
JM
1496 pi->fpregs_valid = 0;
1497 return win;
c906108c
SS
1498}
1499
77382aee
PA
1500/* Send a signal to the proc or lwp with the semantics of "kill()".
1501 Returns non-zero for success, zero for failure. */
c906108c 1502
d3581e61 1503static int
fba45db2 1504proc_kill (procinfo *pi, int signo)
c3f6f71d
JM
1505{
1506 int win;
c906108c 1507
77382aee
PA
1508 /* We might conceivably apply this operation to an LWP, and the
1509 LWP's ctl file descriptor might not be open. */
c906108c 1510
c3f6f71d
JM
1511 if (pi->ctl_fd == 0 &&
1512 open_procinfo_files (pi, FD_CTL) == 0)
1513 {
1514 return 0;
1515 }
1516 else
1517 {
37de36c6 1518 procfs_ctl_t cmd[2];
c906108c 1519
c3f6f71d
JM
1520 cmd[0] = PCKILL;
1521 cmd[1] = signo;
1522 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
c3f6f71d 1523 }
c906108c 1524
c3f6f71d
JM
1525 return win;
1526}
c906108c 1527
77382aee
PA
1528/* Find the pid of the process that started this one. Returns the
1529 parent process pid, or zero. */
c906108c 1530
d3581e61 1531static int
fba45db2 1532proc_parent_pid (procinfo *pi)
c906108c 1533{
77382aee
PA
1534 /* We should never have to apply this operation to any procinfo
1535 except the one for the main process. If that ever changes for
1536 any reason, then take out the following clause and replace it
1537 with one that makes sure the ctl_fd is open. */
19958708 1538
c3f6f71d
JM
1539 if (pi->tid != 0)
1540 pi = find_procinfo_or_die (pi->pid, 0);
1541
1542 if (!pi->status_valid)
1543 if (!proc_get_status (pi))
1544 return 0;
c5aa993b 1545
c3f6f71d
JM
1546 return pi->prstatus.pr_ppid;
1547}
1548
9a043c1d
AC
1549/* Convert a target address (a.k.a. CORE_ADDR) into a host address
1550 (a.k.a void pointer)! */
1551
1552static void *
1553procfs_address_to_host_pointer (CORE_ADDR addr)
1554{
f5656ead 1555 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
9a043c1d
AC
1556 void *ptr;
1557
4e906f53 1558 gdb_assert (sizeof (ptr) == TYPE_LENGTH (ptr_type));
f5656ead 1559 gdbarch_address_to_pointer (target_gdbarch (), ptr_type,
0b62613e 1560 (gdb_byte *) &ptr, addr);
9a043c1d
AC
1561 return ptr;
1562}
1563
a0911fd0 1564static int
fba45db2 1565proc_set_watchpoint (procinfo *pi, CORE_ADDR addr, int len, int wflags)
c3f6f71d 1566{
c3f6f71d 1567 struct {
37de36c6 1568 procfs_ctl_t cmd;
c3f6f71d
JM
1569 char watch[sizeof (prwatch_t)];
1570 } arg;
73930d4d 1571 prwatch_t pwatch;
c3f6f71d 1572
9a043c1d
AC
1573 /* NOTE: cagney/2003-02-01: Even more horrible hack. Need to
1574 convert a target address into something that can be stored in a
1575 native data structure. */
73930d4d 1576 pwatch.pr_vaddr = (uintptr_t) procfs_address_to_host_pointer (addr);
73930d4d
KH
1577 pwatch.pr_size = len;
1578 pwatch.pr_wflags = wflags;
c3f6f71d 1579 arg.cmd = PCWATCH;
73930d4d 1580 memcpy (arg.watch, &pwatch, sizeof (prwatch_t));
c3f6f71d 1581 return (write (pi->ctl_fd, &arg, sizeof (arg)) == sizeof (arg));
c906108c
SS
1582}
1583
965b60ee 1584#if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
c906108c 1585
c3f6f71d 1586#include <sys/sysi86.h>
c906108c 1587
77382aee
PA
1588/* The KEY is actually the value of the lower 16 bits of the GS
1589 register for the LWP that we're interested in. Returns the
1590 matching ssh struct (LDT entry). */
c906108c 1591
337c776f 1592static struct ssd *
fba45db2 1593proc_get_LDT_entry (procinfo *pi, int key)
c906108c 1594{
c3f6f71d 1595 static struct ssd *ldt_entry = NULL;
c3f6f71d 1596 char pathname[MAX_PROC_NAME_SIZE];
c3f6f71d
JM
1597
1598 /* Allocate space for one LDT entry.
1599 This alloc must persist, because we return a pointer to it. */
1600 if (ldt_entry == NULL)
8d749320 1601 ldt_entry = XNEW (struct ssd);
c3f6f71d
JM
1602
1603 /* Open the file descriptor for the LDT table. */
1604 sprintf (pathname, "/proc/%d/ldt", pi->pid);
5dc1a704
TT
1605 scoped_fd fd (open_with_retry (pathname, O_RDONLY));
1606 if (fd.get () < 0)
c906108c 1607 {
c3f6f71d
JM
1608 proc_warn (pi, "proc_get_LDT_entry (open)", __LINE__);
1609 return NULL;
c906108c
SS
1610 }
1611
c3f6f71d 1612 /* Now 'read' thru the table, find a match and return it. */
5dc1a704
TT
1613 while (read (fd.get (), ldt_entry, sizeof (struct ssd))
1614 == sizeof (struct ssd))
c906108c 1615 {
c3f6f71d
JM
1616 if (ldt_entry->sel == 0 &&
1617 ldt_entry->bo == 0 &&
1618 ldt_entry->acc1 == 0 &&
1619 ldt_entry->acc2 == 0)
1620 break; /* end of table */
0df8b418 1621 /* If key matches, return this entry. */
c3f6f71d 1622 if (ldt_entry->sel == key)
70b33f19 1623 return ldt_entry;
c906108c 1624 }
0df8b418 1625 /* Loop ended, match not found. */
c3f6f71d 1626 return NULL;
c3f6f71d 1627}
c906108c 1628
77382aee 1629/* Returns the pointer to the LDT entry of PTID. */
965b60ee
JB
1630
1631struct ssd *
1632procfs_find_LDT_entry (ptid_t ptid)
1633{
1634 gdb_gregset_t *gregs;
1635 int key;
1636 procinfo *pi;
1637
0df8b418 1638 /* Find procinfo for the lwp. */
dfd4cc63 1639 if ((pi = find_procinfo (ptid_get_pid (ptid), ptid_get_lwp (ptid))) == NULL)
965b60ee 1640 {
0b62613e 1641 warning (_("procfs_find_LDT_entry: could not find procinfo for %d:%ld."),
dfd4cc63 1642 ptid_get_pid (ptid), ptid_get_lwp (ptid));
965b60ee
JB
1643 return NULL;
1644 }
0df8b418 1645 /* get its general registers. */
965b60ee
JB
1646 if ((gregs = proc_get_gregs (pi)) == NULL)
1647 {
0b62613e 1648 warning (_("procfs_find_LDT_entry: could not read gregs for %d:%ld."),
dfd4cc63 1649 ptid_get_pid (ptid), ptid_get_lwp (ptid));
965b60ee
JB
1650 return NULL;
1651 }
0df8b418 1652 /* Now extract the GS register's lower 16 bits. */
965b60ee
JB
1653 key = (*gregs)[GS] & 0xffff;
1654
0df8b418 1655 /* Find the matching entry and return it. */
965b60ee
JB
1656 return proc_get_LDT_entry (pi, key);
1657}
1658
1659#endif
c906108c 1660
c3f6f71d 1661/* =============== END, non-thread part of /proc "MODULE" =============== */
c906108c 1662
c3f6f71d 1663/* =================== Thread "MODULE" =================== */
c906108c 1664
44122162
RO
1665/* NOTE: you'll see more ifdefs and duplication of functions here,
1666 since there is a different way to do threads on every OS. */
c906108c 1667
44122162 1668/* Returns the number of threads for the process. */
c906108c 1669
d3581e61 1670static int
fba45db2 1671proc_get_nthreads (procinfo *pi)
c906108c 1672{
c3f6f71d
JM
1673 if (!pi->status_valid)
1674 if (!proc_get_status (pi))
1675 return 0;
c5aa993b 1676
44122162
RO
1677 /* Only works for the process procinfo, because the LWP procinfos do not
1678 get prstatus filled in. */
0df8b418 1679 if (pi->tid != 0) /* Find the parent process procinfo. */
c3f6f71d 1680 pi = find_procinfo_or_die (pi->pid, 0);
c3f6f71d 1681 return pi->prstatus.pr_nlwp;
c906108c
SS
1682}
1683
77382aee
PA
1684/* LWP version.
1685
1686 Return the ID of the thread that had an event of interest.
1687 (ie. the one that hit a breakpoint or other traced event). All
1688 other things being equal, this should be the ID of a thread that is
1689 currently executing. */
c3f6f71d 1690
d3581e61 1691static int
fba45db2 1692proc_get_current_thread (procinfo *pi)
c3f6f71d 1693{
77382aee
PA
1694 /* Note: this should be applied to the root procinfo for the
1695 process, not to the procinfo for an LWP. If applied to the
1696 procinfo for an LWP, it will simply return that LWP's ID. In
1697 that case, find the parent process procinfo. */
19958708 1698
c3f6f71d
JM
1699 if (pi->tid != 0)
1700 pi = find_procinfo_or_die (pi->pid, 0);
1701
1702 if (!pi->status_valid)
1703 if (!proc_get_status (pi))
1704 return 0;
1705
c3f6f71d 1706 return pi->prstatus.pr_lwp.pr_lwpid;
c3f6f71d
JM
1707}
1708
77382aee
PA
1709/* Discover the IDs of all the threads within the process, and create
1710 a procinfo for each of them (chained to the parent). This
1711 unfortunately requires a different method on every OS. Returns
1712 non-zero for success, zero for failure. */
c906108c 1713
a0911fd0 1714static int
fba45db2 1715proc_delete_dead_threads (procinfo *parent, procinfo *thread, void *ignore)
c3f6f71d
JM
1716{
1717 if (thread && parent) /* sanity */
c906108c 1718 {
c3f6f71d
JM
1719 thread->status_valid = 0;
1720 if (!proc_get_status (thread))
1721 destroy_one_procinfo (&parent->thread_list, thread);
1722 }
1723 return 0; /* keep iterating */
1724}
c5aa993b 1725
004527cb
AC
1726static void
1727do_closedir_cleanup (void *dir)
1728{
b196bc4c 1729 closedir ((DIR *) dir);
004527cb
AC
1730}
1731
d3581e61 1732static int
fba45db2 1733proc_update_threads (procinfo *pi)
c3f6f71d
JM
1734{
1735 char pathname[MAX_PROC_NAME_SIZE + 16];
1736 struct dirent *direntry;
1737 struct cleanup *old_chain = NULL;
1738 procinfo *thread;
1739 DIR *dirp;
1740 int lwpid;
1741
77382aee
PA
1742 /* We should never have to apply this operation to any procinfo
1743 except the one for the main process. If that ever changes for
1744 any reason, then take out the following clause and replace it
1745 with one that makes sure the ctl_fd is open. */
19958708 1746
c3f6f71d
JM
1747 if (pi->tid != 0)
1748 pi = find_procinfo_or_die (pi->pid, 0);
1749
1750 proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL);
1751
05b4bd79
PA
1752 /* Note: this brute-force method was originally devised for Unixware
1753 (support removed since), and will also work on Solaris 2.6 and
1754 2.7. The original comment mentioned the existence of a much
1755 simpler and more elegant way to do this on Solaris, but didn't
1756 point out what that was. */
c3f6f71d
JM
1757
1758 strcpy (pathname, pi->pathname);
1759 strcat (pathname, "/lwp");
1760 if ((dirp = opendir (pathname)) == NULL)
1761 proc_error (pi, "update_threads, opendir", __LINE__);
1762
004527cb 1763 old_chain = make_cleanup (do_closedir_cleanup, dirp);
c3f6f71d
JM
1764 while ((direntry = readdir (dirp)) != NULL)
1765 if (direntry->d_name[0] != '.') /* skip '.' and '..' */
1766 {
1767 lwpid = atoi (&direntry->d_name[0]);
1768 if ((thread = create_procinfo (pi->pid, lwpid)) == NULL)
1769 proc_error (pi, "update_threads, create_procinfo", __LINE__);
1770 }
1771 pi->threads_valid = 1;
1772 do_cleanups (old_chain);
1773 return 1;
1774}
c906108c 1775
77382aee
PA
1776/* Given a pointer to a function, call that function once for each lwp
1777 in the procinfo list, until the function returns non-zero, in which
1778 event return the value returned by the function.
1779
1780 Note: this function does NOT call update_threads. If you want to
1781 discover new threads first, you must call that function explicitly.
1782 This function just makes a quick pass over the currently-known
1783 procinfos.
1784
1785 PI is the parent process procinfo. FUNC is the per-thread
1786 function. PTR is an opaque parameter for function. Returns the
1787 first non-zero return value from the callee, or zero. */
c3f6f71d 1788
d3581e61 1789static int
d0849a9a
KB
1790proc_iterate_over_threads (procinfo *pi,
1791 int (*func) (procinfo *, procinfo *, void *),
1792 void *ptr)
c906108c 1793{
c3f6f71d
JM
1794 procinfo *thread, *next;
1795 int retval = 0;
c906108c 1796
77382aee
PA
1797 /* We should never have to apply this operation to any procinfo
1798 except the one for the main process. If that ever changes for
1799 any reason, then take out the following clause and replace it
1800 with one that makes sure the ctl_fd is open. */
19958708 1801
c3f6f71d
JM
1802 if (pi->tid != 0)
1803 pi = find_procinfo_or_die (pi->pid, 0);
1804
1805 for (thread = pi->thread_list; thread != NULL; thread = next)
c906108c 1806 {
0df8b418 1807 next = thread->next; /* In case thread is destroyed. */
c3f6f71d
JM
1808 if ((retval = (*func) (pi, thread, ptr)) != 0)
1809 break;
c906108c 1810 }
c3f6f71d
JM
1811
1812 return retval;
c906108c
SS
1813}
1814
c3f6f71d
JM
1815/* =================== END, Thread "MODULE" =================== */
1816
1817/* =================== END, /proc "MODULE" =================== */
1818
1819/* =================== GDB "MODULE" =================== */
1820
77382aee
PA
1821/* Here are all of the gdb target vector functions and their
1822 friends. */
c3f6f71d 1823
39f77062 1824static ptid_t do_attach (ptid_t ptid);
6bd6f3b6 1825static void do_detach ();
9185ddce 1826static void proc_trace_syscalls_1 (procinfo *pi, int syscallnum,
77382aee 1827 int entry_or_exit, int mode, int from_tty);
9185ddce 1828
77382aee
PA
1829/* Sets up the inferior to be debugged. Registers to trace signals,
1830 hardware faults, and syscalls. Note: does not set RLC flag: caller
1831 may want to customize that. Returns zero for success (note!
1832 unlike most functions in this module); on failure, returns the LINE
1833 NUMBER where it failed! */
c3f6f71d
JM
1834
1835static int
fba45db2 1836procfs_debug_inferior (procinfo *pi)
c906108c 1837{
c3f6f71d 1838 fltset_t traced_faults;
44122162 1839 sigset_t traced_signals;
37de36c6
KB
1840 sysset_t *traced_syscall_entries;
1841 sysset_t *traced_syscall_exits;
1842 int status;
c906108c 1843
0df8b418
MS
1844 /* Register to trace hardware faults in the child. */
1845 prfillset (&traced_faults); /* trace all faults... */
44122162 1846 prdelset (&traced_faults, FLTPAGE); /* except page fault. */
c3f6f71d
JM
1847 if (!proc_set_traced_faults (pi, &traced_faults))
1848 return __LINE__;
c906108c 1849
2455069d
UW
1850 /* Initially, register to trace all signals in the child. */
1851 prfillset (&traced_signals);
1852 if (!proc_set_traced_signals (pi, &traced_signals))
c3f6f71d
JM
1853 return __LINE__;
1854
37de36c6 1855
c3f6f71d 1856 /* Register to trace the 'exit' system call (on entry). */
37de36c6 1857 traced_syscall_entries = sysset_t_alloc (pi);
44122162
RO
1858 premptyset (traced_syscall_entries);
1859 praddset (traced_syscall_entries, SYS_exit);
1860 praddset (traced_syscall_entries, SYS_lwp_exit);
c906108c 1861
37de36c6
KB
1862 status = proc_set_traced_sysentry (pi, traced_syscall_entries);
1863 xfree (traced_syscall_entries);
1864 if (!status)
c3f6f71d
JM
1865 return __LINE__;
1866
44122162 1867 /* Method for tracing exec syscalls. */
c3f6f71d
JM
1868 /* GW: Rationale...
1869 Not all systems with /proc have all the exec* syscalls with the same
1870 names. On the SGI, for example, there is no SYS_exec, but there
0df8b418 1871 *is* a SYS_execv. So, we try to account for that. */
c3f6f71d 1872
37de36c6 1873 traced_syscall_exits = sysset_t_alloc (pi);
44122162 1874 premptyset (traced_syscall_exits);
c3f6f71d 1875#ifdef SYS_exec
44122162 1876 praddset (traced_syscall_exits, SYS_exec);
37de36c6 1877#endif
44122162
RO
1878 praddset (traced_syscall_exits, SYS_execve);
1879 praddset (traced_syscall_exits, SYS_lwp_create);
1880 praddset (traced_syscall_exits, SYS_lwp_exit);
c906108c 1881
37de36c6
KB
1882 status = proc_set_traced_sysexit (pi, traced_syscall_exits);
1883 xfree (traced_syscall_exits);
1884 if (!status)
c3f6f71d
JM
1885 return __LINE__;
1886
c3f6f71d 1887 return 0;
c906108c
SS
1888}
1889
19958708 1890static void
c0939df1 1891procfs_attach (struct target_ops *ops, const char *args, int from_tty)
c906108c 1892{
c3f6f71d
JM
1893 char *exec_file;
1894 int pid;
1895
74164c56 1896 pid = parse_pid_to_attach (args);
c3f6f71d 1897
c3f6f71d 1898 if (pid == getpid ())
8a3fe4f8 1899 error (_("Attaching GDB to itself is not a good idea..."));
c906108c 1900
c3f6f71d 1901 if (from_tty)
c906108c 1902 {
c3f6f71d
JM
1903 exec_file = get_exec_file (0);
1904
1905 if (exec_file)
a3f17187 1906 printf_filtered (_("Attaching to program `%s', %s\n"),
39f77062 1907 exec_file, target_pid_to_str (pid_to_ptid (pid)));
c3f6f71d 1908 else
a3f17187 1909 printf_filtered (_("Attaching to %s\n"),
77382aee 1910 target_pid_to_str (pid_to_ptid (pid)));
c3f6f71d
JM
1911
1912 fflush (stdout);
c906108c 1913 }
39f77062 1914 inferior_ptid = do_attach (pid_to_ptid (pid));
6a3cb8e8
PA
1915 if (!target_is_pushed (ops))
1916 push_target (ops);
c3f6f71d
JM
1917}
1918
19958708 1919static void
6e1e1966 1920procfs_detach (struct target_ops *ops, inferior *inf, int from_tty)
c3f6f71d 1921{
dfd4cc63 1922 int pid = ptid_get_pid (inferior_ptid);
cc377e6b 1923
c3f6f71d 1924 if (from_tty)
c906108c 1925 {
995816ba 1926 const char *exec_file;
cc377e6b 1927
c3f6f71d 1928 exec_file = get_exec_file (0);
cc377e6b 1929 if (exec_file == NULL)
c3f6f71d 1930 exec_file = "";
cc377e6b 1931
a3f17187 1932 printf_filtered (_("Detaching from program: %s, %s\n"), exec_file,
cc377e6b
MK
1933 target_pid_to_str (pid_to_ptid (pid)));
1934 gdb_flush (gdb_stdout);
c906108c 1935 }
19958708 1936
6bd6f3b6 1937 do_detach ();
cc377e6b 1938
39f77062 1939 inferior_ptid = null_ptid;
7f9f62ba 1940 detach_inferior (pid);
6a3cb8e8 1941 inf_child_maybe_unpush_target (ops);
c906108c
SS
1942}
1943
39f77062
KB
1944static ptid_t
1945do_attach (ptid_t ptid)
c906108c 1946{
c3f6f71d 1947 procinfo *pi;
181e7f93 1948 struct inferior *inf;
c3f6f71d 1949 int fail;
2689673f 1950 int lwpid;
c3f6f71d 1951
dfd4cc63 1952 if ((pi = create_procinfo (ptid_get_pid (ptid), 0)) == NULL)
8a3fe4f8 1953 perror (_("procfs: out of memory in 'attach'"));
c3f6f71d
JM
1954
1955 if (!open_procinfo_files (pi, FD_CTL))
1956 {
1957 fprintf_filtered (gdb_stderr, "procfs:%d -- ", __LINE__);
19958708 1958 sprintf (errmsg, "do_attach: couldn't open /proc file for process %d",
dfd4cc63 1959 ptid_get_pid (ptid));
c3f6f71d
JM
1960 dead_procinfo (pi, errmsg, NOKILL);
1961 }
c906108c 1962
c3f6f71d
JM
1963 /* Stop the process (if it isn't already stopped). */
1964 if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
c906108c 1965 {
c3f6f71d
JM
1966 pi->was_stopped = 1;
1967 proc_prettyprint_why (proc_why (pi), proc_what (pi), 1);
c906108c
SS
1968 }
1969 else
1970 {
c3f6f71d
JM
1971 pi->was_stopped = 0;
1972 /* Set the process to run again when we close it. */
1973 if (!proc_set_run_on_last_close (pi))
1974 dead_procinfo (pi, "do_attach: couldn't set RLC.", NOKILL);
1975
0df8b418 1976 /* Now stop the process. */
c3f6f71d
JM
1977 if (!proc_stop_process (pi))
1978 dead_procinfo (pi, "do_attach: couldn't stop the process.", NOKILL);
1979 pi->ignore_next_sigstop = 1;
c906108c 1980 }
c3f6f71d
JM
1981 /* Save some of the /proc state to be restored if we detach. */
1982 if (!proc_get_traced_faults (pi, &pi->saved_fltset))
1983 dead_procinfo (pi, "do_attach: couldn't save traced faults.", NOKILL);
1984 if (!proc_get_traced_signals (pi, &pi->saved_sigset))
1985 dead_procinfo (pi, "do_attach: couldn't save traced signals.", NOKILL);
37de36c6 1986 if (!proc_get_traced_sysentry (pi, pi->saved_entryset))
c3f6f71d
JM
1987 dead_procinfo (pi, "do_attach: couldn't save traced syscall entries.",
1988 NOKILL);
37de36c6 1989 if (!proc_get_traced_sysexit (pi, pi->saved_exitset))
19958708 1990 dead_procinfo (pi, "do_attach: couldn't save traced syscall exits.",
c3f6f71d
JM
1991 NOKILL);
1992 if (!proc_get_held_signals (pi, &pi->saved_sighold))
1993 dead_procinfo (pi, "do_attach: couldn't save held signals.", NOKILL);
1994
1995 if ((fail = procfs_debug_inferior (pi)) != 0)
1996 dead_procinfo (pi, "do_attach: failed in procfs_debug_inferior", NOKILL);
1997
6c95b8df
PA
1998 inf = current_inferior ();
1999 inferior_appeared (inf, pi->pid);
c3f6f71d 2000 /* Let GDB know that the inferior was attached. */
181e7f93 2001 inf->attach_flag = 1;
2689673f
PA
2002
2003 /* Create a procinfo for the current lwp. */
2004 lwpid = proc_get_current_thread (pi);
2005 create_procinfo (pi->pid, lwpid);
2006
2007 /* Add it to gdb's thread list. */
dfd4cc63 2008 ptid = ptid_build (pi->pid, lwpid, 0);
2689673f
PA
2009 add_thread (ptid);
2010
2011 return ptid;
c906108c
SS
2012}
2013
2014static void
6bd6f3b6 2015do_detach ()
c906108c 2016{
c3f6f71d 2017 procinfo *pi;
c906108c 2018
0df8b418 2019 /* Find procinfo for the main process. */
dfd4cc63
LM
2020 pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid),
2021 0); /* FIXME: threads */
c5aa993b 2022
c3f6f71d
JM
2023 if (!proc_set_traced_signals (pi, &pi->saved_sigset))
2024 proc_warn (pi, "do_detach, set_traced_signal", __LINE__);
c906108c 2025
c3f6f71d
JM
2026 if (!proc_set_traced_faults (pi, &pi->saved_fltset))
2027 proc_warn (pi, "do_detach, set_traced_faults", __LINE__);
2028
37de36c6 2029 if (!proc_set_traced_sysentry (pi, pi->saved_entryset))
c3f6f71d
JM
2030 proc_warn (pi, "do_detach, set_traced_sysentry", __LINE__);
2031
37de36c6 2032 if (!proc_set_traced_sysexit (pi, pi->saved_exitset))
c3f6f71d
JM
2033 proc_warn (pi, "do_detach, set_traced_sysexit", __LINE__);
2034
2035 if (!proc_set_held_signals (pi, &pi->saved_sighold))
2036 proc_warn (pi, "do_detach, set_held_signals", __LINE__);
2037
6bd6f3b6
SM
2038 if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
2039 if (!(pi->was_stopped)
2040 || query (_("Was stopped when attached, make it runnable again? ")))
c3f6f71d
JM
2041 {
2042 /* Clear any pending signal. */
2043 if (!proc_clear_current_fault (pi))
2044 proc_warn (pi, "do_detach, clear_current_fault", __LINE__);
2045
6bd6f3b6 2046 if (!proc_clear_current_signal (pi))
1a303dec
MS
2047 proc_warn (pi, "do_detach, clear_current_signal", __LINE__);
2048
c3f6f71d
JM
2049 if (!proc_set_run_on_last_close (pi))
2050 proc_warn (pi, "do_detach, set_rlc", __LINE__);
2051 }
2052
c3f6f71d 2053 destroy_procinfo (pi);
c906108c
SS
2054}
2055
772cf8be
MK
2056/* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
2057 for all registers.
2058
2059 ??? Is the following note still relevant? We can't get individual
2060 registers with the PT_GETREGS ptrace(2) request either, yet we
2061 don't bother with caching at all in that case.
2062
2063 NOTE: Since the /proc interface cannot give us individual
2064 registers, we pay no attention to REGNUM, and just fetch them all.
2065 This results in the possibility that we will do unnecessarily many
2066 fetches, since we may be called repeatedly for individual
2067 registers. So we cache the results, and mark the cache invalid
2068 when the process is resumed. */
c3f6f71d 2069
c906108c 2070static void
28439f5e
PA
2071procfs_fetch_registers (struct target_ops *ops,
2072 struct regcache *regcache, int regnum)
c906108c 2073{
772cf8be
MK
2074 gdb_gregset_t *gregs;
2075 procinfo *pi;
bcc0c096
SM
2076 ptid_t ptid = regcache_get_ptid (regcache);
2077 int pid = ptid_get_pid (ptid);
2078 int tid = ptid_get_lwp (ptid);
ac7936df 2079 struct gdbarch *gdbarch = regcache->arch ();
c3f6f71d 2080
2689673f 2081 pi = find_procinfo_or_die (pid, tid);
c3f6f71d
JM
2082
2083 if (pi == NULL)
8a3fe4f8 2084 error (_("procfs: fetch_registers failed to find procinfo for %s"),
bcc0c096 2085 target_pid_to_str (ptid));
c3f6f71d 2086
772cf8be
MK
2087 gregs = proc_get_gregs (pi);
2088 if (gregs == NULL)
c3f6f71d
JM
2089 proc_error (pi, "fetch_registers, get_gregs", __LINE__);
2090
56be3814 2091 supply_gregset (regcache, (const gdb_gregset_t *) gregs);
c3f6f71d 2092
40a6adc1 2093 if (gdbarch_fp0_regnum (gdbarch) >= 0) /* Do we have an FPU? */
60054393 2094 {
772cf8be
MK
2095 gdb_fpregset_t *fpregs;
2096
40a6adc1
MD
2097 if ((regnum >= 0 && regnum < gdbarch_fp0_regnum (gdbarch))
2098 || regnum == gdbarch_pc_regnum (gdbarch)
2099 || regnum == gdbarch_sp_regnum (gdbarch))
772cf8be 2100 return; /* Not a floating point register. */
c5aa993b 2101
772cf8be
MK
2102 fpregs = proc_get_fpregs (pi);
2103 if (fpregs == NULL)
60054393 2104 proc_error (pi, "fetch_registers, get_fpregs", __LINE__);
c906108c 2105
56be3814 2106 supply_fpregset (regcache, (const gdb_fpregset_t *) fpregs);
60054393 2107 }
c906108c
SS
2108}
2109
772cf8be
MK
2110/* Store register REGNUM back into the inferior. If REGNUM is -1, do
2111 this for all registers.
2112
2113 NOTE: Since the /proc interface will not read individual registers,
2114 we will cache these requests until the process is resumed, and only
2115 then write them back to the inferior process.
77382aee 2116
772cf8be
MK
2117 FIXME: is that a really bad idea? Have to think about cases where
2118 writing one register might affect the value of others, etc. */
c906108c 2119
c3f6f71d 2120static void
28439f5e
PA
2121procfs_store_registers (struct target_ops *ops,
2122 struct regcache *regcache, int regnum)
c3f6f71d 2123{
772cf8be
MK
2124 gdb_gregset_t *gregs;
2125 procinfo *pi;
bcc0c096
SM
2126 ptid_t ptid = regcache_get_ptid (regcache);
2127 int pid = ptid_get_pid (ptid);
2128 int tid = ptid_get_lwp (ptid);
ac7936df 2129 struct gdbarch *gdbarch = regcache->arch ();
c3f6f71d 2130
2689673f 2131 pi = find_procinfo_or_die (pid, tid);
c3f6f71d
JM
2132
2133 if (pi == NULL)
8a3fe4f8 2134 error (_("procfs: store_registers: failed to find procinfo for %s"),
bcc0c096 2135 target_pid_to_str (ptid));
c906108c 2136
772cf8be
MK
2137 gregs = proc_get_gregs (pi);
2138 if (gregs == NULL)
c3f6f71d 2139 proc_error (pi, "store_registers, get_gregs", __LINE__);
c906108c 2140
56be3814 2141 fill_gregset (regcache, gregs, regnum);
c3f6f71d
JM
2142 if (!proc_set_gregs (pi))
2143 proc_error (pi, "store_registers, set_gregs", __LINE__);
c906108c 2144
40a6adc1 2145 if (gdbarch_fp0_regnum (gdbarch) >= 0) /* Do we have an FPU? */
60054393 2146 {
772cf8be
MK
2147 gdb_fpregset_t *fpregs;
2148
40a6adc1
MD
2149 if ((regnum >= 0 && regnum < gdbarch_fp0_regnum (gdbarch))
2150 || regnum == gdbarch_pc_regnum (gdbarch)
2151 || regnum == gdbarch_sp_regnum (gdbarch))
772cf8be 2152 return; /* Not a floating point register. */
60054393 2153
772cf8be
MK
2154 fpregs = proc_get_fpregs (pi);
2155 if (fpregs == NULL)
60054393
MS
2156 proc_error (pi, "store_registers, get_fpregs", __LINE__);
2157
56be3814 2158 fill_fpregset (regcache, fpregs, regnum);
60054393
MS
2159 if (!proc_set_fpregs (pi))
2160 proc_error (pi, "store_registers, set_fpregs", __LINE__);
2161 }
c3f6f71d 2162}
c906108c 2163
37de36c6
KB
2164static int
2165syscall_is_lwp_exit (procinfo *pi, int scall)
2166{
37de36c6
KB
2167 if (scall == SYS_lwp_exit)
2168 return 1;
37de36c6
KB
2169 return 0;
2170}
2171
2172static int
2173syscall_is_exit (procinfo *pi, int scall)
2174{
37de36c6
KB
2175 if (scall == SYS_exit)
2176 return 1;
37de36c6
KB
2177 return 0;
2178}
2179
2180static int
2181syscall_is_exec (procinfo *pi, int scall)
2182{
2183#ifdef SYS_exec
2184 if (scall == SYS_exec)
2185 return 1;
2186#endif
37de36c6
KB
2187 if (scall == SYS_execve)
2188 return 1;
37de36c6
KB
2189 return 0;
2190}
2191
2192static int
2193syscall_is_lwp_create (procinfo *pi, int scall)
2194{
37de36c6
KB
2195 if (scall == SYS_lwp_create)
2196 return 1;
37de36c6
KB
2197 return 0;
2198}
2199
77382aee
PA
2200/* Retrieve the next stop event from the child process. If child has
2201 not stopped yet, wait for it to stop. Translate /proc eventcodes
2202 (or possibly wait eventcodes) into gdb internal event codes.
2203 Returns the id of process (and possibly thread) that incurred the
2204 event. Event codes are returned through a pointer parameter. */
c906108c 2205
39f77062 2206static ptid_t
117de6a9 2207procfs_wait (struct target_ops *ops,
4fcbb494 2208 ptid_t ptid, struct target_waitstatus *status, int options)
c906108c 2209{
0df8b418 2210 /* First cut: loosely based on original version 2.1. */
c3f6f71d 2211 procinfo *pi;
39f77062
KB
2212 int wstat;
2213 int temp_tid;
2214 ptid_t retval, temp_ptid;
c3f6f71d
JM
2215 int why, what, flags;
2216 int retry = 0;
c906108c 2217
c3f6f71d 2218wait_again:
c906108c 2219
c3f6f71d
JM
2220 retry++;
2221 wstat = 0;
39f77062 2222 retval = pid_to_ptid (-1);
c906108c 2223
0df8b418 2224 /* Find procinfo for main process. */
dfd4cc63 2225 pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid), 0);
c3f6f71d 2226 if (pi)
c906108c 2227 {
0df8b418 2228 /* We must assume that the status is stale now... */
c3f6f71d
JM
2229 pi->status_valid = 0;
2230 pi->gregs_valid = 0;
2231 pi->fpregs_valid = 0;
2232
0df8b418 2233#if 0 /* just try this out... */
c3f6f71d
JM
2234 flags = proc_flags (pi);
2235 why = proc_why (pi);
2236 if ((flags & PR_STOPPED) && (why == PR_REQUESTED))
0df8b418 2237 pi->status_valid = 0; /* re-read again, IMMEDIATELY... */
c3f6f71d
JM
2238#endif
2239 /* If child is not stopped, wait for it to stop. */
2240 if (!(proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) &&
2241 !proc_wait_for_stop (pi))
c906108c 2242 {
0df8b418 2243 /* wait_for_stop failed: has the child terminated? */
c3f6f71d 2244 if (errno == ENOENT)
c906108c 2245 {
39f77062
KB
2246 int wait_retval;
2247
0df8b418
MS
2248 /* /proc file not found; presumably child has terminated. */
2249 wait_retval = wait (&wstat); /* "wait" for the child's exit. */
c3f6f71d 2250
dfd4cc63
LM
2251 /* Wrong child? */
2252 if (wait_retval != ptid_get_pid (inferior_ptid))
3e43a32a
MS
2253 error (_("procfs: couldn't stop "
2254 "process %d: wait returned %d."),
dfd4cc63 2255 ptid_get_pid (inferior_ptid), wait_retval);
c3f6f71d 2256 /* FIXME: might I not just use waitpid?
0df8b418 2257 Or try find_procinfo to see if I know about this child? */
39f77062 2258 retval = pid_to_ptid (wait_retval);
c906108c 2259 }
d1566ff5
FN
2260 else if (errno == EINTR)
2261 goto wait_again;
c3f6f71d 2262 else
c906108c 2263 {
0df8b418 2264 /* Unknown error from wait_for_stop. */
c3f6f71d 2265 proc_error (pi, "target_wait (wait_for_stop)", __LINE__);
c906108c 2266 }
c3f6f71d
JM
2267 }
2268 else
2269 {
2270 /* This long block is reached if either:
2271 a) the child was already stopped, or
2272 b) we successfully waited for the child with wait_for_stop.
2273 This block will analyze the /proc status, and translate it
2274 into a waitstatus for GDB.
2275
2276 If we actually had to call wait because the /proc file
19958708 2277 is gone (child terminated), then we skip this block,
c3f6f71d
JM
2278 because we already have a waitstatus. */
2279
2280 flags = proc_flags (pi);
2281 why = proc_why (pi);
2282 what = proc_what (pi);
2283
c3f6f71d 2284 if (flags & (PR_STOPPED | PR_ISTOP))
c906108c 2285 {
c3f6f71d
JM
2286 /* If it's running async (for single_thread control),
2287 set it back to normal again. */
2288 if (flags & PR_ASYNC)
2289 if (!proc_unset_async (pi))
2290 proc_error (pi, "target_wait, unset_async", __LINE__);
c3f6f71d
JM
2291
2292 if (info_verbose)
2293 proc_prettyprint_why (why, what, 1);
2294
2295 /* The 'pid' we will return to GDB is composed of
2296 the process ID plus the lwp ID. */
dfd4cc63 2297 retval = ptid_build (pi->pid, proc_get_current_thread (pi), 0);
c3f6f71d
JM
2298
2299 switch (why) {
2300 case PR_SIGNALLED:
2301 wstat = (what << 8) | 0177;
2302 break;
2303 case PR_SYSENTRY:
37de36c6 2304 if (syscall_is_lwp_exit (pi, what))
c3f6f71d 2305 {
17faa917
DJ
2306 if (print_thread_events)
2307 printf_unfiltered (_("[%s exited]\n"),
2308 target_pid_to_str (retval));
37de36c6
KB
2309 delete_thread (retval);
2310 status->kind = TARGET_WAITKIND_SPURIOUS;
2311 return retval;
2312 }
2313 else if (syscall_is_exit (pi, what))
2314 {
181e7f93
PA
2315 struct inferior *inf;
2316
0df8b418 2317 /* Handle SYS_exit call only. */
37de36c6 2318 /* Stopped at entry to SYS_exit.
19958708 2319 Make it runnable, resume it, then use
37de36c6 2320 the wait system call to get its exit code.
19958708 2321 Proc_run_process always clears the current
37de36c6
KB
2322 fault and signal.
2323 Then return its exit status. */
2324 pi->status_valid = 0;
2325 wstat = 0;
19958708 2326 /* FIXME: what we should do is return
37de36c6
KB
2327 TARGET_WAITKIND_SPURIOUS. */
2328 if (!proc_run_process (pi, 0, 0))
2329 proc_error (pi, "target_wait, run_process", __LINE__);
181e7f93
PA
2330
2331 inf = find_inferior_pid (pi->pid);
2332 if (inf->attach_flag)
c3f6f71d 2333 {
19958708 2334 /* Don't call wait: simulate waiting for exit,
37de36c6
KB
2335 return a "success" exit code. Bogus: what if
2336 it returns something else? */
2337 wstat = 0;
39f77062 2338 retval = inferior_ptid; /* ? ? ? */
37de36c6
KB
2339 }
2340 else
2341 {
2342 int temp = wait (&wstat);
2343
2344 /* FIXME: shouldn't I make sure I get the right
2345 event from the right process? If (for
2346 instance) I have killed an earlier inferior
2347 process but failed to clean up after it
2348 somehow, I could get its termination event
2349 here. */
2350
0df8b418
MS
2351 /* If wait returns -1, that's what we return
2352 to GDB. */
37de36c6 2353 if (temp < 0)
39f77062 2354 retval = pid_to_ptid (temp);
c3f6f71d 2355 }
c3f6f71d 2356 }
37de36c6
KB
2357 else
2358 {
a3f17187 2359 printf_filtered (_("procfs: trapped on entry to "));
37de36c6
KB
2360 proc_prettyprint_syscall (proc_what (pi), 0);
2361 printf_filtered ("\n");
44122162
RO
2362
2363 long i, nsysargs, *sysargs;
2364
2365 if ((nsysargs = proc_nsysarg (pi)) > 0 &&
2366 (sysargs = proc_sysargs (pi)) != NULL)
2367 {
2368 printf_filtered (_("%ld syscall arguments:\n"),
2369 nsysargs);
2370 for (i = 0; i < nsysargs; i++)
2371 printf_filtered ("#%ld: 0x%08lx\n",
2372 i, sysargs[i]);
2373 }
2374
37de36c6
KB
2375 if (status)
2376 {
0df8b418
MS
2377 /* How to exit gracefully, returning "unknown
2378 event". */
37de36c6 2379 status->kind = TARGET_WAITKIND_SPURIOUS;
39f77062 2380 return inferior_ptid;
37de36c6
KB
2381 }
2382 else
2383 {
2384 /* How to keep going without returning to wfi: */
049a8570 2385 target_continue_no_signal (ptid);
37de36c6
KB
2386 goto wait_again;
2387 }
2388 }
2389 break;
2390 case PR_SYSEXIT:
2391 if (syscall_is_exec (pi, what))
c3f6f71d 2392 {
37de36c6
KB
2393 /* Hopefully this is our own "fork-child" execing
2394 the real child. Hoax this event into a trap, and
2395 GDB will see the child about to execute its start
0df8b418 2396 address. */
37de36c6
KB
2397 wstat = (SIGTRAP << 8) | 0177;
2398 }
2399 else if (syscall_is_lwp_create (pi, what))
2400 {
77382aee
PA
2401 /* This syscall is somewhat like fork/exec. We
2402 will get the event twice: once for the parent
2403 LWP, and once for the child. We should already
2404 know about the parent LWP, but the child will
2405 be new to us. So, whenever we get this event,
2406 if it represents a new thread, simply add the
2407 thread to the list. */
c3f6f71d 2408
37de36c6 2409 /* If not in procinfo list, add it. */
39f77062
KB
2410 temp_tid = proc_get_current_thread (pi);
2411 if (!find_procinfo (pi->pid, temp_tid))
2412 create_procinfo (pi->pid, temp_tid);
37de36c6 2413
dfd4cc63 2414 temp_ptid = ptid_build (pi->pid, temp_tid, 0);
37de36c6 2415 /* If not in GDB's thread list, add it. */
39f77062 2416 if (!in_thread_list (temp_ptid))
93815fbf
VP
2417 add_thread (temp_ptid);
2418
0df8b418 2419 /* Return to WFI, but tell it to immediately resume. */
37de36c6 2420 status->kind = TARGET_WAITKIND_SPURIOUS;
39f77062 2421 return inferior_ptid;
37de36c6
KB
2422 }
2423 else if (syscall_is_lwp_exit (pi, what))
2424 {
17faa917
DJ
2425 if (print_thread_events)
2426 printf_unfiltered (_("[%s exited]\n"),
2427 target_pid_to_str (retval));
37de36c6
KB
2428 delete_thread (retval);
2429 status->kind = TARGET_WAITKIND_SPURIOUS;
2430 return retval;
c3f6f71d 2431 }
37de36c6
KB
2432 else if (0)
2433 {
2434 /* FIXME: Do we need to handle SYS_sproc,
2435 SYS_fork, or SYS_vfork here? The old procfs
2436 seemed to use this event to handle threads on
2437 older (non-LWP) systems, where I'm assuming
19958708 2438 that threads were actually separate processes.
37de36c6
KB
2439 Irix, maybe? Anyway, low priority for now. */
2440 }
2441 else
2442 {
a3f17187 2443 printf_filtered (_("procfs: trapped on exit from "));
37de36c6
KB
2444 proc_prettyprint_syscall (proc_what (pi), 0);
2445 printf_filtered ("\n");
44122162
RO
2446
2447 long i, nsysargs, *sysargs;
2448
2449 if ((nsysargs = proc_nsysarg (pi)) > 0 &&
2450 (sysargs = proc_sysargs (pi)) != NULL)
2451 {
2452 printf_filtered (_("%ld syscall arguments:\n"),
2453 nsysargs);
2454 for (i = 0; i < nsysargs; i++)
2455 printf_filtered ("#%ld: 0x%08lx\n",
2456 i, sysargs[i]);
2457 }
2458
37de36c6 2459 status->kind = TARGET_WAITKIND_SPURIOUS;
39f77062 2460 return inferior_ptid;
37de36c6 2461 }
c3f6f71d
JM
2462 break;
2463 case PR_REQUESTED:
2464#if 0 /* FIXME */
2465 wstat = (SIGSTOP << 8) | 0177;
2466 break;
2467#else
2468 if (retry < 5)
2469 {
a3f17187 2470 printf_filtered (_("Retry #%d:\n"), retry);
c3f6f71d
JM
2471 pi->status_valid = 0;
2472 goto wait_again;
2473 }
2474 else
2475 {
2476 /* If not in procinfo list, add it. */
39f77062
KB
2477 temp_tid = proc_get_current_thread (pi);
2478 if (!find_procinfo (pi->pid, temp_tid))
2479 create_procinfo (pi->pid, temp_tid);
c3f6f71d
JM
2480
2481 /* If not in GDB's thread list, add it. */
dfd4cc63 2482 temp_ptid = ptid_build (pi->pid, temp_tid, 0);
39f77062 2483 if (!in_thread_list (temp_ptid))
93815fbf 2484 add_thread (temp_ptid);
c3f6f71d
JM
2485
2486 status->kind = TARGET_WAITKIND_STOPPED;
b196bc4c 2487 status->value.sig = GDB_SIGNAL_0;
c3f6f71d
JM
2488 return retval;
2489 }
2490#endif
2491 case PR_JOBCONTROL:
2492 wstat = (what << 8) | 0177;
2493 break;
2494 case PR_FAULTED:
7af6341f 2495 switch (what) {
c3f6f71d
JM
2496 case FLTWATCH:
2497 wstat = (SIGTRAP << 8) | 0177;
2498 break;
0df8b418 2499 /* FIXME: use si_signo where possible. */
c3f6f71d 2500 case FLTPRIV:
c3f6f71d 2501 case FLTILL:
c3f6f71d
JM
2502 wstat = (SIGILL << 8) | 0177;
2503 break;
2504 case FLTBPT:
c3f6f71d 2505 case FLTTRACE:
c3f6f71d
JM
2506 wstat = (SIGTRAP << 8) | 0177;
2507 break;
2508 case FLTSTACK:
2509 case FLTACCESS:
c3f6f71d 2510 case FLTBOUNDS:
c3f6f71d
JM
2511 wstat = (SIGSEGV << 8) | 0177;
2512 break;
2513 case FLTIOVF:
2514 case FLTIZDIV:
c3f6f71d 2515 case FLTFPE:
c3f6f71d
JM
2516 wstat = (SIGFPE << 8) | 0177;
2517 break;
3e43a32a 2518 case FLTPAGE: /* Recoverable page fault */
0df8b418
MS
2519 default: /* FIXME: use si_signo if possible for
2520 fault. */
39f77062 2521 retval = pid_to_ptid (-1);
c3f6f71d 2522 printf_filtered ("procfs:%d -- ", __LINE__);
a3f17187 2523 printf_filtered (_("child stopped for unknown reason:\n"));
c3f6f71d 2524 proc_prettyprint_why (why, what, 1);
8a3fe4f8 2525 error (_("... giving up..."));
c3f6f71d
JM
2526 break;
2527 }
2528 break; /* case PR_FAULTED: */
2529 default: /* switch (why) unmatched */
2530 printf_filtered ("procfs:%d -- ", __LINE__);
a3f17187 2531 printf_filtered (_("child stopped for unknown reason:\n"));
c3f6f71d 2532 proc_prettyprint_why (why, what, 1);
8a3fe4f8 2533 error (_("... giving up..."));
c3f6f71d
JM
2534 break;
2535 }
77382aee
PA
2536 /* Got this far without error: If retval isn't in the
2537 threads database, add it. */
dfd4cc63 2538 if (ptid_get_pid (retval) > 0 &&
39f77062 2539 !ptid_equal (retval, inferior_ptid) &&
c3f6f71d 2540 !in_thread_list (retval))
c906108c 2541 {
77382aee
PA
2542 /* We have a new thread. We need to add it both to
2543 GDB's list and to our own. If we don't create a
2544 procinfo, resume may be unhappy later. */
c3f6f71d 2545 add_thread (retval);
dfd4cc63
LM
2546 if (find_procinfo (ptid_get_pid (retval),
2547 ptid_get_lwp (retval)) == NULL)
2548 create_procinfo (ptid_get_pid (retval),
2549 ptid_get_lwp (retval));
c906108c 2550 }
c906108c 2551 }
0df8b418 2552 else /* Flags do not indicate STOPPED. */
c906108c 2553 {
0df8b418 2554 /* surely this can't happen... */
c3f6f71d
JM
2555 printf_filtered ("procfs:%d -- process not stopped.\n",
2556 __LINE__);
2557 proc_prettyprint_flags (flags, 1);
8a3fe4f8 2558 error (_("procfs: ...giving up..."));
c906108c 2559 }
c906108c 2560 }
c906108c 2561
c3f6f71d
JM
2562 if (status)
2563 store_waitstatus (status, wstat);
c906108c
SS
2564 }
2565
c3f6f71d
JM
2566 return retval;
2567}
c906108c 2568
4e73f23d
RM
2569/* Perform a partial transfer to/from the specified object. For
2570 memory transfers, fall back to the old memory xfer functions. */
2571
9b409511 2572static enum target_xfer_status
4e73f23d 2573procfs_xfer_partial (struct target_ops *ops, enum target_object object,
0b62613e 2574 const char *annex, gdb_byte *readbuf,
9b409511
YQ
2575 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
2576 ULONGEST *xfered_len)
4e73f23d
RM
2577{
2578 switch (object)
2579 {
2580 case TARGET_OBJECT_MEMORY:
e96027e0 2581 return procfs_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
4e73f23d 2582
4e73f23d 2583 case TARGET_OBJECT_AUXV:
9f2982ff 2584 return memory_xfer_auxv (ops, object, annex, readbuf, writebuf,
9b409511 2585 offset, len, xfered_len);
4e73f23d
RM
2586
2587 default:
e75fdfca
TT
2588 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2589 readbuf, writebuf, offset, len,
2590 xfered_len);
4e73f23d
RM
2591 }
2592}
2593
e96027e0
PA
2594/* Helper for procfs_xfer_partial that handles memory transfers.
2595 Arguments are like target_xfer_partial. */
4e73f23d 2596
e96027e0
PA
2597static enum target_xfer_status
2598procfs_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
2599 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
c3f6f71d
JM
2600{
2601 procinfo *pi;
e96027e0 2602 int nbytes;
c906108c 2603
0df8b418 2604 /* Find procinfo for main process. */
dfd4cc63 2605 pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid), 0);
c3f6f71d
JM
2606 if (pi->as_fd == 0 &&
2607 open_procinfo_files (pi, FD_AS) == 0)
c906108c 2608 {
c3f6f71d 2609 proc_warn (pi, "xfer_memory, open_proc_files", __LINE__);
e96027e0 2610 return TARGET_XFER_E_IO;
c906108c 2611 }
c906108c 2612
e96027e0
PA
2613 if (lseek (pi->as_fd, (off_t) memaddr, SEEK_SET) != (off_t) memaddr)
2614 return TARGET_XFER_E_IO;
2615
2616 if (writebuf != NULL)
c906108c 2617 {
e96027e0
PA
2618 PROCFS_NOTE ("write memory:\n");
2619 nbytes = write (pi->as_fd, writebuf, len);
2620 }
2621 else
2622 {
2623 PROCFS_NOTE ("read memory:\n");
2624 nbytes = read (pi->as_fd, readbuf, len);
c906108c 2625 }
e96027e0
PA
2626 if (nbytes <= 0)
2627 return TARGET_XFER_E_IO;
2628 *xfered_len = nbytes;
2629 return TARGET_XFER_OK;
c906108c
SS
2630}
2631
77382aee
PA
2632/* Called by target_resume before making child runnable. Mark cached
2633 registers and status's invalid. If there are "dirty" caches that
2634 need to be written back to the child process, do that.
c906108c 2635
77382aee
PA
2636 File descriptors are also cached. As they are a limited resource,
2637 we cannot hold onto them indefinitely. However, as they are
2638 expensive to open, we don't want to throw them away
2639 indescriminately either. As a compromise, we will keep the file
2640 descriptors for the parent process, but discard any file
2641 descriptors we may have accumulated for the threads.
2642
2643 As this function is called by iterate_over_threads, it always
2644 returns zero (so that iterate_over_threads will keep
2645 iterating). */
c3f6f71d
JM
2646
2647static int
fba45db2 2648invalidate_cache (procinfo *parent, procinfo *pi, void *ptr)
c906108c 2649{
77382aee
PA
2650 /* About to run the child; invalidate caches and do any other
2651 cleanup. */
c906108c 2652
c3f6f71d
JM
2653#if 0
2654 if (pi->gregs_dirty)
2655 if (parent == NULL ||
2656 proc_get_current_thread (parent) != pi->tid)
2657 if (!proc_set_gregs (pi)) /* flush gregs cache */
2658 proc_warn (pi, "target_resume, set_gregs",
2659 __LINE__);
f5656ead 2660 if (gdbarch_fp0_regnum (target_gdbarch ()) >= 0)
60054393
MS
2661 if (pi->fpregs_dirty)
2662 if (parent == NULL ||
2663 proc_get_current_thread (parent) != pi->tid)
2664 if (!proc_set_fpregs (pi)) /* flush fpregs cache */
19958708 2665 proc_warn (pi, "target_resume, set_fpregs",
60054393 2666 __LINE__);
c906108c 2667#endif
c906108c 2668
c3f6f71d 2669 if (parent != NULL)
c906108c 2670 {
c3f6f71d 2671 /* The presence of a parent indicates that this is an LWP.
19958708 2672 Close any file descriptors that it might have open.
c3f6f71d
JM
2673 We don't do this to the master (parent) procinfo. */
2674
2675 close_procinfo_files (pi);
c906108c 2676 }
c3f6f71d
JM
2677 pi->gregs_valid = 0;
2678 pi->fpregs_valid = 0;
2679#if 0
2680 pi->gregs_dirty = 0;
2681 pi->fpregs_dirty = 0;
c906108c 2682#endif
c3f6f71d
JM
2683 pi->status_valid = 0;
2684 pi->threads_valid = 0;
c906108c 2685
c3f6f71d 2686 return 0;
c906108c
SS
2687}
2688
0fda6bd2 2689#if 0
77382aee
PA
2690/* A callback function for iterate_over_threads. Find the
2691 asynchronous signal thread, and make it runnable. See if that
2692 helps matters any. */
c906108c 2693
c3f6f71d 2694static int
fba45db2 2695make_signal_thread_runnable (procinfo *process, procinfo *pi, void *ptr)
c906108c 2696{
c3f6f71d
JM
2697#ifdef PR_ASLWP
2698 if (proc_flags (pi) & PR_ASLWP)
c906108c 2699 {
c3f6f71d
JM
2700 if (!proc_run_process (pi, 0, -1))
2701 proc_error (pi, "make_signal_thread_runnable", __LINE__);
2702 return 1;
c906108c 2703 }
c906108c 2704#endif
c3f6f71d 2705 return 0;
c906108c 2706}
0fda6bd2 2707#endif
c906108c 2708
77382aee
PA
2709/* Make the child process runnable. Normally we will then call
2710 procfs_wait and wait for it to stop again (unless gdb is async).
2711
2712 If STEP is true, then arrange for the child to stop again after
2713 executing a single instruction. If SIGNO is zero, then cancel any
2714 pending signal; if non-zero, then arrange for the indicated signal
2715 to be delivered to the child when it runs. If PID is -1, then
2716 allow any child thread to run; if non-zero, then allow only the
2717 indicated thread to run. (not implemented yet). */
c906108c
SS
2718
2719static void
28439f5e 2720procfs_resume (struct target_ops *ops,
2ea28649 2721 ptid_t ptid, int step, enum gdb_signal signo)
c906108c 2722{
c3f6f71d
JM
2723 procinfo *pi, *thread;
2724 int native_signo;
2725
19958708 2726 /* 2.1:
c3f6f71d 2727 prrun.prflags |= PRSVADDR;
19958708 2728 prrun.pr_vaddr = $PC; set resume address
c3f6f71d 2729 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
19958708 2730 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
c3f6f71d
JM
2731 prrun.prflags |= PRCFAULT; clear current fault.
2732
2733 PRSTRACE and PRSFAULT can be done by other means
77382aee 2734 (proc_trace_signals, proc_trace_faults)
c3f6f71d
JM
2735 PRSVADDR is unnecessary.
2736 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
2737 This basically leaves PRSTEP and PRCSIG.
2738 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
2739 So basically PR_STEP is the sole argument that must be passed
77382aee 2740 to proc_run_process (for use in the prrun struct by ioctl). */
c3f6f71d 2741
0df8b418 2742 /* Find procinfo for main process. */
dfd4cc63 2743 pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid), 0);
c3f6f71d 2744
77382aee 2745 /* First cut: ignore pid argument. */
c3f6f71d 2746 errno = 0;
c906108c 2747
c3f6f71d
JM
2748 /* Convert signal to host numbering. */
2749 if (signo == 0 ||
a493e3e2 2750 (signo == GDB_SIGNAL_STOP && pi->ignore_next_sigstop))
c3f6f71d
JM
2751 native_signo = 0;
2752 else
2ea28649 2753 native_signo = gdb_signal_to_host (signo);
c906108c 2754
c3f6f71d 2755 pi->ignore_next_sigstop = 0;
c906108c 2756
77382aee
PA
2757 /* Running the process voids all cached registers and status. */
2758 /* Void the threads' caches first. */
19958708 2759 proc_iterate_over_threads (pi, invalidate_cache, NULL);
c3f6f71d
JM
2760 /* Void the process procinfo's caches. */
2761 invalidate_cache (NULL, pi, NULL);
c906108c 2762
dfd4cc63 2763 if (ptid_get_pid (ptid) != -1)
c906108c 2764 {
77382aee
PA
2765 /* Resume a specific thread, presumably suppressing the
2766 others. */
dfd4cc63 2767 thread = find_procinfo (ptid_get_pid (ptid), ptid_get_lwp (ptid));
7de45904 2768 if (thread != NULL)
c906108c 2769 {
c3f6f71d
JM
2770 if (thread->tid != 0)
2771 {
77382aee
PA
2772 /* We're to resume a specific thread, and not the
2773 others. Set the child process's PR_ASYNC flag. */
c3f6f71d
JM
2774 if (!proc_set_async (pi))
2775 proc_error (pi, "target_resume, set_async", __LINE__);
c3f6f71d 2776#if 0
19958708 2777 proc_iterate_over_threads (pi,
c3f6f71d
JM
2778 make_signal_thread_runnable,
2779 NULL);
2780#endif
0df8b418
MS
2781 pi = thread; /* Substitute the thread's procinfo
2782 for run. */
c3f6f71d 2783 }
c906108c
SS
2784 }
2785 }
c906108c 2786
c3f6f71d 2787 if (!proc_run_process (pi, step, native_signo))
c906108c 2788 {
c3f6f71d 2789 if (errno == EBUSY)
77382aee
PA
2790 warning (_("resume: target already running. "
2791 "Pretend to resume, and hope for the best!"));
c3f6f71d
JM
2792 else
2793 proc_error (pi, "target_resume", __LINE__);
c906108c 2794 }
c3f6f71d 2795}
c906108c 2796
77382aee 2797/* Set up to trace signals in the child process. */
c906108c 2798
c3f6f71d 2799static void
94bedb42
TT
2800procfs_pass_signals (struct target_ops *self,
2801 int numsigs, unsigned char *pass_signals)
c3f6f71d 2802{
44122162 2803 sigset_t signals;
dfd4cc63 2804 procinfo *pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid), 0);
2455069d 2805 int signo;
c906108c 2806
2455069d
UW
2807 prfillset (&signals);
2808
2809 for (signo = 0; signo < NSIG; signo++)
2810 {
2ea28649 2811 int target_signo = gdb_signal_from_host (signo);
2455069d 2812 if (target_signo < numsigs && pass_signals[target_signo])
44122162 2813 prdelset (&signals, signo);
2455069d
UW
2814 }
2815
2816 if (!proc_set_traced_signals (pi, &signals))
2817 proc_error (pi, "pass_signals", __LINE__);
c3f6f71d 2818}
c906108c 2819
77382aee 2820/* Print status information about the child process. */
c906108c 2821
c3f6f71d 2822static void
fba45db2 2823procfs_files_info (struct target_ops *ignore)
c3f6f71d 2824{
181e7f93 2825 struct inferior *inf = current_inferior ();
f4a14ae6 2826
a3f17187 2827 printf_filtered (_("\tUsing the running image of %s %s via /proc.\n"),
181e7f93 2828 inf->attach_flag? "attached": "child",
39f77062 2829 target_pid_to_str (inferior_ptid));
c3f6f71d 2830}
c906108c 2831
77382aee
PA
2832/* Make it die. Wait for it to die. Clean up after it. Note: this
2833 should only be applied to the real process, not to an LWP, because
2834 of the check for parent-process. If we need this to work for an
2835 LWP, it needs some more logic. */
c906108c 2836
c3f6f71d 2837static void
fba45db2 2838unconditionally_kill_inferior (procinfo *pi)
c3f6f71d
JM
2839{
2840 int parent_pid;
c906108c 2841
c3f6f71d 2842 parent_pid = proc_parent_pid (pi);
c3f6f71d 2843 if (!proc_kill (pi, SIGKILL))
103b3ef5 2844 proc_error (pi, "unconditionally_kill, proc_kill", __LINE__);
c3f6f71d 2845 destroy_procinfo (pi);
c906108c 2846
c3f6f71d
JM
2847 /* If pi is GDB's child, wait for it to die. */
2848 if (parent_pid == getpid ())
19958708 2849 /* FIXME: should we use waitpid to make sure we get the right event?
c3f6f71d
JM
2850 Should we check the returned event? */
2851 {
0d06e24b 2852#if 0
c3f6f71d 2853 int status, ret;
c906108c 2854
c3f6f71d
JM
2855 ret = waitpid (pi->pid, &status, 0);
2856#else
2857 wait (NULL);
2858#endif
2859 }
2860}
c906108c 2861
77382aee
PA
2862/* We're done debugging it, and we want it to go away. Then we want
2863 GDB to forget all about it. */
c906108c 2864
19958708 2865static void
7d85a9c0 2866procfs_kill_inferior (struct target_ops *ops)
c906108c 2867{
39f77062 2868 if (!ptid_equal (inferior_ptid, null_ptid)) /* ? */
c3f6f71d 2869 {
0df8b418 2870 /* Find procinfo for main process. */
dfd4cc63 2871 procinfo *pi = find_procinfo (ptid_get_pid (inferior_ptid), 0);
c906108c 2872
c3f6f71d
JM
2873 if (pi)
2874 unconditionally_kill_inferior (pi);
bc1e6c81 2875 target_mourn_inferior (inferior_ptid);
c906108c 2876 }
c3f6f71d
JM
2877}
2878
77382aee 2879/* Forget we ever debugged this thing! */
c906108c 2880
19958708 2881static void
136d6dae 2882procfs_mourn_inferior (struct target_ops *ops)
c3f6f71d
JM
2883{
2884 procinfo *pi;
c906108c 2885
39f77062 2886 if (!ptid_equal (inferior_ptid, null_ptid))
c3f6f71d 2887 {
0df8b418 2888 /* Find procinfo for main process. */
dfd4cc63 2889 pi = find_procinfo (ptid_get_pid (inferior_ptid), 0);
c3f6f71d
JM
2890 if (pi)
2891 destroy_procinfo (pi);
c906108c 2892 }
6a3cb8e8
PA
2893
2894 generic_mourn_inferior ();
8181d85f 2895
6a3cb8e8 2896 inf_child_maybe_unpush_target (ops);
c3f6f71d 2897}
c906108c 2898
77382aee
PA
2899/* When GDB forks to create a runnable inferior process, this function
2900 is called on the parent side of the fork. It's job is to do
2901 whatever is necessary to make the child ready to be debugged, and
2902 then wait for the child to synchronize. */
c906108c 2903
19958708 2904static void
28439f5e 2905procfs_init_inferior (struct target_ops *ops, int pid)
c3f6f71d
JM
2906{
2907 procinfo *pi;
44122162 2908 sigset_t signals;
c3f6f71d 2909 int fail;
2689673f 2910 int lwpid;
c906108c 2911
c3f6f71d
JM
2912 /* This routine called on the parent side (GDB side)
2913 after GDB forks the inferior. */
6a3cb8e8
PA
2914 if (!target_is_pushed (ops))
2915 push_target (ops);
c906108c 2916
c3f6f71d 2917 if ((pi = create_procinfo (pid, 0)) == NULL)
9b20d036 2918 perror (_("procfs: out of memory in 'init_inferior'"));
c3f6f71d
JM
2919
2920 if (!open_procinfo_files (pi, FD_CTL))
2921 proc_error (pi, "init_inferior, open_proc_files", __LINE__);
2922
2923 /*
2924 xmalloc // done
2925 open_procinfo_files // done
2926 link list // done
2927 prfillset (trace)
2928 procfs_notice_signals
2929 prfillset (fault)
2930 prdelset (FLTPAGE)
2931 PIOCWSTOP
2932 PIOCSFAULT
2933 */
2934
77382aee 2935 /* If not stopped yet, wait for it to stop. */
c3f6f71d
JM
2936 if (!(proc_flags (pi) & PR_STOPPED) &&
2937 !(proc_wait_for_stop (pi)))
2938 dead_procinfo (pi, "init_inferior: wait_for_stop failed", KILL);
2939
2940 /* Save some of the /proc state to be restored if we detach. */
2941 /* FIXME: Why? In case another debugger was debugging it?
0df8b418 2942 We're it's parent, for Ghu's sake! */
c3f6f71d
JM
2943 if (!proc_get_traced_signals (pi, &pi->saved_sigset))
2944 proc_error (pi, "init_inferior, get_traced_signals", __LINE__);
2945 if (!proc_get_held_signals (pi, &pi->saved_sighold))
2946 proc_error (pi, "init_inferior, get_held_signals", __LINE__);
2947 if (!proc_get_traced_faults (pi, &pi->saved_fltset))
2948 proc_error (pi, "init_inferior, get_traced_faults", __LINE__);
37de36c6 2949 if (!proc_get_traced_sysentry (pi, pi->saved_entryset))
c3f6f71d 2950 proc_error (pi, "init_inferior, get_traced_sysentry", __LINE__);
37de36c6 2951 if (!proc_get_traced_sysexit (pi, pi->saved_exitset))
c3f6f71d
JM
2952 proc_error (pi, "init_inferior, get_traced_sysexit", __LINE__);
2953
c3f6f71d
JM
2954 if ((fail = procfs_debug_inferior (pi)) != 0)
2955 proc_error (pi, "init_inferior (procfs_debug_inferior)", fail);
2956
0d06e24b
JM
2957 /* FIXME: logically, we should really be turning OFF run-on-last-close,
2958 and possibly even turning ON kill-on-last-close at this point. But
2959 I can't make that change without careful testing which I don't have
2960 time to do right now... */
c3f6f71d
JM
2961 /* Turn on run-on-last-close flag so that the child
2962 will die if GDB goes away for some reason. */
2963 if (!proc_set_run_on_last_close (pi))
2964 proc_error (pi, "init_inferior, set_RLC", __LINE__);
2965
2689673f
PA
2966 /* We now have have access to the lwpid of the main thread/lwp. */
2967 lwpid = proc_get_current_thread (pi);
2968
2969 /* Create a procinfo for the main lwp. */
2970 create_procinfo (pid, lwpid);
2971
2972 /* We already have a main thread registered in the thread table at
2973 this point, but it didn't have any lwp info yet. Notify the core
2974 about it. This changes inferior_ptid as well. */
2975 thread_change_ptid (pid_to_ptid (pid),
793e1c06 2976 ptid_build (pid, lwpid, 0));
c906108c 2977
2090129c 2978 gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
c3f6f71d 2979}
c906108c 2980
77382aee
PA
2981/* When GDB forks to create a new process, this function is called on
2982 the child side of the fork before GDB exec's the user program. Its
2983 job is to make the child minimally debuggable, so that the parent
2984 GDB process can connect to the child and take over. This function
2985 should do only the minimum to make that possible, and to
2986 synchronize with the parent process. The parent process should
2987 take care of the details. */
c3f6f71d
JM
2988
2989static void
fba45db2 2990procfs_set_exec_trap (void)
c3f6f71d
JM
2991{
2992 /* This routine called on the child side (inferior side)
2993 after GDB forks the inferior. It must use only local variables,
2994 because it may be sharing data space with its parent. */
c906108c 2995
c3f6f71d 2996 procinfo *pi;
37de36c6 2997 sysset_t *exitset;
c906108c 2998
c3f6f71d 2999 if ((pi = create_procinfo (getpid (), 0)) == NULL)
e2e0b3e5 3000 perror_with_name (_("procfs: create_procinfo failed in child."));
c906108c 3001
c3f6f71d
JM
3002 if (open_procinfo_files (pi, FD_CTL) == 0)
3003 {
3004 proc_warn (pi, "set_exec_trap, open_proc_files", __LINE__);
3005 gdb_flush (gdb_stderr);
77382aee
PA
3006 /* No need to call "dead_procinfo", because we're going to
3007 exit. */
c3f6f71d
JM
3008 _exit (127);
3009 }
c906108c 3010
44122162 3011 /* Method for tracing exec syscalls. */
c3f6f71d
JM
3012 /* GW: Rationale...
3013 Not all systems with /proc have all the exec* syscalls with the same
3014 names. On the SGI, for example, there is no SYS_exec, but there
77382aee 3015 *is* a SYS_execv. So, we try to account for that. */
c906108c 3016
37de36c6 3017 exitset = sysset_t_alloc (pi);
44122162 3018 premptyset (exitset);
c3f6f71d 3019#ifdef SYS_exec
44122162 3020 praddset (exitset, SYS_exec);
c906108c 3021#endif
44122162 3022 praddset (exitset, SYS_execve);
37de36c6
KB
3023
3024 if (!proc_set_traced_sysexit (pi, exitset))
c906108c 3025 {
c3f6f71d
JM
3026 proc_warn (pi, "set_exec_trap, set_traced_sysexit", __LINE__);
3027 gdb_flush (gdb_stderr);
3028 _exit (127);
c906108c 3029 }
c3f6f71d 3030
0df8b418 3031 /* FIXME: should this be done in the parent instead? */
c3f6f71d
JM
3032 /* Turn off inherit on fork flag so that all grand-children
3033 of gdb start with tracing flags cleared. */
3034 if (!proc_unset_inherit_on_fork (pi))
3035 proc_warn (pi, "set_exec_trap, unset_inherit", __LINE__);
3036
3037 /* Turn off run on last close flag, so that the child process
3038 cannot run away just because we close our handle on it.
3039 We want it to wait for the parent to attach. */
3040 if (!proc_unset_run_on_last_close (pi))
3041 proc_warn (pi, "set_exec_trap, unset_RLC", __LINE__);
3042
19958708 3043 /* FIXME: No need to destroy the procinfo --
0df8b418 3044 we have our own address space, and we're about to do an exec! */
c3f6f71d 3045 /*destroy_procinfo (pi);*/
c906108c 3046}
c906108c 3047
77382aee
PA
3048/* This function is called BEFORE gdb forks the inferior process. Its
3049 only real responsibility is to set things up for the fork, and tell
3050 GDB which two functions to call after the fork (one for the parent,
3051 and one for the child).
3052
3053 This function does a complicated search for a unix shell program,
3054 which it then uses to parse arguments and environment variables to
3055 be sent to the child. I wonder whether this code could not be
3056 abstracted out and shared with other unix targets such as
3057 inf-ptrace? */
c906108c
SS
3058
3059static void
7c5ded6a
SDJ
3060procfs_create_inferior (struct target_ops *ops, const char *exec_file,
3061 const std::string &allargs, char **env, int from_tty)
c906108c
SS
3062{
3063 char *shell_file = getenv ("SHELL");
3064 char *tryname;
28439f5e
PA
3065 int pid;
3066
c906108c
SS
3067 if (shell_file != NULL && strchr (shell_file, '/') == NULL)
3068 {
3069
3070 /* We will be looking down the PATH to find shell_file. If we
c3f6f71d
JM
3071 just do this the normal way (via execlp, which operates by
3072 attempting an exec for each element of the PATH until it
3073 finds one which succeeds), then there will be an exec for
3074 each failed attempt, each of which will cause a PR_SYSEXIT
3075 stop, and we won't know how to distinguish the PR_SYSEXIT's
3076 for these failed execs with the ones for successful execs
3077 (whether the exec has succeeded is stored at that time in the
3078 carry bit or some such architecture-specific and
3079 non-ABI-specified place).
3080
3081 So I can't think of anything better than to search the PATH
3082 now. This has several disadvantages: (1) There is a race
3083 condition; if we find a file now and it is deleted before we
3084 exec it, we lose, even if the deletion leaves a valid file
3085 further down in the PATH, (2) there is no way to know exactly
3086 what an executable (in the sense of "capable of being
3087 exec'd") file is. Using access() loses because it may lose
3088 if the caller is the superuser; failing to use it loses if
3089 there are ACLs or some such. */
c906108c 3090
995816ba
PA
3091 const char *p;
3092 const char *p1;
c906108c 3093 /* FIXME-maybe: might want "set path" command so user can change what
c3f6f71d 3094 path is used from within GDB. */
995816ba 3095 const char *path = getenv ("PATH");
c906108c
SS
3096 int len;
3097 struct stat statbuf;
3098
3099 if (path == NULL)
3100 path = "/bin:/usr/bin";
3101
b196bc4c 3102 tryname = (char *) alloca (strlen (path) + strlen (shell_file) + 2);
c3f6f71d 3103 for (p = path; p != NULL; p = p1 ? p1 + 1: NULL)
c906108c
SS
3104 {
3105 p1 = strchr (p, ':');
3106 if (p1 != NULL)
3107 len = p1 - p;
3108 else
3109 len = strlen (p);
3110 strncpy (tryname, p, len);
3111 tryname[len] = '\0';
3112 strcat (tryname, "/");
3113 strcat (tryname, shell_file);
3114 if (access (tryname, X_OK) < 0)
3115 continue;
3116 if (stat (tryname, &statbuf) < 0)
3117 continue;
3118 if (!S_ISREG (statbuf.st_mode))
3119 /* We certainly need to reject directories. I'm not quite
3120 as sure about FIFOs, sockets, etc., but I kind of doubt
3121 that people want to exec() these things. */
3122 continue;
3123 break;
3124 }
3125 if (p == NULL)
3126 /* Not found. This must be an error rather than merely passing
3127 the file to execlp(), because execlp() would try all the
3128 exec()s, causing GDB to get confused. */
8a3fe4f8 3129 error (_("procfs:%d -- Can't find shell %s in PATH"),
c3f6f71d 3130 __LINE__, shell_file);
c906108c
SS
3131
3132 shell_file = tryname;
3133 }
3134
28439f5e 3135 pid = fork_inferior (exec_file, allargs, env, procfs_set_exec_trap,
e69860f1 3136 NULL, NULL, shell_file, NULL);
28439f5e 3137
2090129c
SDJ
3138 /* We have something that executes now. We'll be running through
3139 the shell at this point (if startup-with-shell is true), but the
3140 pid shouldn't change. */
3141 add_thread_silent (pid_to_ptid (pid));
3142
28439f5e 3143 procfs_init_inferior (ops, pid);
27087a3d
JB
3144}
3145
3146/* An observer for the "inferior_created" event. */
c906108c 3147
27087a3d
JB
3148static void
3149procfs_inferior_created (struct target_ops *ops, int from_tty)
3150{
c906108c
SS
3151}
3152
e8032dde 3153/* Callback for update_thread_list. Calls "add_thread". */
c906108c 3154
c3f6f71d 3155static int
fba45db2 3156procfs_notice_thread (procinfo *pi, procinfo *thread, void *ptr)
c906108c 3157{
dfd4cc63 3158 ptid_t gdb_threadid = ptid_build (pi->pid, thread->tid, 0);
c906108c 3159
2689673f 3160 if (!in_thread_list (gdb_threadid) || is_exited (gdb_threadid))
c3f6f71d 3161 add_thread (gdb_threadid);
c906108c 3162
c3f6f71d
JM
3163 return 0;
3164}
3165
77382aee
PA
3166/* Query all the threads that the target knows about, and give them
3167 back to GDB to add to its list. */
c3f6f71d 3168
d3581e61 3169static void
e8032dde 3170procfs_update_thread_list (struct target_ops *ops)
c3f6f71d
JM
3171{
3172 procinfo *pi;
3173
e8032dde
PA
3174 prune_threads ();
3175
0df8b418 3176 /* Find procinfo for main process. */
dfd4cc63 3177 pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid), 0);
c3f6f71d
JM
3178 proc_update_threads (pi);
3179 proc_iterate_over_threads (pi, procfs_notice_thread, NULL);
c906108c
SS
3180}
3181
77382aee
PA
3182/* Return true if the thread is still 'alive'. This guy doesn't
3183 really seem to be doing his job. Got to investigate how to tell
3184 when a thread is really gone. */
c906108c 3185
c906108c 3186static int
28439f5e 3187procfs_thread_alive (struct target_ops *ops, ptid_t ptid)
c906108c 3188{
c3f6f71d
JM
3189 int proc, thread;
3190 procinfo *pi;
c906108c 3191
dfd4cc63
LM
3192 proc = ptid_get_pid (ptid);
3193 thread = ptid_get_lwp (ptid);
0df8b418 3194 /* If I don't know it, it ain't alive! */
c3f6f71d
JM
3195 if ((pi = find_procinfo (proc, thread)) == NULL)
3196 return 0;
3197
3198 /* If I can't get its status, it ain't alive!
3199 What's more, I need to forget about it! */
3200 if (!proc_get_status (pi))
3201 {
3202 destroy_procinfo (pi);
3203 return 0;
3204 }
77382aee
PA
3205 /* I couldn't have got its status if it weren't alive, so it's
3206 alive. */
c3f6f71d 3207 return 1;
c906108c 3208}
c3f6f71d 3209
77382aee
PA
3210/* Convert PTID to a string. Returns the string in a static
3211 buffer. */
c3f6f71d 3212
7a114964 3213static const char *
117de6a9 3214procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
c3f6f71d
JM
3215{
3216 static char buf[80];
c3f6f71d 3217
dfd4cc63
LM
3218 if (ptid_get_lwp (ptid) == 0)
3219 sprintf (buf, "process %d", ptid_get_pid (ptid));
c3f6f71d 3220 else
dfd4cc63 3221 sprintf (buf, "LWP %ld", ptid_get_lwp (ptid));
5240ceac
MK
3222
3223 return buf;
c3f6f71d
JM
3224}
3225
77382aee 3226/* Insert a watchpoint. */
c3f6f71d 3227
a0911fd0 3228static int
39f77062 3229procfs_set_watchpoint (ptid_t ptid, CORE_ADDR addr, int len, int rwflag,
77382aee 3230 int after)
c906108c 3231{
c3f6f71d 3232 int pflags = 0;
19958708 3233 procinfo *pi;
c3f6f71d 3234
dfd4cc63
LM
3235 pi = find_procinfo_or_die (ptid_get_pid (ptid) == -1 ?
3236 ptid_get_pid (inferior_ptid) : ptid_get_pid (ptid),
3237 0);
c3f6f71d 3238
0df8b418
MS
3239 /* Translate from GDB's flags to /proc's. */
3240 if (len > 0) /* len == 0 means delete watchpoint. */
c906108c 3241 {
0df8b418 3242 switch (rwflag) { /* FIXME: need an enum! */
c3f6f71d
JM
3243 case hw_write: /* default watchpoint (write) */
3244 pflags = WRITE_WATCHFLAG;
3245 break;
3246 case hw_read: /* read watchpoint */
3247 pflags = READ_WATCHFLAG;
3248 break;
3249 case hw_access: /* access watchpoint */
3250 pflags = READ_WATCHFLAG | WRITE_WATCHFLAG;
3251 break;
3252 case hw_execute: /* execution HW breakpoint */
3253 pflags = EXEC_WATCHFLAG;
3254 break;
0df8b418 3255 default: /* Something weird. Return error. */
c906108c 3256 return -1;
c3f6f71d 3257 }
0df8b418 3258 if (after) /* Stop after r/w access is completed. */
c3f6f71d
JM
3259 pflags |= AFTER_WATCHFLAG;
3260 }
3261
3262 if (!proc_set_watchpoint (pi, addr, len, pflags))
3263 {
0df8b418 3264 if (errno == E2BIG) /* Typical error for no resources. */
c3f6f71d
JM
3265 return -1; /* fail */
3266 /* GDB may try to remove the same watchpoint twice.
3267 If a remove request returns no match, don't error. */
c906108c 3268 if (errno == ESRCH && len == 0)
c3f6f71d
JM
3269 return 0; /* ignore */
3270 proc_error (pi, "set_watchpoint", __LINE__);
c906108c
SS
3271 }
3272 return 0;
3273}
3274
1e03ad20
KB
3275/* Return non-zero if we can set a hardware watchpoint of type TYPE. TYPE
3276 is one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint,
3277 or bp_hardware_watchpoint. CNT is the number of watchpoints used so
3278 far.
19958708 3279
1e03ad20
KB
3280 Note: procfs_can_use_hw_breakpoint() is not yet used by all
3281 procfs.c targets due to the fact that some of them still define
d92524f1 3282 target_can_use_hardware_watchpoint. */
1e03ad20
KB
3283
3284static int
5461485a 3285procfs_can_use_hw_breakpoint (struct target_ops *self,
f486487f
SM
3286 enum bptype type,
3287 int cnt, int othertype)
1e03ad20 3288{
1e03ad20
KB
3289 /* Due to the way that proc_set_watchpoint() is implemented, host
3290 and target pointers must be of the same size. If they are not,
3291 we can't use hardware watchpoints. This limitation is due to the
9a043c1d
AC
3292 fact that proc_set_watchpoint() calls
3293 procfs_address_to_host_pointer(); a close inspection of
3294 procfs_address_to_host_pointer will reveal that an internal error
3295 will be generated when the host and target pointer sizes are
3296 different. */
f5656ead 3297 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
f4a14ae6 3298
4e906f53 3299 if (sizeof (void *) != TYPE_LENGTH (ptr_type))
1e03ad20
KB
3300 return 0;
3301
3302 /* Other tests here??? */
3303
3304 return 1;
1e03ad20
KB
3305}
3306
77382aee
PA
3307/* Returns non-zero if process is stopped on a hardware watchpoint
3308 fault, else returns zero. */
c3f6f71d 3309
25513619 3310static int
6a109b6b 3311procfs_stopped_by_watchpoint (struct target_ops *ops)
c906108c 3312{
c3f6f71d 3313 procinfo *pi;
c906108c 3314
dfd4cc63 3315 pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid), 0);
aaeb7efa 3316
c3f6f71d 3317 if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
c906108c 3318 {
c3f6f71d 3319 if (proc_why (pi) == PR_FAULTED)
19958708 3320 {
c3f6f71d
JM
3321 if (proc_what (pi) == FLTWATCH)
3322 return 1;
c3f6f71d 3323 }
c906108c
SS
3324 }
3325 return 0;
3326}
c906108c 3327
77382aee
PA
3328/* Returns 1 if the OS knows the position of the triggered watchpoint,
3329 and sets *ADDR to that address. Returns 0 if OS cannot report that
3330 address. This function is only called if
3331 procfs_stopped_by_watchpoint returned 1, thus no further checks are
3332 done. The function also assumes that ADDR is not NULL. */
bf701c2c
PM
3333
3334static int
3335procfs_stopped_data_address (struct target_ops *targ, CORE_ADDR *addr)
3336{
3337 procinfo *pi;
3338
dfd4cc63 3339 pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid), 0);
bf701c2c
PM
3340 return proc_watchpoint_address (pi, addr);
3341}
3342
25513619 3343static int
7bb99c53 3344procfs_insert_watchpoint (struct target_ops *self,
f486487f
SM
3345 CORE_ADDR addr, int len,
3346 enum target_hw_bp_type type,
0cf6dd15 3347 struct expression *cond)
25513619 3348{
d92524f1 3349 if (!target_have_steppable_watchpoint
f5656ead 3350 && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch ()))
25513619
PA
3351 {
3352 /* When a hardware watchpoint fires off the PC will be left at
3353 the instruction following the one which caused the
3354 watchpoint. It will *NOT* be necessary for GDB to step over
3355 the watchpoint. */
3356 return procfs_set_watchpoint (inferior_ptid, addr, len, type, 1);
3357 }
3358 else
3359 {
3360 /* When a hardware watchpoint fires off the PC will be left at
3361 the instruction which caused the watchpoint. It will be
3362 necessary for GDB to step over the watchpoint. */
3363 return procfs_set_watchpoint (inferior_ptid, addr, len, type, 0);
3364 }
3365}
3366
3367static int
11b5219a 3368procfs_remove_watchpoint (struct target_ops *self,
f486487f
SM
3369 CORE_ADDR addr, int len,
3370 enum target_hw_bp_type type,
0cf6dd15 3371 struct expression *cond)
25513619
PA
3372{
3373 return procfs_set_watchpoint (inferior_ptid, addr, 0, 0, 0);
3374}
3375
3376static int
31568a15
TT
3377procfs_region_ok_for_hw_watchpoint (struct target_ops *self,
3378 CORE_ADDR addr, int len)
25513619
PA
3379{
3380 /* The man page for proc(4) on Solaris 2.6 and up says that the
3381 system can support "thousands" of hardware watchpoints, but gives
3382 no method for finding out how many; It doesn't say anything about
3383 the allowed size for the watched area either. So we just tell
3384 GDB 'yes'. */
3385 return 1;
3386}
3387
3388void
3389procfs_use_watchpoints (struct target_ops *t)
3390{
3391 t->to_stopped_by_watchpoint = procfs_stopped_by_watchpoint;
3392 t->to_insert_watchpoint = procfs_insert_watchpoint;
3393 t->to_remove_watchpoint = procfs_remove_watchpoint;
3394 t->to_region_ok_for_hw_watchpoint = procfs_region_ok_for_hw_watchpoint;
d1a7880c 3395 t->to_can_use_hw_breakpoint = procfs_can_use_hw_breakpoint;
bf701c2c 3396 t->to_stopped_data_address = procfs_stopped_data_address;
25513619
PA
3397}
3398
77382aee
PA
3399/* Memory Mappings Functions: */
3400
3401/* Call a callback function once for each mapping, passing it the
3402 mapping, an optional secondary callback function, and some optional
3403 opaque data. Quit and return the first non-zero value returned
3404 from the callback.
3405
3406 PI is the procinfo struct for the process to be mapped. FUNC is
3407 the callback function to be called by this iterator. DATA is the
3408 optional opaque data to be passed to the callback function.
3409 CHILD_FUNC is the optional secondary function pointer to be passed
3410 to the child function. Returns the first non-zero return value
3411 from the callback function, or zero. */
831e682e
MS
3412
3413static int
b8edc417 3414iterate_over_mappings (procinfo *pi, find_memory_region_ftype child_func,
e9ef4f39 3415 void *data,
19958708 3416 int (*func) (struct prmap *map,
b8edc417 3417 find_memory_region_ftype child_func,
831e682e
MS
3418 void *data))
3419{
3420 char pathname[MAX_PROC_NAME_SIZE];
3421 struct prmap *prmaps;
3422 struct prmap *prmap;
3423 int funcstat;
831e682e 3424 int nmap;
831e682e 3425 struct stat sbuf;
831e682e 3426
19958708 3427 /* Get the number of mappings, allocate space,
831e682e 3428 and read the mappings into prmaps. */
0df8b418 3429 /* Open map fd. */
831e682e 3430 sprintf (pathname, "/proc/%d/map", pi->pid);
831e682e 3431
5dc1a704
TT
3432 scoped_fd map_fd (open (pathname, O_RDONLY));
3433 if (map_fd.get () < 0)
3434 proc_error (pi, "iterate_over_mappings (open)", __LINE__);
831e682e 3435
19958708 3436 /* Use stat to determine the file size, and compute
831e682e 3437 the number of prmap_t objects it contains. */
5dc1a704 3438 if (fstat (map_fd.get (), &sbuf) != 0)
831e682e
MS
3439 proc_error (pi, "iterate_over_mappings (fstat)", __LINE__);
3440
3441 nmap = sbuf.st_size / sizeof (prmap_t);
3442 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
5dc1a704 3443 if (read (map_fd.get (), (char *) prmaps, nmap * sizeof (*prmaps))
831e682e
MS
3444 != (nmap * sizeof (*prmaps)))
3445 proc_error (pi, "iterate_over_mappings (read)", __LINE__);
831e682e
MS
3446
3447 for (prmap = prmaps; nmap > 0; prmap++, nmap--)
3448 if ((funcstat = (*func) (prmap, child_func, data)) != 0)
5dc1a704 3449 return funcstat;
831e682e
MS
3450
3451 return 0;
3452}
3453
77382aee 3454/* Implements the to_find_memory_regions method. Calls an external
b8edc417 3455 function for each memory region.
77382aee 3456 Returns the integer value returned by the callback. */
be4d1333
MS
3457
3458static int
19958708 3459find_memory_regions_callback (struct prmap *map,
b8edc417 3460 find_memory_region_ftype func, void *data)
be4d1333 3461{
bf75638e 3462 return (*func) ((CORE_ADDR) map->pr_vaddr,
19958708 3463 map->pr_size,
be4d1333
MS
3464 (map->pr_mflags & MA_READ) != 0,
3465 (map->pr_mflags & MA_WRITE) != 0,
19958708 3466 (map->pr_mflags & MA_EXEC) != 0,
4f69f4c2 3467 1, /* MODIFIED is unknown, pass it as true. */
be4d1333
MS
3468 data);
3469}
3470
77382aee
PA
3471/* External interface. Calls a callback function once for each
3472 mapped memory region in the child process, passing as arguments:
3473
3474 CORE_ADDR virtual_address,
3475 unsigned long size,
3476 int read, TRUE if region is readable by the child
3477 int write, TRUE if region is writable by the child
3478 int execute TRUE if region is executable by the child.
3479
3480 Stops iterating and returns the first non-zero value returned by
3481 the callback. */
be4d1333
MS
3482
3483static int
2e73927c
TT
3484proc_find_memory_regions (struct target_ops *self,
3485 find_memory_region_ftype func, void *data)
be4d1333 3486{
dfd4cc63 3487 procinfo *pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid), 0);
be4d1333 3488
19958708 3489 return iterate_over_mappings (pi, func, data,
be4d1333
MS
3490 find_memory_regions_callback);
3491}
3492
77382aee 3493/* Returns an ascii representation of a memory mapping's flags. */
c3f6f71d 3494
388faa48 3495static char *
5ae5f592 3496mappingflags (long flags)
388faa48
MS
3497{
3498 static char asciiflags[8];
3499
3500 strcpy (asciiflags, "-------");
388faa48
MS
3501 if (flags & MA_STACK)
3502 asciiflags[1] = 's';
3503 if (flags & MA_BREAK)
3504 asciiflags[2] = 'b';
3505 if (flags & MA_SHARED)
3506 asciiflags[3] = 's';
3507 if (flags & MA_READ)
3508 asciiflags[4] = 'r';
3509 if (flags & MA_WRITE)
3510 asciiflags[5] = 'w';
3511 if (flags & MA_EXEC)
3512 asciiflags[6] = 'x';
3513 return (asciiflags);
3514}
3515
77382aee
PA
3516/* Callback function, does the actual work for 'info proc
3517 mappings'. */
831e682e 3518
831e682e 3519static int
b8edc417 3520info_mappings_callback (struct prmap *map, find_memory_region_ftype ignore,
e9ef4f39 3521 void *unused)
831e682e 3522{
0b62613e 3523 unsigned int pr_off;
831e682e 3524
0b62613e 3525 pr_off = (unsigned int) map->pr_offset;
0b62613e 3526
f5656ead 3527 if (gdbarch_addr_bit (target_gdbarch ()) == 32)
f6a96b83 3528 printf_filtered ("\t%#10lx %#10lx %#10lx %#10x %7s\n",
0b62613e
PA
3529 (unsigned long) map->pr_vaddr,
3530 (unsigned long) map->pr_vaddr + map->pr_size - 1,
f6a96b83 3531 (unsigned long) map->pr_size,
0b62613e
PA
3532 pr_off,
3533 mappingflags (map->pr_mflags));
3534 else
f6a96b83 3535 printf_filtered (" %#18lx %#18lx %#10lx %#10x %7s\n",
0b62613e
PA
3536 (unsigned long) map->pr_vaddr,
3537 (unsigned long) map->pr_vaddr + map->pr_size - 1,
f6a96b83 3538 (unsigned long) map->pr_size,
0b62613e
PA
3539 pr_off,
3540 mappingflags (map->pr_mflags));
831e682e
MS
3541
3542 return 0;
3543}
3544
77382aee 3545/* Implement the "info proc mappings" subcommand. */
388faa48
MS
3546
3547static void
3548info_proc_mappings (procinfo *pi, int summary)
3549{
388faa48 3550 if (summary)
0df8b418 3551 return; /* No output for summary mode. */
388faa48 3552
a3f17187 3553 printf_filtered (_("Mapped address spaces:\n\n"));
f5656ead 3554 if (gdbarch_ptr_bit (target_gdbarch ()) == 32)
0b62613e
PA
3555 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
3556 "Start Addr",
3557 " End Addr",
3558 " Size",
3559 " Offset",
3560 "Flags");
3561 else
3562 printf_filtered (" %18s %18s %10s %10s %7s\n",
3563 "Start Addr",
3564 " End Addr",
3565 " Size",
3566 " Offset",
3567 "Flags");
388faa48 3568
831e682e 3569 iterate_over_mappings (pi, NULL, NULL, info_mappings_callback);
388faa48
MS
3570 printf_filtered ("\n");
3571}
3572
77382aee 3573/* Implement the "info proc" command. */
c3f6f71d
JM
3574
3575static void
7bc112c1 3576procfs_info_proc (struct target_ops *ops, const char *args,
145b16a9 3577 enum info_proc_what what)
c906108c 3578{
c3f6f71d 3579 struct cleanup *old_chain;
388faa48
MS
3580 procinfo *process = NULL;
3581 procinfo *thread = NULL;
388faa48
MS
3582 char *tmp = NULL;
3583 int pid = 0;
3584 int tid = 0;
3585 int mappings = 0;
c906108c 3586
145b16a9
UW
3587 switch (what)
3588 {
3589 case IP_MINIMAL:
3590 break;
3591
3592 case IP_MAPPINGS:
3593 case IP_ALL:
3594 mappings = 1;
3595 break;
3596
3597 default:
3598 error (_("Not supported on this target."));
3599 }
3600
c3f6f71d 3601 old_chain = make_cleanup (null_cleanup, 0);
773a1edc 3602 gdb_argv built_argv (args);
4fa7574e 3603 for (char *arg : built_argv)
c3f6f71d 3604 {
773a1edc 3605 if (isdigit (arg[0]))
c3f6f71d 3606 {
773a1edc 3607 pid = strtoul (arg, &tmp, 10);
c3f6f71d
JM
3608 if (*tmp == '/')
3609 tid = strtoul (++tmp, NULL, 10);
3610 }
773a1edc 3611 else if (arg[0] == '/')
c3f6f71d 3612 {
773a1edc 3613 tid = strtoul (arg + 1, NULL, 10);
c3f6f71d 3614 }
c3f6f71d
JM
3615 }
3616 if (pid == 0)
dfd4cc63 3617 pid = ptid_get_pid (inferior_ptid);
c3f6f71d 3618 if (pid == 0)
8a3fe4f8 3619 error (_("No current process: you must name one."));
c3f6f71d 3620 else
c906108c 3621 {
c3f6f71d 3622 /* Have pid, will travel.
0df8b418 3623 First see if it's a process we're already debugging. */
c3f6f71d
JM
3624 process = find_procinfo (pid, 0);
3625 if (process == NULL)
3626 {
19958708 3627 /* No. So open a procinfo for it, but
c3f6f71d
JM
3628 remember to close it again when finished. */
3629 process = create_procinfo (pid, 0);
004527cb 3630 make_cleanup (do_destroy_procinfo_cleanup, process);
c3f6f71d
JM
3631 if (!open_procinfo_files (process, FD_CTL))
3632 proc_error (process, "info proc, open_procinfo_files", __LINE__);
3633 }
c906108c 3634 }
c3f6f71d
JM
3635 if (tid != 0)
3636 thread = create_procinfo (pid, tid);
3637
3638 if (process)
3639 {
a3f17187 3640 printf_filtered (_("process %d flags:\n"), process->pid);
c3f6f71d
JM
3641 proc_prettyprint_flags (proc_flags (process), 1);
3642 if (proc_flags (process) & (PR_STOPPED | PR_ISTOP))
3643 proc_prettyprint_why (proc_why (process), proc_what (process), 1);
3644 if (proc_get_nthreads (process) > 1)
19958708 3645 printf_filtered ("Process has %d threads.\n",
c3f6f71d
JM
3646 proc_get_nthreads (process));
3647 }
3648 if (thread)
3649 {
a3f17187 3650 printf_filtered (_("thread %d flags:\n"), thread->tid);
c3f6f71d
JM
3651 proc_prettyprint_flags (proc_flags (thread), 1);
3652 if (proc_flags (thread) & (PR_STOPPED | PR_ISTOP))
3653 proc_prettyprint_why (proc_why (thread), proc_what (thread), 1);
3654 }
3655
388faa48
MS
3656 if (mappings)
3657 {
3658 info_proc_mappings (process, 0);
3659 }
3660
c3f6f71d 3661 do_cleanups (old_chain);
c906108c
SS
3662}
3663
9185ddce
JB
3664/* Modify the status of the system call identified by SYSCALLNUM in
3665 the set of syscalls that are currently traced/debugged.
3666
3667 If ENTRY_OR_EXIT is set to PR_SYSENTRY, then the entry syscalls set
0df8b418 3668 will be updated. Otherwise, the exit syscalls set will be updated.
9185ddce 3669
0df8b418 3670 If MODE is FLAG_SET, then traces will be enabled. Otherwise, they
9185ddce
JB
3671 will be disabled. */
3672
3673static void
3674proc_trace_syscalls_1 (procinfo *pi, int syscallnum, int entry_or_exit,
77382aee 3675 int mode, int from_tty)
9185ddce
JB
3676{
3677 sysset_t *sysset;
77382aee 3678
9185ddce
JB
3679 if (entry_or_exit == PR_SYSENTRY)
3680 sysset = proc_get_traced_sysentry (pi, NULL);
3681 else
3682 sysset = proc_get_traced_sysexit (pi, NULL);
3683
3684 if (sysset == NULL)
3685 proc_error (pi, "proc-trace, get_traced_sysset", __LINE__);
3686
3687 if (mode == FLAG_SET)
44122162 3688 praddset (sysset, syscallnum);
9185ddce 3689 else
44122162 3690 prdelset (sysset, syscallnum);
9185ddce
JB
3691
3692 if (entry_or_exit == PR_SYSENTRY)
3693 {
3694 if (!proc_set_traced_sysentry (pi, sysset))
77382aee 3695 proc_error (pi, "proc-trace, set_traced_sysentry", __LINE__);
9185ddce
JB
3696 }
3697 else
3698 {
3699 if (!proc_set_traced_sysexit (pi, sysset))
77382aee 3700 proc_error (pi, "proc-trace, set_traced_sysexit", __LINE__);
9185ddce
JB
3701 }
3702}
3703
c3f6f71d 3704static void
0b39b52e 3705proc_trace_syscalls (const char *args, int from_tty, int entry_or_exit, int mode)
c906108c 3706{
c3f6f71d 3707 procinfo *pi;
c906108c 3708
dfd4cc63 3709 if (ptid_get_pid (inferior_ptid) <= 0)
8a3fe4f8 3710 error (_("you must be debugging a process to use this command."));
c906108c 3711
c3f6f71d 3712 if (args == NULL || args[0] == 0)
e2e0b3e5 3713 error_no_arg (_("system call to trace"));
c3f6f71d 3714
dfd4cc63 3715 pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid), 0);
c3f6f71d
JM
3716 if (isdigit (args[0]))
3717 {
9185ddce 3718 const int syscallnum = atoi (args);
c906108c 3719
9185ddce 3720 proc_trace_syscalls_1 (pi, syscallnum, entry_or_exit, mode, from_tty);
c3f6f71d
JM
3721 }
3722}
3723
19958708 3724static void
0b39b52e 3725proc_trace_sysentry_cmd (const char *args, int from_tty)
c906108c 3726{
c3f6f71d
JM
3727 proc_trace_syscalls (args, from_tty, PR_SYSENTRY, FLAG_SET);
3728}
c906108c 3729
19958708 3730static void
0b39b52e 3731proc_trace_sysexit_cmd (const char *args, int from_tty)
c3f6f71d
JM
3732{
3733 proc_trace_syscalls (args, from_tty, PR_SYSEXIT, FLAG_SET);
c906108c 3734}
c906108c 3735
19958708 3736static void
0b39b52e 3737proc_untrace_sysentry_cmd (const char *args, int from_tty)
c3f6f71d
JM
3738{
3739 proc_trace_syscalls (args, from_tty, PR_SYSENTRY, FLAG_RESET);
3740}
3741
19958708 3742static void
0b39b52e 3743proc_untrace_sysexit_cmd (const char *args, int from_tty)
c906108c 3744{
c3f6f71d
JM
3745 proc_trace_syscalls (args, from_tty, PR_SYSEXIT, FLAG_RESET);
3746}
c906108c 3747
c906108c 3748void
fba45db2 3749_initialize_procfs (void)
c906108c 3750{
76727919 3751 gdb::observers::inferior_created.attach (procfs_inferior_created);
27087a3d 3752
19958708 3753 add_com ("proc-trace-entry", no_class, proc_trace_sysentry_cmd,
1bedd215 3754 _("Give a trace of entries into the syscall."));
19958708 3755 add_com ("proc-trace-exit", no_class, proc_trace_sysexit_cmd,
1bedd215 3756 _("Give a trace of exits from the syscall."));
19958708 3757 add_com ("proc-untrace-entry", no_class, proc_untrace_sysentry_cmd,
1bedd215 3758 _("Cancel a trace of entries into the syscall."));
19958708 3759 add_com ("proc-untrace-exit", no_class, proc_untrace_sysexit_cmd,
1bedd215 3760 _("Cancel a trace of exits from the syscall."));
c3f6f71d
JM
3761}
3762
3763/* =================== END, GDB "MODULE" =================== */
3764
3765
3766
77382aee
PA
3767/* miscellaneous stubs: */
3768
3769/* The following satisfy a few random symbols mostly created by the
3770 solaris threads implementation, which I will chase down later. */
c3f6f71d 3771
77382aee
PA
3772/* Return a pid for which we guarantee we will be able to find a
3773 'live' procinfo. */
c3f6f71d 3774
39f77062 3775ptid_t
fba45db2 3776procfs_first_available (void)
c3f6f71d 3777{
39f77062 3778 return pid_to_ptid (procinfo_list ? procinfo_list->pid : -1);
c3f6f71d 3779}
be4d1333
MS
3780
3781/* =================== GCORE .NOTE "MODULE" =================== */
3782
3783static char *
19958708 3784procfs_do_thread_registers (bfd *obfd, ptid_t ptid,
2020b7ab 3785 char *note_data, int *note_size,
2ea28649 3786 enum gdb_signal stop_signal)
be4d1333 3787{
594f7785 3788 struct regcache *regcache = get_thread_regcache (ptid);
be4d1333
MS
3789 gdb_gregset_t gregs;
3790 gdb_fpregset_t fpregs;
3791 unsigned long merged_pid;
3792
dfd4cc63 3793 merged_pid = ptid_get_lwp (ptid) << 16 | ptid_get_pid (ptid);
be4d1333 3794
75125405
DJ
3795 /* This part is the old method for fetching registers.
3796 It should be replaced by the newer one using regsets
3797 once it is implemented in this platform:
29082443 3798 gdbarch_iterate_over_regset_sections(). */
75125405 3799
2989a365 3800 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
75125405
DJ
3801 inferior_ptid = ptid;
3802 target_fetch_registers (regcache, -1);
3803
594f7785 3804 fill_gregset (regcache, &gregs, -1);
65554fef
MS
3805 note_data = (char *) elfcore_write_lwpstatus (obfd,
3806 note_data,
3807 note_size,
19958708 3808 merged_pid,
65554fef
MS
3809 stop_signal,
3810 &gregs);
594f7785 3811 fill_fpregset (regcache, &fpregs, -1);
be4d1333
MS
3812 note_data = (char *) elfcore_write_prfpreg (obfd,
3813 note_data,
3814 note_size,
3815 &fpregs,
3816 sizeof (fpregs));
75125405 3817
be4d1333
MS
3818 return note_data;
3819}
3820
3821struct procfs_corefile_thread_data {
3822 bfd *obfd;
3823 char *note_data;
3824 int *note_size;
2ea28649 3825 enum gdb_signal stop_signal;
be4d1333
MS
3826};
3827
3828static int
65554fef 3829procfs_corefile_thread_callback (procinfo *pi, procinfo *thread, void *data)
be4d1333 3830{
b196bc4c
RO
3831 struct procfs_corefile_thread_data *args
3832 = (struct procfs_corefile_thread_data *) data;
be4d1333 3833
2689673f 3834 if (pi != NULL)
be4d1333 3835 {
dfd4cc63 3836 ptid_t ptid = ptid_build (pi->pid, thread->tid, 0);
f4a14ae6 3837
75125405 3838 args->note_data = procfs_do_thread_registers (args->obfd, ptid,
19958708 3839 args->note_data,
2020b7ab
PA
3840 args->note_size,
3841 args->stop_signal);
be4d1333
MS
3842 }
3843 return 0;
3844}
3845
a223f1e7
JB
3846static int
3847find_signalled_thread (struct thread_info *info, void *data)
3848{
a493e3e2 3849 if (info->suspend.stop_signal != GDB_SIGNAL_0
a223f1e7
JB
3850 && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
3851 return 1;
3852
3853 return 0;
3854}
3855
2ea28649 3856static enum gdb_signal
a223f1e7
JB
3857find_stop_signal (void)
3858{
3859 struct thread_info *info =
3860 iterate_over_threads (find_signalled_thread, NULL);
3861
3862 if (info)
16c381f0 3863 return info->suspend.stop_signal;
a223f1e7 3864 else
a493e3e2 3865 return GDB_SIGNAL_0;
a223f1e7
JB
3866}
3867
be4d1333 3868static char *
fc6691b2 3869procfs_make_note_section (struct target_ops *self, bfd *obfd, int *note_size)
be4d1333
MS
3870{
3871 struct cleanup *old_chain;
3872 gdb_gregset_t gregs;
3873 gdb_fpregset_t fpregs;
3874 char fname[16] = {'\0'};
3875 char psargs[80] = {'\0'};
dfd4cc63 3876 procinfo *pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid), 0);
be4d1333 3877 char *note_data = NULL;
6dbdc4a3 3878 char *inf_args;
be4d1333 3879 struct procfs_corefile_thread_data thread_args;
0b62613e 3880 gdb_byte *auxv;
4e73f23d 3881 int auxv_len;
2ea28649 3882 enum gdb_signal stop_signal;
be4d1333
MS
3883
3884 if (get_exec_file (0))
3885 {
9f37bbcc 3886 strncpy (fname, lbasename (get_exec_file (0)), sizeof (fname));
4e2af517
JM
3887 fname[sizeof (fname) - 1] = 0;
3888 strncpy (psargs, get_exec_file (0), sizeof (psargs));
3889 psargs[sizeof (psargs) - 1] = 0;
6dbdc4a3
MS
3890
3891 inf_args = get_inferior_args ();
3892 if (inf_args && *inf_args &&
3893 strlen (inf_args) < ((int) sizeof (psargs) - (int) strlen (psargs)))
be4d1333 3894 {
19958708 3895 strncat (psargs, " ",
be4d1333 3896 sizeof (psargs) - strlen (psargs));
19958708 3897 strncat (psargs, inf_args,
be4d1333
MS
3898 sizeof (psargs) - strlen (psargs));
3899 }
3900 }
3901
19958708
RM
3902 note_data = (char *) elfcore_write_prpsinfo (obfd,
3903 note_data,
3904 note_size,
3905 fname,
be4d1333
MS
3906 psargs);
3907
651c8d2d
PA
3908 stop_signal = find_stop_signal ();
3909
3e3420f6
PA
3910 fill_gregset (get_current_regcache (), &gregs, -1);
3911 note_data = elfcore_write_pstatus (obfd, note_data, note_size,
dfd4cc63 3912 ptid_get_pid (inferior_ptid),
3e3420f6 3913 stop_signal, &gregs);
3e3420f6 3914
be4d1333
MS
3915 thread_args.obfd = obfd;
3916 thread_args.note_data = note_data;
3917 thread_args.note_size = note_size;
651c8d2d 3918 thread_args.stop_signal = stop_signal;
3e43a32a
MS
3919 proc_iterate_over_threads (pi, procfs_corefile_thread_callback,
3920 &thread_args);
2689673f 3921 note_data = thread_args.note_data;
be4d1333 3922
13547ab6
DJ
3923 auxv_len = target_read_alloc (&current_target, TARGET_OBJECT_AUXV,
3924 NULL, &auxv);
4e73f23d
RM
3925 if (auxv_len > 0)
3926 {
3927 note_data = elfcore_write_note (obfd, note_data, note_size,
3928 "CORE", NT_AUXV, auxv, auxv_len);
3929 xfree (auxv);
3930 }
3931
be4d1333
MS
3932 return note_data;
3933}
be4d1333 3934/* =================== END GCORE .NOTE "MODULE" =================== */
This page took 2.177039 seconds and 4 git commands to generate.