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"
98 char **,
int)
override;
100 void kill ()
override;
104 void attach (
const char *,
int)
override;
107 void resume (ptid_t,
int,
enum gdb_signal)
override;
116 const gdb_byte *writebuf,
117 ULONGEST offset, ULONGEST len,
118 ULONGEST *xfered_len)
override;
120 void pass_signals (gdb::array_view<const unsigned char>)
override;
143#if PR_MODEL_NATIVE == PR_MODEL_LP64
145 const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
167#if PR_MODEL_NATIVE == PR_MODEL_LP64
173 const gdb_byte *endptr, CORE_ADDR *typep,
177 const gdb_byte *ptr = *readptr;
182 if (endptr - ptr < 8 * 2)
221#define CTL_PROC_NAME_FMT "/proc/%d/ctl"
222#define AS_PROC_NAME_FMT "/proc/%d/as"
223#define MAP_PROC_NAME_FMT "/proc/%d/map"
224#define STATUS_PROC_NAME_FMT "/proc/%d/status"
225#define MAX_PROC_NAME_SIZE sizeof("/proc/999999/lwp/0123456789/lwpstatus")
318 error (_(
"procfs: couldn't find pid %d "
319 "(kernel thread %d) in procinfo list."),
322 error (_(
"procfs: couldn't find pid %d in procinfo list."),
pid);
340 int retries_remaining,
status;
342 retries_remaining = 2;
348 if (
status >= 0 || retries_remaining == 0)
350 else if (errno != EINTR && errno != EAGAIN)
404 strcat (tmp,
"/lwpctl");
406 strcat (tmp,
"/ctl");
423 strcat (tmp,
"/lwpstatus");
425 strcat (tmp,
"/status");
507 for (ptr = *list; ptr; ptr = ptr->
next)
565 kill (pi->
pid, SIGKILL);
596 xsnprintf (
errmsg,
sizeof (
errmsg),
"procfs: %s line %d, %s",
604 xsnprintf (
errmsg,
sizeof (
errmsg),
"procfs: %s line %d, %s",
634 sizeof (lwpstatus_t))
635 ==
sizeof (lwpstatus_t));
641 ==
sizeof (pstatus_t));
670 return pi->
prstatus.pr_lwp.pr_flags;
711 (gdb_byte *) &pi->
prstatus.pr_lwp.pr_info.si_addr);
725 return pi->
prstatus.pr_lwp.pr_nsysarg;
738 return (
long *) &pi->
prstatus.pr_lwp.pr_sysarg;
780 win = (write (pi->
ctl_fd, (
void *) &arg, sizeof (arg)) ==
sizeof (arg));
787 warning (_(
"procfs: modify_flag failed to turn %s %s"),
788 flag == PR_FORK ?
"PR_FORK" :
789 flag == PR_RLC ?
"PR_RLC" :
790 flag == PR_ASYNC ?
"PR_ASYNC" :
791 flag == PR_KLC ?
"PR_KLC" :
866 win = (write (pi->
ctl_fd, (
char *) &cmd, sizeof (cmd)) ==
sizeof (cmd));
892 win = (write (pi->
ctl_fd, (
char *) &cmd, sizeof (cmd)) ==
sizeof (cmd));
934 else if (signo != -1)
941 win = (write (pi->
ctl_fd, (
char *) &cmd, sizeof (cmd)) ==
sizeof (cmd));
965 char sigset[
sizeof (sigset_t)];
969 memcpy (&arg.sigset, sigset, sizeof (sigset_t));
971 win = (write (pi->
ctl_fd, (
char *) &arg, sizeof (arg)) ==
sizeof (arg));
977 warning (_(
"procfs: set_traced_signals failed"));
1000 char fltset[
sizeof (fltset_t)];
1004 memcpy (&arg.fltset, fltset, sizeof (fltset_t));
1006 win = (write (pi->
ctl_fd, (
char *) &arg, sizeof (arg)) ==
sizeof (arg));
1033 char sysset[
sizeof (sysset_t)];
1037 memcpy (&arg.sysset, sysset, sizeof (sysset_t));
1039 win = (write (pi->
ctl_fd, (
char *) &arg, sizeof (arg)) ==
sizeof (arg));
1064 struct gdb_proc_ctl_pcsexit {
1067 char sysset[
sizeof (sysset_t)];
1071 memcpy (&arg.sysset, sysset, sizeof (sysset_t));
1073 win = (write (pi->
ctl_fd, (
char *) &arg, sizeof (arg)) ==
sizeof (arg));
1101 char hold[
sizeof (sigset_t)];
1105 memcpy (&arg.hold, sighold, sizeof (sigset_t));
1106 win = (write (pi->
ctl_fd, (
void *) &arg, sizeof (arg)) ==
sizeof (arg));
1121 sigset_t *ret = NULL;
1135 ret = &pi->
prstatus.pr_lwp.pr_lwphold;
1137 memcpy (save, ret,
sizeof (sigset_t));
1148 sigset_t *ret = NULL;
1164 memcpy (save, ret,
sizeof (sigset_t));
1175 fltset_t *ret = NULL;
1191 memcpy (save, ret,
sizeof (fltset_t));
1202 sysset_t *ret = NULL;
1218 memcpy (save, ret,
sizeof (sysset_t));
1229 sysset_t *ret = NULL;
1245 memcpy (save, ret,
sizeof (sysset_t));
1269 win = (write (pi->
ctl_fd, (
void *) &cmd, sizeof (cmd)) ==
sizeof (cmd));
1289 char sinfo[
sizeof (siginfo_t)];
1309 && wait_status.
sig () == gdb_signal_from_host (signo)
1311 && pi->
prstatus.pr_lwp.pr_info.si_signo == signo
1315 memcpy (arg.sinfo, &pi->
prstatus.pr_lwp.pr_info, sizeof (siginfo_t));
1318 mysinfo.si_signo = signo;
1319 mysinfo.si_code = 0;
1320 mysinfo.si_pid = getpid ();
1321 mysinfo.si_uid = getuid ();
1322 memcpy (arg.sinfo, &mysinfo, sizeof (siginfo_t));
1326 win = (write (pi->
ctl_fd, (
void *) &arg, sizeof (arg)) ==
sizeof (arg));
1351 char sinfo[
sizeof (siginfo_t)];
1357 mysinfo.si_signo = 0;
1358 mysinfo.si_code = 0;
1359 mysinfo.si_errno = 0;
1360 mysinfo.si_pid = getpid ();
1361 mysinfo.si_uid = getuid ();
1362 memcpy (arg.sinfo, &mysinfo, sizeof (siginfo_t));
1364 win = (write (pi->
ctl_fd, (
void *) &arg, sizeof (arg)) ==
sizeof (arg));
1379 return &pi->
prstatus.pr_lwp.pr_reg;
1392 return &pi->
prstatus.pr_lwp.pr_fpreg;
1420 memcpy (&arg.gregs, gregs, sizeof (arg.gregs));
1421 win = (write (pi->
ctl_fd, (
void *) &arg, sizeof (arg)) ==
sizeof (arg));
1454 memcpy (&arg.fpregs, fpregs, sizeof (arg.fpregs));
1455 win = (write (pi->
ctl_fd, (
void *) &arg, sizeof (arg)) ==
sizeof (arg));
1482 win = (write (pi->
ctl_fd, (
char *) &cmd, sizeof (cmd)) ==
sizeof (cmd));
1518 gdb_assert (
sizeof (ptr) == ptr_type->
length ());
1520 (gdb_byte *) &ptr, addr);
1529 char watch[
sizeof (prwatch_t)];
1537 pwatch.pr_size = len;
1538 pwatch.pr_wflags = wflags;
1540 memcpy (arg.watch, &pwatch, sizeof (prwatch_t));
1541 return (write (pi->
ctl_fd, &arg, sizeof (arg)) ==
sizeof (arg));
1584 return pi->
prstatus.pr_lwp.pr_lwpid;
1594 if (thread && parent)
1607 struct dirent *direntry;
1629 strcat (pathname,
"/lwp");
1630 dirp.reset (opendir (pathname));
1632 proc_error (pi,
"update_threads, opendir", __LINE__);
1634 while ((direntry = readdir (dirp.get ())) != NULL)
1635 if (direntry->d_name[0] !=
'.')
1637 lwpid = atoi (&direntry->d_name[0]);
1640 proc_error (pi,
"update_threads, create_procinfo", __LINE__);
1675 for (thread = pi->
thread_list; thread != NULL; thread = next)
1677 next = thread->
next;
1678 retval = (*func) (pi, thread, ptr);
1698 int entry_or_exit,
int mode,
int from_tty);
1709 fltset_t traced_faults;
1710 sigset_t traced_signals;
1711 sysset_t *traced_syscall_entries;
1712 sysset_t *traced_syscall_exits;
1716 prfillset (&traced_faults);
1717 prdelset (&traced_faults, FLTPAGE);
1722 prfillset (&traced_signals);
1728 traced_syscall_entries = XNEW (sysset_t);
1729 premptyset (traced_syscall_entries);
1730 praddset (traced_syscall_entries, SYS_exit);
1731 praddset (traced_syscall_entries, SYS_lwp_exit);
1734 xfree (traced_syscall_entries);
1739 traced_syscall_exits = XNEW (sysset_t);
1740 premptyset (traced_syscall_exits);
1741 praddset (traced_syscall_exits, SYS_execve);
1742 praddset (traced_syscall_exits, SYS_lwp_create);
1743 praddset (traced_syscall_exits, SYS_lwp_exit);
1746 xfree (traced_syscall_exits);
1760 if (
pid == getpid ())
1761 error (_(
"Attaching GDB to itself is not a good idea..."));
1766 if (!
inf->target_is_pushed (
this))
1768 inf->push_target (
this);
1769 unpusher.reset (
this);
1777 unpusher.release ();
1802 perror (_(
"procfs: out of memory in 'attach'"));
1808 "do_attach: couldn't open /proc file for process %d",
1814 if (
proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
1837 dead_procinfo (pi,
"do_attach: couldn't save traced syscall entries.",
1840 dead_procinfo (pi,
"do_attach: couldn't save traced syscall exits.",
1852 inf->attach_flag =
true;
1859 ptid = ptid_t (pi->
pid, lwpid, 0);
1874 proc_warn (pi,
"do_detach, set_traced_signal", __LINE__);
1877 proc_warn (pi,
"do_detach, set_traced_faults", __LINE__);
1880 proc_warn (pi,
"do_detach, set_traced_sysentry", __LINE__);
1883 proc_warn (pi,
"do_detach, set_traced_sysexit", __LINE__);
1886 proc_warn (pi,
"do_detach, set_held_signals", __LINE__);
1888 if (
proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
1890 ||
query (_(
"Was stopped when attached, make it runnable again? ")))
1894 proc_warn (pi,
"do_detach, clear_current_fault", __LINE__);
1897 proc_warn (pi,
"do_detach, clear_current_signal", __LINE__);
1900 proc_warn (pi,
"do_detach, set_rlc", __LINE__);
1922 int pid = ptid.pid ();
1923 int tid = ptid.lwp ();
1929 error (_(
"procfs: fetch_registers failed to find procinfo for %s"),
1934 proc_error (pi,
"fetch_registers, get_gregs", __LINE__);
1949 proc_error (pi,
"fetch_registers, get_fpregs", __LINE__);
1971 int pid = ptid.pid ();
1972 int tid = ptid.lwp ();
1978 error (_(
"procfs: store_registers: failed to find procinfo for %s"),
1983 proc_error (pi,
"store_registers, get_gregs", __LINE__);
1987 proc_error (pi,
"store_registers, set_gregs", __LINE__);
2000 proc_error (pi,
"store_registers, get_fpregs", __LINE__);
2004 proc_error (pi,
"store_registers, set_fpregs", __LINE__);
2016 target_wait_flags options)
2022 ptid_t retval, temp_ptid;
2023 int why, what,
flags;
2030 retval = ptid_t (-1);
2048 if ((
flags & PR_STOPPED) && (why == PR_REQUESTED))
2052 if (!(
proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
2056 if (errno == ENOENT)
2061 wait_retval =
::wait (&wstat);
2064 if (wait_retval !=
inf->
pid)
2065 error (_(
"procfs: couldn't stop "
2066 "process %d: wait returned %d."),
2070 retval = ptid_t (wait_retval);
2072 else if (errno == EINTR)
2077 proc_error (pi,
"target_wait (wait_for_stop)", __LINE__);
2096 if (
flags & (PR_STOPPED | PR_ISTOP))
2100 if (
flags & PR_ASYNC)
2102 proc_error (pi,
"target_wait, unset_async", __LINE__);
2113 wstat = (what << 8) | 0177;
2116 if (what == SYS_lwp_exit)
2125 else if (what == SYS_exit)
2139 proc_error (pi,
"target_wait, run_process", __LINE__);
2141 if (
inf->attach_flag)
2147 retval = ptid_t (
inf->
pid);
2151 int temp =
::wait (&wstat);
2163 retval = ptid_t (temp);
2168 gdb_printf (_(
"procfs: trapped on entry to "));
2172 long i, nsysargs, *sysargs;
2177 if (nsysargs > 0 && sysargs != NULL)
2181 for (i = 0; i < nsysargs; i++)
2192 if (what == SYS_execve)
2198 wstat = (SIGTRAP << 8) | 0177;
2200 else if (what == SYS_lwp_create)
2215 temp_ptid = ptid_t (pi->
pid, temp_tid, 0);
2223 else if (what == SYS_lwp_exit)
2234 gdb_printf (_(
"procfs: trapped on exit from "));
2238 long i, nsysargs, *sysargs;
2243 if (nsysargs > 0 && sysargs != NULL)
2247 for (i = 0; i < nsysargs; i++)
2258 wstat = (SIGSTOP << 8) | 0177;
2275 temp_ptid = ptid_t (pi->
pid, temp_tid, 0);
2279 status->set_stopped (GDB_SIGNAL_0);
2284 wstat = (what << 8) | 0177;
2288 int signo = pi->
prstatus.pr_lwp.pr_info.si_signo;
2290 wstat = (signo << 8) | 0177;
2295 gdb_printf (_(
"child stopped for unknown reason:\n"));
2297 error (_(
"... giving up..."));
2302 if (retval.pid () > 0
2310 retval.lwp ()) == NULL)
2318 gdb_printf (
"procfs:%d -- process not stopped.\n",
2321 error (_(
"procfs: ...giving up..."));
2337 const char *annex, gdb_byte *readbuf,
2338 const gdb_byte *writebuf, ULONGEST offset,
2339 ULONGEST len, ULONGEST *xfered_len)
2348 offset, len, xfered_len);
2352 readbuf, writebuf, offset, len,
2362 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
2371 proc_warn (pi,
"xfer_memory, open_proc_files", __LINE__);
2375 if (lseek (pi->
as_fd, (off_t) memaddr,
SEEK_SET) != (off_t) memaddr)
2378 if (writebuf != NULL)
2381 nbytes = write (pi->
as_fd, writebuf, len);
2386 nbytes =
read (pi->
as_fd, readbuf, len);
2390 *xfered_len = nbytes;
2466 native_signo = gdb_signal_to_host (signo);
2476 if (ptid.pid () != -1)
2483 if (thread->
tid != 0)
2488 proc_error (pi,
"target_resume, set_async", __LINE__);
2498 warning (_(
"resume: target already running. "
2499 "Pretend to resume, and hope for the best!"));
2514 prfillset (&signals);
2516 for (signo = 0; signo < NSIG; signo++)
2518 int target_signo = gdb_signal_from_host (signo);
2520 prdelset (&signals, signo);
2534 gdb_printf (_(
"\tUsing the running image of %s %s via /proc.\n"),
2535 inf->attach_flag?
"attached":
"child",
2551 proc_error (pi,
"unconditionally_kill, proc_kill", __LINE__);
2555 if (parent_pid == getpid ())
2620 perror (_(
"procfs: out of memory in 'init_inferior'"));
2623 proc_error (pi,
"init_inferior, open_proc_files", __LINE__);
2643 proc_error (pi,
"init_inferior, get_traced_signals", __LINE__);
2645 proc_error (pi,
"init_inferior, get_held_signals", __LINE__);
2647 proc_error (pi,
"init_inferior, get_traced_faults", __LINE__);
2649 proc_error (pi,
"init_inferior, get_traced_sysentry", __LINE__);
2651 proc_error (pi,
"init_inferior, get_traced_sysexit", __LINE__);
2655 proc_error (pi,
"init_inferior (procfs_debug_inferior)", fail);
2664 proc_error (pi,
"init_inferior, set_RLC", __LINE__);
2704 proc_warn (pi,
"set_exec_trap, open_proc_files", __LINE__);
2711 exitset = XNEW (sysset_t);
2712 premptyset (exitset);
2713 praddset (exitset, SYS_execve);
2717 proc_warn (pi,
"set_exec_trap, set_traced_sysexit", __LINE__);
2726 proc_warn (pi,
"set_exec_trap, unset_inherit", __LINE__);
2732 proc_warn (pi,
"set_exec_trap, unset_RLC", __LINE__);
2759 const std::string &allargs,
2760 char **env,
int from_tty)
2762 const char *shell_file = get_shell ();
2766 if (strchr (shell_file,
'/') == NULL)
2794 const char *path = getenv (
"PATH");
2796 struct stat statbuf;
2799 path =
"/bin:/usr/bin";
2801 tryname = (
char *) alloca (strlen (path) + strlen (shell_file) + 2);
2802 for (p = path; p != NULL; p = p1 ? p1 + 1: NULL)
2804 p1 = strchr (p,
':');
2809 memcpy (tryname, p, len);
2810 tryname[len] =
'\0';
2811 strcat (tryname,
"/");
2812 strcat (tryname, shell_file);
2813 if (access (tryname, X_OK) < 0)
2815 if (stat (tryname, &statbuf) < 0)
2817 if (!S_ISREG (statbuf.st_mode))
2828 error (_(
"procfs:%d -- Can't find shell %s in PATH"),
2829 __LINE__, shell_file);
2831 shell_file = tryname;
2835 if (!
inf->target_is_pushed (
this))
2836 inf->push_target (
this);
2855 ptid_t gdb_threadid = ptid_t (pi->
pid, thread->
tid, 0);
2891 thread = ptid.lwp ();
2914 if (ptid.lwp () == 0)
2915 return string_printf (
"process %d", ptid.pid ());
2917 return string_printf (
"LWP %ld", ptid.lwp ());
2926 static char buf[PATH_MAX];
2927 char name[PATH_MAX];
2930 xsnprintf (
name,
sizeof (
name),
"/proc/%d/execname",
pid);
2931 scoped_fd fd (gdb_open_cloexec (
name, O_RDONLY, 0));
2932 if (fd.get () < 0 ||
read (fd.get (), buf, PATH_MAX - 1) < 0)
2938 xsnprintf (
name,
sizeof (
name),
"/proc/%d/path/a.out",
pid);
2939 len = readlink (
name, buf, PATH_MAX - 1);
2973 pflags = WA_READ | WA_WRITE;
2982 pflags |= WA_TRAPAFTER;
2991 if (errno == ESRCH && len == 0)
3016 if (
sizeof (
void *) != ptr_type->
length ())
3034 if (
proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
3058 enum target_hw_bp_type
type,
3077 enum target_hw_bp_type
type,
3111 int (*
func) (
struct prmap *map,
3116 struct prmap *prmaps;
3117 struct prmap *prmap;
3125 xsnprintf (pathname,
sizeof (pathname),
"/proc/%d/map", pi->
pid);
3127 scoped_fd map_fd (open (pathname, O_RDONLY));
3128 if (map_fd.get () < 0)
3129 proc_error (pi,
"iterate_over_mappings (open)", __LINE__);
3133 if (fstat (map_fd.get (), &sbuf) != 0)
3134 proc_error (pi,
"iterate_over_mappings (fstat)", __LINE__);
3136 nmap = sbuf.st_size /
sizeof (prmap_t);
3137 prmaps = (
struct prmap *) alloca ((nmap + 1) *
sizeof (*prmaps));
3138 if (
read (map_fd.get (), (
char *) prmaps, nmap *
sizeof (*prmaps))
3139 != (nmap *
sizeof (*prmaps)))
3140 proc_error (pi,
"iterate_over_mappings (read)", __LINE__);
3142 for (prmap = prmaps; nmap > 0; prmap++, nmap--)
3144 funcstat = (*func) (prmap, child_func, data);
3160 return (*
func) ((CORE_ADDR) map->pr_vaddr,
3162 (map->pr_mflags & MA_READ) != 0,
3163 (map->pr_mflags & MA_WRITE) != 0,
3164 (map->pr_mflags & MA_EXEC) != 0,
3196 static char asciiflags[8];
3198 strcpy (asciiflags,
"-------");
3199 if (
flags & MA_STACK)
3200 asciiflags[1] =
's';
3201 if (
flags & MA_BREAK)
3202 asciiflags[2] =
'b';
3203 if (
flags & MA_SHARED)
3204 asciiflags[3] =
's';
3205 if (
flags & MA_READ)
3206 asciiflags[4] =
'r';
3207 if (
flags & MA_WRITE)
3208 asciiflags[5] =
'w';
3209 if (
flags & MA_EXEC)
3210 asciiflags[6] =
'x';
3211 return (asciiflags);
3221 unsigned int pr_off;
3223 pr_off = (
unsigned int) map->pr_offset;
3226 gdb_printf (
"\t%#10lx %#10lx %#10lx %#10x %7s\n",
3227 (
unsigned long) map->pr_vaddr,
3228 (
unsigned long) map->pr_vaddr + map->pr_size - 1,
3229 (
unsigned long) map->pr_size,
3233 gdb_printf (
" %#18lx %#18lx %#10lx %#10x %7s\n",
3234 (
unsigned long) map->pr_vaddr,
3235 (
unsigned long) map->pr_vaddr + map->pr_size - 1,
3236 (
unsigned long) map->pr_size,
3251 gdb_printf (_(
"Mapped address spaces:\n\n"));
3294 error (_(
"Not supported on this target."));
3297 gdb_argv built_argv (args);
3298 for (
char *arg : built_argv)
3300 if (isdigit (arg[0]))
3302 pid = strtoul (arg, &tmp, 10);
3304 tid = strtoul (++tmp, NULL, 10);
3306 else if (arg[0] ==
'/')
3308 tid = strtoul (arg + 1, NULL, 10);
3316 error (_(
"No current process: you must name one."));
3322 if (process == NULL)
3327 temporary_procinfo.reset (process);
3329 proc_error (process,
"info proc, open_procinfo_files", __LINE__);
3339 if (
proc_flags (process) & (PR_STOPPED | PR_ISTOP))
3349 if (
proc_flags (thread) & (PR_STOPPED | PR_ISTOP))
3370 int mode,
int from_tty)
3374 if (entry_or_exit == PR_SYSENTRY)
3380 proc_error (pi,
"proc-trace, get_traced_sysset", __LINE__);
3383 praddset (sysset, syscallnum);
3385 prdelset (sysset, syscallnum);
3387 if (entry_or_exit == PR_SYSENTRY)
3390 proc_error (pi,
"proc-trace, set_traced_sysentry", __LINE__);
3395 proc_error (pi,
"proc-trace, set_traced_sysexit", __LINE__);
3405 error (_(
"you must be debugging a process to use this command."));
3407 if (args == NULL || args[0] == 0)
3411 if (isdigit (args[0]))
3413 const int syscallnum = atoi (args);
3448 _(
"Give a trace of entries into the syscall."));
3450 _(
"Give a trace of exits from the syscall."));
3452 _(
"Cancel a trace of entries into the syscall."));
3454 _(
"Cancel a trace of exits from the syscall."));
3481 gdb::unique_xmalloc_ptr<char> ¬e_data,
3482 int *
note_size,
enum gdb_signal stop_signal)
3487 unsigned long merged_pid;
3489 merged_pid =
ptid.lwp () << 16 |
ptid.pid ();
3499 note_data.reset (elfcore_write_lwpstatus (
obfd,
3500 note_data.release (),
3506 note_data.reset (elfcore_write_prfpreg (
obfd,
3507 note_data.release (),
3516 gdb::unique_xmalloc_ptr<char> &
note_data,
3536 ptid_t ptid = ptid_t (pi->
pid, thread->
tid, 0);
3549 if (info->stop_signal () != GDB_SIGNAL_0
3556static enum gdb_signal
3563 return info->stop_signal ();
3565 return GDB_SIGNAL_0;
3568gdb::unique_xmalloc_ptr<char>
3572 char fname[16] = {
'\0'};
3573 char psargs[80] = {
'\0'};
3575 gdb::unique_xmalloc_ptr<char> note_data;
3576 enum gdb_signal stop_signal;
3580 strncpy (fname, lbasename (
get_exec_file (0)),
sizeof (fname));
3581 fname[
sizeof (fname) - 1] = 0;
3583 psargs[
sizeof (psargs) - 1] = 0;
3586 if (!inf_args.empty () &&
3587 inf_args.length () < ((
int) sizeof (psargs) - (
int) strlen (psargs)))
3589 strncat (psargs,
" ",
3590 sizeof (psargs) - strlen (psargs));
3591 strncat (psargs, inf_args.c_str (),
3592 sizeof (psargs) - strlen (psargs));
3596 note_data.reset (elfcore_write_prpsinfo (
obfd,
3597 note_data.release (),
3605 note_data.reset (elfcore_write_pstatus (
obfd, note_data.release (),
note_size,
3607 stop_signal, &gregs));
3614 gdb::optional<gdb::byte_vector> auxv =
3617 if (auxv && !auxv->empty ())
3618 note_data.reset (elfcore_write_note (
obfd, note_data.release (),
note_size,
3619 "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
void maybe_unpush_target()
const std::string & args() const
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)
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)
thread_info * find_thread_ptid(inferior *inf, ptid_t ptid)
void delete_thread(struct 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()
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 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_continue_no_signal(ptid_t ptid)
void target_mourn_inferior(ptid_t ptid)
std::unique_ptr< struct target_ops, target_unpusher > target_unpush_up
thread_control_capabilities
void perror_with_name(const char *string)
int query(const char *ctlstr,...)
void print_sys_errmsg(const char *string, int errcode)
void gdb_printf(struct ui_file *stream, const char *format,...)
void gdb_flush(struct ui_file *stream)
int parse_pid_to_attach(const char *args)
@ TARGET_WAITKIND_STOPPED