fbsd_nat_target::find_memory_regions (find_memory_region_ftype func,
void *obfd)
{
- pid_t pid = ptid_get_pid (inferior_ptid);
+ pid_t pid = inferior_ptid.pid ();
struct kinfo_vmentry *kve;
uint64_t size;
int i, nitems;
fbsd_nat_target::find_memory_regions (find_memory_region_ftype func,
void *obfd)
{
- pid_t pid = ptid_get_pid (inferior_ptid);
+ pid_t pid = inferior_ptid.pid ();
unsigned long start, end, size;
char protection[4];
int read, write, exec;
int nfd = 0;
#endif
struct kinfo_proc kp;
- char *tmp;
pid_t pid;
bool do_cmdline = false;
bool do_cwd = false;
bool do_exe = false;
+#ifdef HAVE_KINFO_GETFILE
+ bool do_files = false;
+#endif
#ifdef HAVE_KINFO_GETVMMAP
bool do_mappings = false;
#endif
case IP_CWD:
do_cwd = true;
break;
+#ifdef HAVE_KINFO_GETFILE
+ case IP_FILES:
+ do_files = true;
+ break;
+#endif
case IP_ALL:
do_cmdline = true;
do_cwd = true;
do_exe = true;
+#ifdef HAVE_KINFO_GETFILE
+ do_files = true;
+#endif
#ifdef HAVE_KINFO_GETVMMAP
do_mappings = true;
#endif
gdb_argv built_argv (args);
if (built_argv.count () == 0)
{
- pid = ptid_get_pid (inferior_ptid);
+ pid = inferior_ptid.pid ();
if (pid == 0)
error (_("No current process: you must name one."));
}
printf_filtered (_("process %d\n"), pid);
#ifdef HAVE_KINFO_GETFILE
- if (do_cwd || do_exe)
+ if (do_cwd || do_exe || do_files)
fdtbl.reset (kinfo_getfile (pid, &nfd));
#endif
else
warning (_("unable to fetch executable path name"));
}
+#ifdef HAVE_KINFO_GETFILE
+ if (do_files)
+ {
+ struct kinfo_file *kf = fdtbl.get ();
+
+ if (nfd > 0)
+ {
+ fbsd_info_proc_files_header ();
+ for (int i = 0; i < nfd; i++, kf++)
+ fbsd_info_proc_files_entry (kf->kf_type, kf->kf_fd, kf->kf_flags,
+ kf->kf_offset, kf->kf_vnode_type,
+ kf->kf_sock_domain, kf->kf_sock_type,
+ kf->kf_sock_protocol, &kf->kf_sa_local,
+ &kf->kf_sa_peer, kf->kf_path);
+ }
+ else
+ warning (_("unable to fetch list of open files"));
+ }
+#endif
#ifdef HAVE_KINFO_GETVMMAP
if (do_mappings)
{
ULONGEST offset, ULONGEST len,
ULONGEST *xfered_len)
{
- pid_t pid = ptid_get_pid (inferior_ptid);
+ pid_t pid = inferior_ptid.pid ();
switch (object)
{
}
return TARGET_XFER_E_IO;
}
+ case TARGET_OBJECT_FREEBSD_VMMAP:
+ case TARGET_OBJECT_FREEBSD_PS_STRINGS:
+ {
+ gdb::byte_vector buf_storage;
+ gdb_byte *buf;
+ size_t buflen;
+ int mib[4];
+
+ int proc_target;
+ uint32_t struct_size;
+ switch (object)
+ {
+ case TARGET_OBJECT_FREEBSD_VMMAP:
+ proc_target = KERN_PROC_VMMAP;
+ struct_size = sizeof (struct kinfo_vmentry);
+ break;
+ case TARGET_OBJECT_FREEBSD_PS_STRINGS:
+ proc_target = KERN_PROC_PS_STRINGS;
+ struct_size = sizeof (void *);
+ break;
+ }
+
+ if (writebuf != NULL)
+ return TARGET_XFER_E_IO;
+
+ mib[0] = CTL_KERN;
+ mib[1] = KERN_PROC;
+ mib[2] = proc_target;
+ mib[3] = pid;
+
+ if (sysctl (mib, 4, NULL, &buflen, NULL, 0) != 0)
+ return TARGET_XFER_E_IO;
+ buflen += sizeof (struct_size);
+
+ if (offset >= buflen)
+ {
+ *xfered_len = 0;
+ return TARGET_XFER_EOF;
+ }
+
+ buf_storage.resize (buflen);
+ buf = buf_storage.data ();
+
+ memcpy (buf, &struct_size, sizeof (struct_size));
+ buflen -= sizeof (struct_size);
+ if (sysctl (mib, 4, buf + sizeof (struct_size), &buflen, NULL, 0) != 0)
+ return TARGET_XFER_E_IO;
+ buflen += sizeof (struct_size);
+
+ if (buflen - offset < len)
+ len = buflen - offset;
+ memcpy (readbuf, buf + offset, len);
+ *xfered_len = len;
+ return TARGET_XFER_OK;
+ }
default:
return inf_ptrace_target::xfer_partial (object, annex,
readbuf, writebuf, offset,
/* Return true if PTID is still active in the inferior. */
-int
+bool
fbsd_nat_target::thread_alive (ptid_t ptid)
{
- if (ptid_lwp_p (ptid))
+ if (ptid.lwp_p ())
{
struct ptrace_lwpinfo pl;
- if (ptrace (PT_LWPINFO, ptid_get_lwp (ptid), (caddr_t) &pl, sizeof pl)
+ if (ptrace (PT_LWPINFO, ptid.lwp (), (caddr_t) &pl, sizeof pl)
== -1)
- return 0;
+ return false;
#ifdef PL_FLAG_EXITED
if (pl.pl_flags & PL_FLAG_EXITED)
- return 0;
+ return false;
#endif
}
- return 1;
+ return true;
}
/* Convert PTID to a string. Returns the string in a static
{
lwpid_t lwp;
- lwp = ptid_get_lwp (ptid);
+ lwp = ptid.lwp ();
if (lwp != 0)
{
static char buf[64];
- int pid = ptid_get_pid (ptid);
+ int pid = ptid.pid ();
xsnprintf (buf, sizeof buf, "LWP %d of process %d", lwp, pid);
return buf;
{
struct ptrace_lwpinfo pl;
struct kinfo_proc kp;
- int pid = ptid_get_pid (thr->ptid);
- long lwp = ptid_get_lwp (thr->ptid);
+ int pid = thr->ptid.pid ();
+ long lwp = thr->ptid.lwp ();
static char buf[sizeof pl.pl_tdname + 1];
/* Note that ptrace_lwpinfo returns the process command in pl_tdname
{
int i, nlwps;
- gdb_assert (!in_thread_list (pid_to_ptid (pid)));
+ gdb_assert (!in_thread_list (ptid_t (pid)));
nlwps = ptrace (PT_GETNUMLWPS, pid, NULL, 0);
if (nlwps == -1)
perror_with_name (("ptrace"));
for (i = 0; i < nlwps; i++)
{
- ptid_t ptid = ptid_build (pid, lwps[i], 0);
+ ptid_t ptid = ptid_t (pid, lwps[i], 0);
if (!in_thread_list (ptid))
{
#else
prune_threads ();
- fbsd_add_threads (ptid_get_pid (inferior_ptid));
+ fbsd_add_threads (inferior_ptid.pid ());
#endif
}
pid_t pid;
/* Don't PT_CONTINUE a process which has a pending vfork done event. */
- if (ptid_equal (minus_one_ptid, ptid))
- pid = ptid_get_pid (inferior_ptid);
+ if (minus_one_ptid == ptid)
+ pid = inferior_ptid.pid ();
else
- pid = ptid_get_pid (ptid);
+ pid = ptid.pid ();
if (fbsd_is_vfork_done_pending (pid))
return;
#endif
if (debug_fbsd_lwp)
fprintf_unfiltered (gdb_stdlog,
"FLWP: fbsd_resume for ptid (%d, %ld, %ld)\n",
- ptid_get_pid (ptid), ptid_get_lwp (ptid),
- ptid_get_tid (ptid));
- if (ptid_lwp_p (ptid))
+ ptid.pid (), ptid.lwp (),
+ ptid.tid ());
+ if (ptid.lwp_p ())
{
/* If ptid is a specific LWP, suspend all other LWPs in the process. */
struct thread_info *tp;
ALL_NON_EXITED_THREADS (tp)
{
- if (ptid_get_pid (tp->ptid) != ptid_get_pid (ptid))
+ if (tp->ptid.pid () != ptid.pid ())
continue;
- if (ptid_get_lwp (tp->ptid) == ptid_get_lwp (ptid))
+ if (tp->ptid.lwp () == ptid.lwp ())
request = PT_RESUME;
else
request = PT_SUSPEND;
- if (ptrace (request, ptid_get_lwp (tp->ptid), NULL, 0) == -1)
+ if (ptrace (request, tp->ptid.lwp (), NULL, 0) == -1)
perror_with_name (("ptrace"));
}
}
ALL_NON_EXITED_THREADS (tp)
{
- if (!ptid_match (tp->ptid, ptid))
+ if (!tp->ptid.matches (ptid))
continue;
- if (ptrace (PT_RESUME, ptid_get_lwp (tp->ptid), NULL, 0) == -1)
+ if (ptrace (PT_RESUME, tp->ptid.lwp (), NULL, 0) == -1)
perror_with_name (("ptrace"));
}
ptid = inferior_ptid;
{
#ifndef PTRACE_VFORK
wptid = fbsd_next_vfork_done ();
- if (!ptid_equal (wptid, null_ptid))
+ if (wptid != null_ptid)
{
ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
return wptid;
pid_t pid;
int status;
- pid = ptid_get_pid (wptid);
+ pid = wptid.pid ();
if (ptrace (PT_LWPINFO, pid, (caddr_t) &pl, sizeof pl) == -1)
perror_with_name (("ptrace"));
- wptid = ptid_build (pid, pl.pl_lwpid, 0);
+ wptid = ptid_t (pid, pl.pl_lwpid, 0);
if (debug_fbsd_nat)
{
threads might be skipped during post_attach that
have not yet reported their PL_FLAG_EXITED event.
Ignore EXITED events for an unknown LWP. */
- if (in_thread_list (wptid))
+ thread_info *thr = find_thread_ptid (wptid);
+ if (thr != nullptr)
{
if (debug_fbsd_lwp)
fprintf_unfiltered (gdb_stdlog,
if (print_thread_events)
printf_unfiltered (_("[%s exited]\n"), target_pid_to_str
(wptid));
- delete_thread (wptid);
+ delete_thread (thr);
}
if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1)
perror_with_name (("ptrace"));
PL_FLAG_BORN in case the first stop reported after
attaching to an existing process is a PL_FLAG_BORN
event. */
- if (in_thread_list (pid_to_ptid (pid)))
+ if (in_thread_list (ptid_t (pid)))
{
if (debug_fbsd_lwp)
fprintf_unfiltered (gdb_stdlog,
"FLWP: using LWP %u for first thread\n",
pl.pl_lwpid);
- thread_change_ptid (pid_to_ptid (pid), wptid);
+ thread_change_ptid (ptid_t (pid), wptid);
}
#ifdef PT_LWP_EVENTS
/* Make sure the other end of the fork is stopped too. */
child_ptid = fbsd_is_child_pending (child);
- if (ptid_equal (child_ptid, null_ptid))
+ if (child_ptid == null_ptid)
{
pid = waitpid (child, &status, 0);
if (pid == -1)
perror_with_name (("ptrace"));
gdb_assert (pl.pl_flags & PL_FLAG_CHILD);
- child_ptid = ptid_build (child, pl.pl_lwpid, 0);
+ child_ptid = ptid_t (child, pl.pl_lwpid, 0);
}
/* Enable additional events on the child process. */
- fbsd_enable_proc_events (ptid_get_pid (child_ptid));
+ fbsd_enable_proc_events (child_ptid.pid ());
#ifndef PTRACE_VFORK
/* For vfork, the child process will have the P_PPWAIT
#ifdef USE_SIGTRAP_SIGINFO
/* Implement the "stopped_by_sw_breakpoint" target_ops method. */
-int
+bool
fbsd_nat_target::stopped_by_sw_breakpoint ()
{
struct ptrace_lwpinfo pl;
if (ptrace (PT_LWPINFO, get_ptrace_pid (inferior_ptid), (caddr_t) &pl,
sizeof pl) == -1)
- return 0;
+ return false;
return ((pl.pl_flags & PL_FLAG_SI)
&& pl.pl_siginfo.si_signo == SIGTRAP
/* Implement the "supports_stopped_by_sw_breakpoint" target_ops
method. */
-int
+bool
fbsd_nat_target::supports_stopped_by_sw_breakpoint ()
{
- return 1;
+ return true;
}
#endif
if (!follow_child && detach_fork)
{
struct thread_info *tp = inferior_thread ();
- pid_t child_pid = ptid_get_pid (tp->pending_follow.value.related_pid);
+ pid_t child_pid = tp->pending_follow.value.related_pid.pid ();
/* Breakpoints have already been detached from the child by
infrun.c. */
void
fbsd_nat_target::post_startup_inferior (ptid_t pid)
{
- fbsd_enable_proc_events (ptid_get_pid (pid));
+ fbsd_enable_proc_events (pid.pid ());
}
/* Implement the "post_attach" target_ops method. */
projects / deliverable / binutils-gdb.git / blobdiff