36#include <sys/procfs.h>
38#include <sys/syscall.h>
39#include "gdbsupport/gdb_wait.h"
46#include "gdbsupport/scoped_fd.h"
47#include "gdbsupport/pathstuff.h"
48#include "gdbsupport/buildargv.h"
99 char **,
int)
override;
101 void kill ()
override;
105 void attach (
const char *,
int)
override;
108 void resume (ptid_t,
int,
enum gdb_signal)
override;
117 const gdb_byte *writebuf,
118 ULONGEST offset, ULONGEST len,
119 ULONGEST *xfered_len)
override;
121 void pass_signals (gdb::array_view<const unsigned char>)
override;
144#if PR_MODEL_NATIVE == PR_MODEL_LP64
146 const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
168#if PR_MODEL_NATIVE == PR_MODEL_LP64
174 const gdb_byte *endptr, CORE_ADDR *typep,
178 const gdb_byte *ptr = *readptr;
183 if (endptr - ptr < 8 * 2)
222#define CTL_PROC_NAME_FMT "/proc/%d/ctl"
223#define AS_PROC_NAME_FMT "/proc/%d/as"
224#define MAP_PROC_NAME_FMT "/proc/%d/map"
225#define STATUS_PROC_NAME_FMT "/proc/%d/status"
226#define MAX_PROC_NAME_SIZE sizeof("/proc/999999/lwp/0123456789/lwpstatus")
317 error (_(
"procfs: couldn't find pid %d "
318 "(kernel thread %d) in procinfo list."),
321 error (_(
"procfs: couldn't find pid %d in procinfo list."),
pid);
339 int retries_remaining,
status;
341 retries_remaining = 2;
347 if (
status >= 0 || retries_remaining == 0)
349 else if (errno != EINTR && errno != EAGAIN)
403 strcat (tmp,
"/lwpctl");
405 strcat (tmp,
"/ctl");
422 strcat (tmp,
"/lwpstatus");
424 strcat (tmp,
"/status");
506 for (ptr = *list; ptr; ptr = ptr->
next)
564 kill (pi->
pid, SIGKILL);
592 int step,
enum gdb_signal signo);
597 int saved_errno = errno;
598 warning (
"procfs: %s line %d, %ps: %s",
601 safe_strerror (saved_errno));
607 int saved_errno = errno;
608 error (
"procfs: %s line %d, %ps: %s",
611 safe_strerror (saved_errno));
639 sizeof (lwpstatus_t))
640 ==
sizeof (lwpstatus_t));
646 ==
sizeof (pstatus_t));
675 return pi->
prstatus.pr_lwp.pr_flags;
716 (gdb_byte *) &pi->
prstatus.pr_lwp.pr_info.si_addr);
730 return pi->
prstatus.pr_lwp.pr_nsysarg;
743 return (
long *) &pi->
prstatus.pr_lwp.pr_sysarg;
785 win = (write (pi->
ctl_fd, (
void *) &arg, sizeof (arg)) ==
sizeof (arg));
792 warning (_(
"procfs: modify_flag failed to turn %s %s"),
793 flag == PR_FORK ?
"PR_FORK" :
794 flag == PR_RLC ?
"PR_RLC" :
795 flag == PR_ASYNC ?
"PR_ASYNC" :
796 flag == PR_KLC ?
"PR_KLC" :
871 win = (write (pi->
ctl_fd, (
char *) &cmd, sizeof (cmd)) ==
sizeof (cmd));
897 win = (write (pi->
ctl_fd, (
char *) &cmd, sizeof (cmd)) ==
sizeof (cmd));
939 else if (signo != -1)
946 win = (write (pi->
ctl_fd, (
char *) &cmd, sizeof (cmd)) ==
sizeof (cmd));
970 char sigset[
sizeof (sigset_t)];
974 memcpy (&arg.sigset, sigset, sizeof (sigset_t));
976 win = (write (pi->
ctl_fd, (
char *) &arg, sizeof (arg)) ==
sizeof (arg));
982 warning (_(
"procfs: set_traced_signals failed"));
1005 char fltset[
sizeof (fltset_t)];
1009 memcpy (&arg.fltset, fltset, sizeof (fltset_t));
1011 win = (write (pi->
ctl_fd, (
char *) &arg, sizeof (arg)) ==
sizeof (arg));
1038 char sysset[
sizeof (sysset_t)];
1042 memcpy (&arg.sysset, sysset, sizeof (sysset_t));
1044 win = (write (pi->
ctl_fd, (
char *) &arg, sizeof (arg)) ==
sizeof (arg));
1069 struct gdb_proc_ctl_pcsexit {
1072 char sysset[
sizeof (sysset_t)];
1076 memcpy (&arg.sysset, sysset, sizeof (sysset_t));
1078 win = (write (pi->
ctl_fd, (
char *) &arg, sizeof (arg)) ==
sizeof (arg));
1106 char hold[
sizeof (sigset_t)];
1110 memcpy (&arg.hold, sighold, sizeof (sigset_t));
1111 win = (write (pi->
ctl_fd, (
void *) &arg, sizeof (arg)) ==
sizeof (arg));
1126 sigset_t *ret = NULL;
1140 ret = &pi->
prstatus.pr_lwp.pr_lwphold;
1142 memcpy (save, ret,
sizeof (sigset_t));
1153 sigset_t *ret = NULL;
1169 memcpy (save, ret,
sizeof (sigset_t));
1180 fltset_t *ret = NULL;
1196 memcpy (save, ret,
sizeof (fltset_t));
1207 sysset_t *ret = NULL;
1223 memcpy (save, ret,
sizeof (sysset_t));
1234 sysset_t *ret = NULL;
1250 memcpy (save, ret,
sizeof (sysset_t));
1274 win = (write (pi->
ctl_fd, (
void *) &cmd, sizeof (cmd)) ==
sizeof (cmd));
1294 char sinfo[
sizeof (siginfo_t)];
1314 && wait_status.
sig () == gdb_signal_from_host (signo)
1316 && pi->
prstatus.pr_lwp.pr_info.si_signo == signo
1320 memcpy (arg.sinfo, &pi->
prstatus.pr_lwp.pr_info, sizeof (siginfo_t));
1323 mysinfo.si_signo = signo;
1324 mysinfo.si_code = 0;
1325 mysinfo.si_pid = getpid ();
1326 mysinfo.si_uid = getuid ();
1327 memcpy (arg.sinfo, &mysinfo, sizeof (siginfo_t));
1331 win = (write (pi->
ctl_fd, (
void *) &arg, sizeof (arg)) ==
sizeof (arg));
1356 char sinfo[
sizeof (siginfo_t)];
1362 mysinfo.si_signo = 0;
1363 mysinfo.si_code = 0;
1364 mysinfo.si_errno = 0;
1365 mysinfo.si_pid = getpid ();
1366 mysinfo.si_uid = getuid ();
1367 memcpy (arg.sinfo, &mysinfo, sizeof (siginfo_t));
1369 win = (write (pi->
ctl_fd, (
void *) &arg, sizeof (arg)) ==
sizeof (arg));
1384 return &pi->
prstatus.pr_lwp.pr_reg;
1397 return &pi->
prstatus.pr_lwp.pr_fpreg;
1425 memcpy (&arg.gregs, gregs, sizeof (arg.gregs));
1426 win = (write (pi->
ctl_fd, (
void *) &arg, sizeof (arg)) ==
sizeof (arg));
1459 memcpy (&arg.fpregs, fpregs, sizeof (arg.fpregs));
1460 win = (write (pi->
ctl_fd, (
void *) &arg, sizeof (arg)) ==
sizeof (arg));
1487 win = (write (pi->
ctl_fd, (
char *) &cmd, sizeof (cmd)) ==
sizeof (cmd));
1523 gdb_assert (
sizeof (ptr) == ptr_type->
length ());
1525 (gdb_byte *) &ptr, addr);
1534 char watch[
sizeof (prwatch_t)];
1542 pwatch.pr_size = len;
1543 pwatch.pr_wflags = wflags;
1545 memcpy (arg.watch, &pwatch, sizeof (prwatch_t));
1546 return (write (pi->
ctl_fd, &arg, sizeof (arg)) ==
sizeof (arg));
1589 return pi->
prstatus.pr_lwp.pr_lwpid;
1599 if (thread && parent)
1612 struct dirent *direntry;
1634 strcat (pathname,
"/lwp");
1635 dirp.reset (opendir (pathname));
1637 proc_error (pi,
"update_threads, opendir", __LINE__);
1639 while ((direntry = readdir (dirp.get ())) != NULL)
1640 if (direntry->d_name[0] !=
'.')
1642 lwpid = atoi (&direntry->d_name[0]);
1645 proc_error (pi,
"update_threads, create_procinfo", __LINE__);
1680 for (thread = pi->
thread_list; thread != NULL; thread = next)
1682 next = thread->
next;
1683 retval = (*func) (pi, thread, ptr);
1703 int entry_or_exit,
int mode,
int from_tty);
1714 fltset_t traced_faults;
1715 sigset_t traced_signals;
1716 sysset_t *traced_syscall_entries;
1717 sysset_t *traced_syscall_exits;
1721 prfillset (&traced_faults);
1722 prdelset (&traced_faults, FLTPAGE);
1727 prfillset (&traced_signals);
1733 traced_syscall_entries = XNEW (sysset_t);
1734 premptyset (traced_syscall_entries);
1735 praddset (traced_syscall_entries, SYS_exit);
1736 praddset (traced_syscall_entries, SYS_lwp_exit);
1739 xfree (traced_syscall_entries);
1744 traced_syscall_exits = XNEW (sysset_t);
1745 premptyset (traced_syscall_exits);
1746 praddset (traced_syscall_exits, SYS_execve);
1747 praddset (traced_syscall_exits, SYS_lwp_create);
1748 praddset (traced_syscall_exits, SYS_lwp_exit);
1751 xfree (traced_syscall_exits);
1765 if (
pid == getpid ())
1766 error (_(
"Attaching GDB to itself is not a good idea..."));
1771 if (!
inf->target_is_pushed (
this))
1773 inf->push_target (
this);
1774 unpusher.reset (
this);
1782 unpusher.release ();
1807 perror (_(
"procfs: out of memory in 'attach'"));
1811 int saved_errno = errno;
1813 = string_printf (
"procfs:%d -- do_attach: couldn't open /proc "
1814 "file for process %d", __LINE__, ptid.pid ());
1815 errno = saved_errno;
1820 if (
proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
1843 dead_procinfo (pi,
"do_attach: couldn't save traced syscall entries.",
1846 dead_procinfo (pi,
"do_attach: couldn't save traced syscall exits.",
1858 inf->attach_flag =
true;
1865 ptid = ptid_t (pi->
pid, lwpid, 0);
1880 proc_warn (pi,
"do_detach, set_traced_signal", __LINE__);
1883 proc_warn (pi,
"do_detach, set_traced_faults", __LINE__);
1886 proc_warn (pi,
"do_detach, set_traced_sysentry", __LINE__);
1889 proc_warn (pi,
"do_detach, set_traced_sysexit", __LINE__);
1892 proc_warn (pi,
"do_detach, set_held_signals", __LINE__);
1894 if (
proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
1896 ||
query (_(
"Was stopped when attached, make it runnable again? ")))
1900 proc_warn (pi,
"do_detach, clear_current_fault", __LINE__);
1903 proc_warn (pi,
"do_detach, clear_current_signal", __LINE__);
1906 proc_warn (pi,
"do_detach, set_rlc", __LINE__);
1928 int pid = ptid.pid ();
1929 int tid = ptid.lwp ();
1935 error (_(
"procfs: fetch_registers failed to find procinfo for %s"),
1940 proc_error (pi,
"fetch_registers, get_gregs", __LINE__);
1955 proc_error (pi,
"fetch_registers, get_fpregs", __LINE__);
1977 int pid = ptid.pid ();
1978 int tid = ptid.lwp ();
1984 error (_(
"procfs: store_registers: failed to find procinfo for %s"),
1989 proc_error (pi,
"store_registers, get_gregs", __LINE__);
1993 proc_error (pi,
"store_registers, set_gregs", __LINE__);
2006 proc_error (pi,
"store_registers, get_fpregs", __LINE__);
2010 proc_error (pi,
"store_registers, set_fpregs", __LINE__);
2022 target_wait_flags options)
2028 ptid_t retval, temp_ptid;
2029 int why, what,
flags;
2036 retval = ptid_t (-1);
2054 if ((
flags & PR_STOPPED) && (why == PR_REQUESTED))
2058 if (!(
proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
2062 if (errno == ENOENT)
2067 wait_retval =
::wait (&wstat);
2070 if (wait_retval !=
inf->
pid)
2071 error (_(
"procfs: couldn't stop "
2072 "process %d: wait returned %d."),
2076 retval = ptid_t (wait_retval);
2078 else if (errno == EINTR)
2083 proc_error (pi,
"target_wait (wait_for_stop)", __LINE__);
2102 if (
flags & (PR_STOPPED | PR_ISTOP))
2106 if (
flags & PR_ASYNC)
2108 proc_error (pi,
"target_wait, unset_async", __LINE__);
2119 wstat = (what << 8) | 0177;
2122 if (what == SYS_lwp_exit)
2128 else if (what == SYS_exit)
2142 proc_error (pi,
"target_wait, run_process", __LINE__);
2144 if (
inf->attach_flag)
2150 retval = ptid_t (
inf->
pid);
2154 int temp =
::wait (&wstat);
2166 retval = ptid_t (temp);
2171 gdb_printf (_(
"procfs: trapped on entry to "));
2175 long i, nsysargs, *sysargs;
2180 if (nsysargs > 0 && sysargs != NULL)
2184 for (i = 0; i < nsysargs; i++)
2194 if (what == SYS_execve)
2200 wstat = (SIGTRAP << 8) | 0177;
2202 else if (what == SYS_lwp_create)
2217 temp_ptid = ptid_t (pi->
pid, temp_tid, 0);
2225 else if (what == SYS_lwp_exit)
2233 gdb_printf (_(
"procfs: trapped on exit from "));
2237 long i, nsysargs, *sysargs;
2242 if (nsysargs > 0 && sysargs != NULL)
2246 for (i = 0; i < nsysargs; i++)
2257 wstat = (SIGSTOP << 8) | 0177;
2274 temp_ptid = ptid_t (pi->
pid, temp_tid, 0);
2278 status->set_stopped (GDB_SIGNAL_0);
2283 wstat = (what << 8) | 0177;
2287 int signo = pi->
prstatus.pr_lwp.pr_info.si_signo;
2289 wstat = (signo << 8) | 0177;
2294 gdb_printf (_(
"child stopped for unknown reason:\n"));
2296 error (_(
"... giving up..."));
2301 if (retval.pid () > 0
2309 retval.lwp ()) == NULL)
2317 gdb_printf (
"procfs:%d -- process not stopped.\n",
2320 error (_(
"procfs: ...giving up..."));
2336 const char *annex, gdb_byte *readbuf,
2337 const gdb_byte *writebuf, ULONGEST offset,
2338 ULONGEST len, ULONGEST *xfered_len)
2347 offset, len, xfered_len);
2351 readbuf, writebuf, offset, len,
2361 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
2370 proc_warn (pi,
"xfer_memory, open_proc_files", __LINE__);
2374 if (lseek (pi->
as_fd, (off_t) memaddr,
SEEK_SET) != (off_t) memaddr)
2377 if (writebuf != NULL)
2380 nbytes = write (pi->
as_fd, writebuf, len);
2385 nbytes =
read (pi->
as_fd, readbuf, len);
2389 *xfered_len = nbytes;
2457 native_signo = gdb_signal_to_host (signo);
2467 if (scope_ptid.pid () != -1)
2471 thread =
find_procinfo (scope_ptid.pid (), scope_ptid.lwp ());
2474 if (thread->
tid != 0)
2479 proc_error (pi,
"target_resume, set_async", __LINE__);
2489 warning (_(
"resume: target already running. "
2490 "Pretend to resume, and hope for the best!"));
2516 prfillset (&signals);
2518 for (signo = 0; signo < NSIG; signo++)
2520 int target_signo = gdb_signal_from_host (signo);
2522 prdelset (&signals, signo);
2536 gdb_printf (_(
"\tUsing the running image of %s %s via /proc.\n"),
2537 inf->attach_flag?
"attached":
"child",
2553 proc_error (pi,
"unconditionally_kill, proc_kill", __LINE__);
2557 if (parent_pid == getpid ())
2622 perror (_(
"procfs: out of memory in 'init_inferior'"));
2625 proc_error (pi,
"init_inferior, open_proc_files", __LINE__);
2645 proc_error (pi,
"init_inferior, get_traced_signals", __LINE__);
2647 proc_error (pi,
"init_inferior, get_held_signals", __LINE__);
2649 proc_error (pi,
"init_inferior, get_traced_faults", __LINE__);
2651 proc_error (pi,
"init_inferior, get_traced_sysentry", __LINE__);
2653 proc_error (pi,
"init_inferior, get_traced_sysexit", __LINE__);
2657 proc_error (pi,
"init_inferior (procfs_debug_inferior)", fail);
2666 proc_error (pi,
"init_inferior, set_RLC", __LINE__);
2702 perror_with_name (_(
"procfs: create_procinfo failed in child"));
2706 proc_warn (pi,
"set_exec_trap, open_proc_files", __LINE__);
2713 exitset = XNEW (sysset_t);
2714 premptyset (exitset);
2715 praddset (exitset, SYS_execve);
2719 proc_warn (pi,
"set_exec_trap, set_traced_sysexit", __LINE__);
2728 proc_warn (pi,
"set_exec_trap, unset_inherit", __LINE__);
2734 proc_warn (pi,
"set_exec_trap, unset_RLC", __LINE__);
2761 const std::string &allargs,
2762 char **env,
int from_tty)
2764 const char *shell_file = get_shell ();
2768 if (strchr (shell_file,
'/') == NULL)
2796 const char *path = getenv (
"PATH");
2798 struct stat statbuf;
2801 path =
"/bin:/usr/bin";
2803 tryname = (
char *) alloca (strlen (path) + strlen (shell_file) + 2);
2804 for (p = path; p != NULL; p = p1 ? p1 + 1: NULL)
2806 p1 = strchr (p,
':');
2811 memcpy (tryname, p, len);
2812 tryname[len] =
'\0';
2813 strcat (tryname,
"/");
2814 strcat (tryname, shell_file);
2815 if (access (tryname, X_OK) < 0)
2817 if (stat (tryname, &statbuf) < 0)
2819 if (!S_ISREG (statbuf.st_mode))
2830 error (_(
"procfs:%d -- Can't find shell %s in PATH"),
2831 __LINE__, shell_file);
2833 shell_file = tryname;
2837 if (!
inf->target_is_pushed (
this))
2838 inf->push_target (
this);
2857 ptid_t gdb_threadid = ptid_t (pi->
pid, thread->
tid, 0);
2893 thread = ptid.lwp ();
2916 if (ptid.lwp () == 0)
2917 return string_printf (
"process %d", ptid.pid ());
2919 return string_printf (
"LWP %ld", ptid.lwp ());
2928 static char buf[PATH_MAX];
2929 char name[PATH_MAX];
2932 xsnprintf (
name,
sizeof (
name),
"/proc/%d/execname",
pid);
2933 scoped_fd fd (gdb_open_cloexec (
name, O_RDONLY, 0));
2934 if (fd.get () < 0 ||
read (fd.get (), buf, PATH_MAX - 1) < 0)
2940 xsnprintf (
name,
sizeof (
name),
"/proc/%d/path/a.out",
pid);
2941 len = readlink (
name, buf, PATH_MAX - 1);
2975 pflags = WA_READ | WA_WRITE;
2984 pflags |= WA_TRAPAFTER;
2993 if (errno == ESRCH && len == 0)
3018 if (
sizeof (
void *) != ptr_type->
length ())
3036 if (
proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
3060 enum target_hw_bp_type
type,
3079 enum target_hw_bp_type
type,
3113 int (*
func) (
struct prmap *map,
3118 struct prmap *prmaps;
3119 struct prmap *prmap;
3127 xsnprintf (pathname,
sizeof (pathname),
"/proc/%d/map", pi->
pid);
3129 scoped_fd map_fd (open (pathname, O_RDONLY));
3130 if (map_fd.get () < 0)
3131 proc_error (pi,
"iterate_over_mappings (open)", __LINE__);
3135 if (fstat (map_fd.get (), &sbuf) != 0)
3136 proc_error (pi,
"iterate_over_mappings (fstat)", __LINE__);
3138 nmap = sbuf.st_size /
sizeof (prmap_t);
3139 prmaps = (
struct prmap *) alloca ((nmap + 1) *
sizeof (*prmaps));
3140 if (
read (map_fd.get (), (
char *) prmaps, nmap *
sizeof (*prmaps))
3141 != (nmap *
sizeof (*prmaps)))
3142 proc_error (pi,
"iterate_over_mappings (read)", __LINE__);
3144 for (prmap = prmaps; nmap > 0; prmap++, nmap--)
3146 funcstat = (*func) (prmap, child_func, data);
3162 return (*
func) ((CORE_ADDR) map->pr_vaddr,
3164 (map->pr_mflags & MA_READ) != 0,
3165 (map->pr_mflags & MA_WRITE) != 0,
3166 (map->pr_mflags & MA_EXEC) != 0,
3198 static char asciiflags[8];
3200 strcpy (asciiflags,
"-------");
3201 if (
flags & MA_STACK)
3202 asciiflags[1] =
's';
3203 if (
flags & MA_BREAK)
3204 asciiflags[2] =
'b';
3205 if (
flags & MA_SHARED)
3206 asciiflags[3] =
's';
3207 if (
flags & MA_READ)
3208 asciiflags[4] =
'r';
3209 if (
flags & MA_WRITE)
3210 asciiflags[5] =
'w';
3211 if (
flags & MA_EXEC)
3212 asciiflags[6] =
'x';
3213 return (asciiflags);
3223 unsigned int pr_off;
3225 pr_off = (
unsigned int) map->pr_offset;
3228 gdb_printf (
"\t%#10lx %#10lx %#10lx %#10x %7s\n",
3229 (
unsigned long) map->pr_vaddr,
3230 (
unsigned long) map->pr_vaddr + map->pr_size - 1,
3231 (
unsigned long) map->pr_size,
3235 gdb_printf (
" %#18lx %#18lx %#10lx %#10x %7s\n",
3236 (
unsigned long) map->pr_vaddr,
3237 (
unsigned long) map->pr_vaddr + map->pr_size - 1,
3238 (
unsigned long) map->pr_size,
3253 gdb_printf (_(
"Mapped address spaces:\n\n"));
3296 error (_(
"Not supported on this target."));
3299 gdb_argv built_argv (args);
3300 for (
char *arg : built_argv)
3302 if (isdigit (arg[0]))
3304 pid = strtoul (arg, &tmp, 10);
3306 tid = strtoul (++tmp, NULL, 10);
3308 else if (arg[0] ==
'/')
3310 tid = strtoul (arg + 1, NULL, 10);
3318 error (_(
"No current process: you must name one."));
3324 if (process == NULL)
3329 temporary_procinfo.reset (process);
3331 proc_error (process,
"info proc, open_procinfo_files", __LINE__);
3341 if (
proc_flags (process) & (PR_STOPPED | PR_ISTOP))
3351 if (
proc_flags (thread) & (PR_STOPPED | PR_ISTOP))
3372 int mode,
int from_tty)
3376 if (entry_or_exit == PR_SYSENTRY)
3382 proc_error (pi,
"proc-trace, get_traced_sysset", __LINE__);
3385 praddset (sysset, syscallnum);
3387 prdelset (sysset, syscallnum);
3389 if (entry_or_exit == PR_SYSENTRY)
3392 proc_error (pi,
"proc-trace, set_traced_sysentry", __LINE__);
3397 proc_error (pi,
"proc-trace, set_traced_sysexit", __LINE__);
3407 error (_(
"you must be debugging a process to use this command."));
3409 if (args == NULL || args[0] == 0)
3413 if (isdigit (args[0]))
3415 const int syscallnum = atoi (args);
3450 _(
"Give a trace of entries into the syscall."));
3452 _(
"Give a trace of exits from the syscall."));
3454 _(
"Cancel a trace of entries into the syscall."));
3456 _(
"Cancel a trace of exits from the syscall."));
3483 gdb::unique_xmalloc_ptr<char> ¬e_data,
3484 int *
note_size,
enum gdb_signal stop_signal)
3489 unsigned long merged_pid;
3491 merged_pid =
ptid.lwp () << 16 |
ptid.pid ();
3501 note_data.reset (elfcore_write_lwpstatus (
obfd,
3502 note_data.release (),
3508 note_data.reset (elfcore_write_prfpreg (
obfd,
3509 note_data.release (),
3518 gdb::unique_xmalloc_ptr<char> &
note_data,
3538 ptid_t ptid = ptid_t (pi->
pid, thread->
tid, 0);
3551 if (info->stop_signal () != GDB_SIGNAL_0
3558static enum gdb_signal
3565 return info->stop_signal ();
3567 return GDB_SIGNAL_0;
3570gdb::unique_xmalloc_ptr<char>
3574 char fname[16] = {
'\0'};
3575 char psargs[80] = {
'\0'};
3577 gdb::unique_xmalloc_ptr<char> note_data;
3578 enum gdb_signal stop_signal;
3582 strncpy (fname, lbasename (
get_exec_file (0)),
sizeof (fname));
3583 fname[
sizeof (fname) - 1] = 0;
3585 psargs[
sizeof (psargs) - 1] = 0;
3588 if (!inf_args.empty () &&
3589 inf_args.length () < ((
int) sizeof (psargs) - (
int) strlen (psargs)))
3591 strncat (psargs,
" ",
3592 sizeof (psargs) - strlen (psargs));
3593 strncat (psargs, inf_args.c_str (),
3594 sizeof (psargs) - strlen (psargs));
3598 note_data.reset (elfcore_write_prpsinfo (
obfd,
3599 note_data.release (),
3607 note_data.reset (elfcore_write_pstatus (
obfd, note_data.release (),
note_size,
3609 stop_signal, &gregs));
3616 gdb::optional<gdb::byte_vector> auxv =
3619 if (auxv && !auxv->empty ())
3620 note_data.reset (elfcore_write_note (
obfd, note_data.release (),
note_size,
3621 "CORE", NT_AUXV, auxv->data (),
void supply_gregset(struct regcache *regcache, const gdb_gregset_t *gregsetp)
void fill_gregset(const struct regcache *regcache, gdb_gregset_t *gregsetp, int regno)
void supply_fpregset(struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
void fill_fpregset(const struct regcache *regcache, gdb_fpregset_t *fpregsetp, int regno)
struct gdbarch * target_gdbarch(void)
target_xfer_partial_ftype memory_xfer_auxv
ui_file_style style() const
void maybe_unpush_target()
const std::string & args() const
thread_info * find_thread(ptid_t ptid)
void store_registers(struct regcache *, int) override
void fetch_registers(struct regcache *, int) override
int find_memory_regions(find_memory_region_ftype func, void *data) override
gdb::unique_xmalloc_ptr< char > make_corefile_notes(bfd *, int *) override
int region_ok_for_hw_watchpoint(CORE_ADDR, int) override
bool stopped_data_address(CORE_ADDR *) override
int can_use_hw_breakpoint(enum bptype, int, int) override
void update_thread_list() override
ptid_t wait(ptid_t, struct target_waitstatus *, target_wait_flags) override
const char * pid_to_exec_file(int pid) override
int insert_watchpoint(CORE_ADDR, int, enum target_hw_bp_type, struct expression *) override
void pass_signals(gdb::array_view< const unsigned char >) override
int remove_watchpoint(CORE_ADDR, int, enum target_hw_bp_type, struct expression *) override
std::string pid_to_str(ptid_t) override
void mourn_inferior() override
void files_info() override
bool info_proc(const char *, enum info_proc_what) override
int auxv_parse(const gdb_byte **readptr, const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) override
bool thread_alive(ptid_t ptid) override
enum target_xfer_status xfer_partial(enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) override
void attach(const char *, int) override
void detach(inferior *inf, int) override
thread_control_capabilities get_thread_control_capabilities() override
void procfs_init_inferior(int pid)
void create_inferior(const char *, const std::string &, char **, int) override
bool stopped_by_watchpoint() override
void resume(ptid_t, int, enum gdb_signal) override
void error_no_arg(const char *why)
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc)
cli_style_option file_name_style
const char * get_exec_file(int err)
int(* find_memory_region_ftype)(CORE_ADDR addr, unsigned long size, int read, int write, int exec, int modified, bool memory_tagged, void *data)
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
ssize_t read(int fd, void *buf, size_t count)
ptid_t gdb_startup_inferior(pid_t pid, int num_traps)
pid_t fork_inferior(const char *exec_file_arg, const std::string &allargs, char **env, void(*traceme_fun)(), gdb::function_view< void(int)> init_trace_fun, void(*pre_trace_fun)(), const char *shell_file_arg, void(*exec_fun)(const char *file, char *const *argv, char *const *env))
#define START_INFERIOR_TRAPS_EXPECTED
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
int gdbarch_have_nonsteppable_watchpoint(struct gdbarch *gdbarch)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
CORE_ADDR gdbarch_pointer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
int gdbarch_addr_bit(struct gdbarch *gdbarch)
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
void gdbarch_address_to_pointer(struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
int gdbarch_fp0_regnum(struct gdbarch *gdbarch)
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
struct thread_info * add_thread(process_stratum_target *targ, ptid_t ptid)
struct thread_info * add_thread_silent(process_stratum_target *targ, ptid_t ptid)
void delete_thread(thread_info *thread)
void switch_to_thread(struct thread_info *thr)
struct thread_info * iterate_over_threads(thread_callback_func, void *)
void thread_change_ptid(process_stratum_target *targ, ptid_t old_ptid, ptid_t new_ptid)
bool in_thread_list(process_stratum_target *targ, ptid_t ptid)
void switch_to_no_thread()
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
GDB_FPREGSET_T gdb_fpregset_t
GDB_GREGSET_T gdb_gregset_t
target_waitstatus host_status_to_waitstatus(int hoststatus)
void add_inf_child_target(inf_child_target *target)
void inferior_appeared(struct inferior *inf, int pid)
void detach_inferior(inferior *inf)
struct inferior * current_inferior(void)
void set_sigint_trap(void)
void generic_mourn_inferior(void)
void clear_sigint_trap(void)
void get_last_target_status(process_stratum_target **target, ptid_t *ptid, target_waitstatus *status)
void proc_prettyprint_syscall(int num, int verbose)
void proc_prettyprint_flags(unsigned long flags, int verbose)
#define PROC_PRETTYFPRINT_STATUS(X, Y, Z, T)
void proc_prettyprint_why(unsigned long why, unsigned long what, int verbose)
static int proc_get_nthreads(procinfo *pi)
static int proc_parent_pid(procinfo *pi)
static void proc_error(procinfo *pi, const char *func, int line)
static int invalidate_cache(procinfo *parent, procinfo *pi, void *ptr)
static int proc_unset_async(procinfo *pi)
static void procfs_pre_trace(void)
static int proc_set_gregs(procinfo *pi)
void _initialize_procfs()
static int proc_watchpoint_address(procinfo *pi, CORE_ADDR *addr)
static int proc_delete_dead_threads(procinfo *parent, procinfo *thread, void *ignore)
static int iterate_over_mappings(procinfo *pi, find_memory_region_ftype child_func, void *data, int(*func)(struct prmap *map, find_memory_region_ftype child_func, void *data))
static long * proc_sysargs(procinfo *pi)
ptid_t procfs_first_available(void)
static int proc_set_traced_sysexit(procinfo *pi, sysset_t *sysset)
static procinfo * find_procinfo_or_die(int pid, int tid)
static void procfs_do_thread_registers(bfd *obfd, ptid_t ptid, gdb::unique_xmalloc_ptr< char > ¬e_data, int *note_size, enum gdb_signal stop_signal)
static int proc_set_held_signals(procinfo *pi, sigset_t *sighold)
static int proc_set_fpregs(procinfo *pi)
static int info_mappings_callback(struct prmap *map, find_memory_region_ftype ignore, void *unused)
static fltset_t * proc_get_traced_faults(procinfo *pi, fltset_t *save)
static enum target_xfer_status procfs_xfer_memory(gdb_byte *, const gdb_byte *, ULONGEST, ULONGEST, ULONGEST *)
static void proc_untrace_sysentry_cmd(const char *args, int from_tty)
static procinfo * create_procinfo(int pid, int tid)
#define MAX_PROC_NAME_SIZE
static sigset_t * proc_get_traced_signals(procinfo *pi, sigset_t *save)
static void dead_procinfo(procinfo *p, const char *msg, int killp)
static procinfo * find_procinfo(int pid, int tid)
static procfs_target the_procfs_target
static int proc_iterate_over_threads(procinfo *pi, int(*func)(procinfo *, procinfo *, void *), void *ptr)
static void proc_trace_sysentry_cmd(const char *args, int from_tty)
static int procfs_notice_thread(procinfo *pi, procinfo *thread, void *ptr)
static gdb_gregset_t * proc_get_gregs(procinfo *pi)
static void proc_trace_syscalls(const char *args, int from_tty, int entry_or_exit, int mode)
static void proc_untrace_sysexit_cmd(const char *args, int from_tty)
static int proc_get_status(procinfo *pi)
static int proc_stop_process(procinfo *pi)
static int proc_clear_current_fault(procinfo *pi)
static int open_procinfo_files(procinfo *p, int which)
static int procfs_debug_inferior(procinfo *pi)
static int proc_kill(procinfo *pi, int signo)
static int proc_set_traced_sysentry(procinfo *pi, sysset_t *sysset)
static int open_with_retry(const char *pathname, int flags)
static void unconditionally_kill_inferior(procinfo *pi)
static int proc_what(procinfo *pi)
static procinfo * procinfo_list
static int proc_nsysarg(procinfo *pi)
static enum gdb_signal find_stop_signal(void)
static int proc_set_async(procinfo *pi)
static sigset_t * proc_get_held_signals(procinfo *pi, sigset_t *save)
static int proc_update_threads(procinfo *pi)
static int proc_get_current_thread(procinfo *pi)
static int procfs_corefile_thread_callback(procinfo *pi, procinfo *thread, void *data)
static void procfs_set_exec_trap(void)
static void * procfs_address_to_host_pointer(CORE_ADDR addr)
static int proc_set_watchpoint(procinfo *pi, CORE_ADDR addr, int len, int wflags)
static void do_attach(ptid_t ptid)
static int proc_unset_run_on_last_close(procinfo *pi)
static int find_memory_regions_callback(struct prmap *map, find_memory_region_ftype func, void *data)
static gdb_fpregset_t * proc_get_fpregs(procinfo *pi)
static int proc_modify_flag(procinfo *pi, long flag, long mode)
static int proc_unset_inherit_on_fork(procinfo *pi)
static int proc_set_traced_signals(procinfo *pi, sigset_t *sigset)
static void proc_resume(procinfo *pi, ptid_t scope_ptid, int step, enum gdb_signal signo)
static int proc_wait_for_stop(procinfo *pi)
static int procfs_set_watchpoint(ptid_t ptid, CORE_ADDR addr, int len, int rwflag, int after)
static int proc_clear_current_signal(procinfo *pi)
static int proc_set_current_signal(procinfo *pi, int signo)
static int proc_run_process(procinfo *pi, int step, int signo)
static void info_proc_mappings(procinfo *pi, int summary)
static void close_procinfo_files(procinfo *p)
static void proc_warn(procinfo *pi, const char *func, int line)
static void proc_trace_sysexit_cmd(const char *args, int from_tty)
static int proc_set_run_on_last_close(procinfo *pi)
static int find_signalled_thread(struct thread_info *info, void *data)
static char * mappingflags(long flags)
static void proc_trace_syscalls_1(procinfo *pi, int syscallnum, int entry_or_exit, int mode, int from_tty)
static long proc_flags(procinfo *pi)
std::unique_ptr< procinfo, procinfo_deleter > procinfo_up
static sysset_t * proc_get_traced_sysentry(procinfo *pi, sysset_t *save)
static void destroy_procinfo(procinfo *p)
static int proc_set_traced_faults(procinfo *pi, fltset_t *fltset)
static int proc_why(procinfo *pi)
static void destroy_one_procinfo(procinfo **list, procinfo *pi)
static sysset_t * proc_get_traced_sysexit(procinfo *pi, sysset_t *save)
struct regcache * get_current_regcache(void)
struct regcache * get_thread_regcache(process_stratum_target *target, ptid_t ptid)
void(* func)(remote_target *remote, char *)
struct type * builtin_data_ptr
enum gdb_signal stop_signal
procfs_corefile_thread_data(bfd *obfd, gdb::unique_xmalloc_ptr< char > ¬e_data, int *note_size, gdb_signal stop_signal)
gdb::unique_xmalloc_ptr< char > & note_data
void operator()(procinfo *pi) const
sysset_t * saved_entryset
char pathname[MAX_PROC_NAME_SIZE]
struct procinfo * thread_list
target_ops * beneath() const
virtual enum target_xfer_status xfer_partial(enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) TARGET_DEFAULT_RETURN(TARGET_XFER_E_IO)
target_waitkind kind() const
void target_announce_detach(int from_tty)
bool target_have_steppable_watchpoint()
void target_fetch_registers(struct regcache *regcache, int regno)
gdb::optional< gdb::byte_vector > target_read_alloc(struct target_ops *ops, enum target_object object, const char *annex)
void target_announce_attach(int from_tty, int pid)
std::string target_pid_to_str(ptid_t ptid)
void target_mourn_inferior(ptid_t ptid)
std::unique_ptr< struct target_ops, target_unpusher > target_unpush_up
thread_control_capabilities
static styled_string_s * styled_string(const ui_file_style &style, const char *str, styled_string_s &&tmp={})
int query(const char *ctlstr,...)
void gdb_printf(struct ui_file *stream, const char *format,...)
void gdb_flush(struct ui_file *stream)
void warning_filename_and_errno(const char *filename, int saved_errno)
int parse_pid_to_attach(const char *args)
@ TARGET_WAITKIND_STOPPED