mirrors/binutils-gdb
1
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-11-24 10:35:12 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
5b6d1e4fa4
binutils-gdb/gdb/fbsd-nat.c
Pedro Alves 5b6d1e4fa4 Multi-target support 
This commit adds multi-target support to GDB.  What this means is that
with this commit, GDB can now be connected to different targets at the
same time.  E.g., you can debug a live native process and a core dump
at the same time, connect to multiple gdbservers, etc.

Actually, the word "target" is overloaded in gdb.  We already have a
target stack, with pushes several target_ops instances on top of one
another.  We also have "info target" already, which means something
completely different to what this patch does.

So from here on, I'll be using the "target connections" term, to mean
an open process_stratum target, pushed on a target stack.  This patch
makes gdb have multiple target stacks, and multiple process_stratum
targets open simultaneously.  The user-visible changes / commands will
also use this terminology, but of course it's all open to debate.

User-interface-wise, not that much changes.  The main difference is
that each inferior may have its own target connection.

A target connection (e.g., a target extended-remote connection) may
support debugging multiple processes, just as before.

Say you're debugging against gdbserver in extended-remote mode, and
you do "add-inferior" to prepare to spawn a new process, like:

 (gdb) target extended-remote :9999
 ...
 (gdb) start
 ...
 (gdb) add-inferior
 Added inferior 2
 (gdb) inferior 2
 [Switching to inferior 2 [<null>] (<noexec>)]
 (gdb) file a.out
 ...
 (gdb) start
 ...

At this point, you have two inferiors connected to the same gdbserver.

With this commit, GDB will maintain a target stack per inferior,
instead of a global target stack.

To preserve the behavior above, by default, "add-inferior" makes the
new inferior inherit a copy of the target stack of the current
inferior.  Same across a fork - the child inherits a copy of the
target stack of the parent.  While the target stacks are copied, the
targets themselves are not.  Instead, target_ops is made a
refcounted_object, which means that target_ops instances are
refcounted, which each inferior counting for a reference.

What if you want to create an inferior and connect it to some _other_
target?  For that, this commit introduces a new "add-inferior
-no-connection" option that makes the new inferior not share the
current inferior's target.  So you could do:

 (gdb) target extended-remote :9999
 Remote debugging using :9999
 ...
 (gdb) add-inferior -no-connection
 [New inferior 2]
 Added inferior 2
 (gdb) inferior 2
 [Switching to inferior 2 [<null>] (<noexec>)]
 (gdb) info inferiors
   Num  Description       Executable
   1    process 18401     target:/home/pedro/tmp/main
 * 2    <null>
 (gdb) tar extended-remote :10000
 Remote debugging using :10000
 ...
 (gdb) info inferiors
   Num  Description       Executable
   1    process 18401     target:/home/pedro/tmp/main
 * 2    process 18450     target:/home/pedro/tmp/main
 (gdb)

A following patch will extended "info inferiors" to include a column
indicating which connection an inferior is bound to, along with a
couple other UI tweaks.

Other than that, debugging is the same as before.  Users interact with
inferiors and threads as before.  The only difference is that
inferiors may be bound to processes running in different machines.

That's pretty much all there is to it in terms of noticeable UI
changes.

On to implementation.

Since we can be connected to different systems at the same time, a
ptid_t is no longer a unique identifier.  Instead a thread can be
identified by a pair of ptid_t and 'process_stratum_target *', the
later being the instance of the process_stratum target that owns the
process/thread.  Note that process_stratum_target inherits from
target_ops, and all process_stratum targets inherit from
process_stratum_target.  In earlier patches, many places in gdb were
converted to refer to threads by thread_info pointer instead of
ptid_t, but there are still places in gdb where we start with a
pid/tid and need to find the corresponding inferior or thread_info
objects.  So you'll see in the patch many places adding a
process_stratum_target parameter to functions that used to take only a
ptid_t.

Since each inferior has its own target stack now, we can always find
the process_stratum target for an inferior.  That is done via a
inf->process_target() convenience method.

Since each inferior has its own target stack, we need to handle the
"beneath" calls when servicing target calls.  The solution I settled
with is just to make sure to switch the current inferior to the
inferior you want before making a target call.  Not relying on global
context is just not feasible in current GDB.  Fortunately, there
aren't that many places that need to do that, because generally most
code that calls target methods already has the current context
pointing to the right inferior/thread.  Note, to emphasize -- there's
no method to "switch to this target stack".  Instead, you switch the
current inferior, and that implicitly switches the target stack.

In some spots, we need to iterate over all inferiors so that we reach
all target stacks.

Native targets are still singletons.  There's always only a single
instance of such targets.

Remote targets however, we'll have one instance per remote connection.

The exec target is still a singleton.  There's only one instance.  I
did not see the point of instanciating more than one exec_target
object.

After vfork, we need to make sure to push the exec target on the new
inferior.  See exec_on_vfork.

For type safety, functions that need a {target, ptid} pair to identify
a thread, take a process_stratum_target pointer for target parameter
instead of target_ops *.  Some shared code in gdb/nat/ also need to
gain a target pointer parameter.  This poses an issue, since gdbserver
doesn't have process_stratum_target, only target_ops.  To fix this,
this commit renames gdbserver's target_ops to process_stratum_target.
I think this makes sense.  There's no concept of target stack in
gdbserver, and gdbserver's target_ops really implements a
process_stratum-like target.

The thread and inferior iterator functions also gain
process_stratum_target parameters.  These are used to be able to
iterate over threads and inferiors of a given target.  Following usual
conventions, if the target pointer is null, then we iterate over
threads and inferiors of all targets.

I tried converting "add-inferior" to the gdb::option framework, as a
preparatory patch, but that stumbled on the fact that gdb::option does
not support file options yet, for "add-inferior -exec".  I have a WIP
patchset that adds that, but it's not a trivial patch, mainly due to
need to integrate readline's filename completion, so I deferred that
to some other time.

In infrun.c/infcmd.c, the main change is that we need to poll events
out of all targets.  See do_target_wait.  Right after collecting an
event, we switch the current inferior to an inferior bound to the
target that reported the event, so that target methods can be used
while handling the event.  This makes most of the code transparent to
multi-targets.  See fetch_inferior_event.

infrun.c:stop_all_threads is interesting -- in this function we need
to stop all threads of all targets.  What the function does is send an
asynchronous stop request to all threads, and then synchronously waits
for events, with target_wait, rinse repeat, until all it finds are
stopped threads.  Now that we have multiple targets, it's not
efficient to synchronously block in target_wait waiting for events out
of one target.  Instead, we implement a mini event loop, with
interruptible_select, select'ing on one file descriptor per target.
For this to work, we need to be able to ask the target for a waitable
file descriptor.  Such file descriptors already exist, they are the
descriptors registered in the main event loop with add_file_handler,
inside the target_async implementations.  This commit adds a new
target_async_wait_fd target method that just returns the file
descriptor in question.  See wait_one / stop_all_threads in infrun.c.

The 'threads_executing' global is made a per-target variable.  Since
it is only relevant to process_stratum_target targets, this is where
it is put, instead of in target_ops.

You'll notice that remote.c includes some FIXME notes.  These refer to
the fact that the global arrays that hold data for the remote packets
supported are still globals.  For example, if we connect to two
different servers/stubs, then each might support different remote
protocol features.  They might even be different architectures, like
e.g., one ARM baremetal stub, and a x86 gdbserver, to debug a
host/controller scenario as a single program.  That isn't going to
work correctly today, because of said globals.  I'm leaving fixing
that for another pass, since it does not appear to be trivial, and I'd
rather land the base work first.  It's already useful to be able to
debug multiple instances of the same server (e.g., a distributed
cluster, where you have full control over the servers installed), so I
think as is it's already reasonable incremental progress.

Current limitations:

 - You can only resume more that one target at the same time if all
   targets support asynchronous debugging, and support non-stop mode.
   It should be possible to support mixed all-stop + non-stop
   backends, but that is left for another time.  This means that
   currently in order to do multi-target with gdbserver you need to
   issue "maint set target-non-stop on".  I would like to make that
   mode be the default, but we're not there yet.  Note that I'm
   talking about how the target backend works, only.  User-visible
   all-stop mode works just fine.

 - As explained above, connecting to different remote servers at the
   same time is likely to produce bad results if they don't support the
   exact set of RSP features.

FreeBSD updates courtesy of John Baldwin.

gdb/ChangeLog:
2020-01-10  Pedro Alves  <palves@redhat.com>
	    John Baldwin  <jhb@FreeBSD.org>

	* aarch64-linux-nat.c
	(aarch64_linux_nat_target::thread_architecture): Adjust.
	* ada-tasks.c (print_ada_task_info): Adjust find_thread_ptid call.
	(task_command_1): Likewise.
	* aix-thread.c (sync_threadlists, aix_thread_target::resume)
	(aix_thread_target::wait, aix_thread_target::fetch_registers)
	(aix_thread_target::store_registers)
	(aix_thread_target::thread_alive): Adjust.
	* amd64-fbsd-tdep.c: Include "inferior.h".
	(amd64fbsd_get_thread_local_address): Pass down target.
	* amd64-linux-nat.c (ps_get_thread_area): Use ps_prochandle
	thread's gdbarch instead of target_gdbarch.
	* break-catch-sig.c (signal_catchpoint_print_it): Adjust call to
	get_last_target_status.
	* break-catch-syscall.c (print_it_catch_syscall): Likewise.
	* breakpoint.c (breakpoints_should_be_inserted_now): Consider all
	inferiors.
	(update_inserted_breakpoint_locations): Skip if inferiors with no
	execution.
	(update_global_location_list): When handling moribund locations,
	find representative inferior for location's pspace, and use thread
	count of its process_stratum target.
	* bsd-kvm.c (bsd_kvm_target_open): Pass target down.
	* bsd-uthread.c (bsd_uthread_target::wait): Use
	as_process_stratum_target and adjust thread_change_ptid and
	add_thread calls.
	(bsd_uthread_target::update_thread_list): Use
	as_process_stratum_target and adjust find_thread_ptid,
	thread_change_ptid and add_thread calls.
	* btrace.c (maint_btrace_packet_history_cmd): Adjust
	find_thread_ptid call.
	* corelow.c (add_to_thread_list): Adjust add_thread call.
	(core_target_open): Adjust add_thread_silent and thread_count
	calls.
	(core_target::pid_to_str): Adjust find_inferior_ptid call.
	* ctf.c (ctf_target_open): Adjust add_thread_silent call.
	* event-top.c (async_disconnect): Pop targets from all inferiors.
	* exec.c (add_target_sections): Push exec target on all inferiors
	sharing the program space.
	(remove_target_sections): Remove the exec target from all
	inferiors sharing the program space.
	(exec_on_vfork): New.
	* exec.h (exec_on_vfork): Declare.
	* fbsd-nat.c (fbsd_add_threads): Add fbsd_nat_target parameter.
	Pass it down.
	(fbsd_nat_target::update_thread_list): Adjust.
	(fbsd_nat_target::resume): Adjust.
	(fbsd_handle_debug_trap): Add fbsd_nat_target parameter.  Pass it
	down.
	(fbsd_nat_target::wait, fbsd_nat_target::post_attach): Adjust.
	* fbsd-tdep.c (fbsd_corefile_thread): Adjust
	get_thread_arch_regcache call.
	* fork-child.c (gdb_startup_inferior): Pass target down to
	startup_inferior and set_executing.
	* gdbthread.h (struct process_stratum_target): Forward declare.
	(add_thread, add_thread_silent, add_thread_with_info)
	(in_thread_list): Add process_stratum_target parameter.
	(find_thread_ptid(inferior*, ptid_t)): New overload.
	(find_thread_ptid, thread_change_ptid): Add process_stratum_target
	parameter.
	(all_threads()): Delete overload.
	(all_threads, all_non_exited_threads): Add process_stratum_target
	parameter.
	(all_threads_safe): Use brace initialization.
	(thread_count): Add process_stratum_target parameter.
	(set_resumed, set_running, set_stop_requested, set_executing)
	(threads_are_executing, finish_thread_state): Add
	process_stratum_target parameter.
	(switch_to_thread): Use is_current_thread.
	* i386-fbsd-tdep.c: Include "inferior.h".
	(i386fbsd_get_thread_local_address): Pass down target.
	* i386-linux-nat.c (i386_linux_nat_target::low_resume): Adjust.
	* inf-child.c (inf_child_target::maybe_unpush_target): Remove
	have_inferiors check.
	* inf-ptrace.c (inf_ptrace_target::create_inferior)
	(inf_ptrace_target::attach): Adjust.
	* infcall.c (run_inferior_call): Adjust.
	* infcmd.c (run_command_1): Pass target to
	scoped_finish_thread_state.
	(proceed_thread_callback): Skip inferiors with no execution.
	(continue_command): Rename 'all_threads' local to avoid hiding
	'all_threads' function.  Adjust get_last_target_status call.
	(prepare_one_step): Adjust set_running call.
	(signal_command): Use user_visible_resume_target.  Compare thread
	pointers instead of inferior_ptid.
	(info_program_command): Adjust to pass down target.
	(attach_command): Mark target's 'thread_executing' flag.
	(stop_current_target_threads_ns): New, factored out from ...
	(interrupt_target_1): ... this.  Switch inferior before making
	target calls.
	* inferior-iter.h
	(struct all_inferiors_iterator, struct all_inferiors_range)
	(struct all_inferiors_safe_range)
	(struct all_non_exited_inferiors_range): Filter on
	process_stratum_target too.  Remove explicit.
	* inferior.c (inferior::inferior): Push dummy target on target
	stack.
	(find_inferior_pid, find_inferior_ptid, number_of_live_inferiors):
	Add process_stratum_target parameter, and pass it down.
	(have_live_inferiors): Adjust.
	(switch_to_inferior_and_push_target): New.
	(add_inferior_command, clone_inferior_command): Handle
	"-no-connection" parameter.  Use
	switch_to_inferior_and_push_target.
	(_initialize_inferior): Mention "-no-connection" option in
	the help of "add-inferior" and "clone-inferior" commands.
	* inferior.h: Include "process-stratum-target.h".
	(interrupt_target_1): Use bool.
	(struct inferior) <push_target, unpush_target, target_is_pushed,
	find_target_beneath, top_target, process_target, target_at,
	m_stack>: New.
	(discard_all_inferiors): Delete.
	(find_inferior_pid, find_inferior_ptid, number_of_live_inferiors)
	(all_inferiors, all_non_exited_inferiors): Add
	process_stratum_target parameter.
	* infrun.c: Include "gdb_select.h" and <unordered_map>.
	(target_last_proc_target): New global.
	(follow_fork_inferior): Push target on new inferior.  Pass target
	to add_thread_silent.  Call exec_on_vfork.  Handle target's
	reference count.
	(follow_fork): Adjust get_last_target_status call.  Also consider
	target.
	(follow_exec): Push target on new inferior.
	(struct execution_control_state) <target>: New field.
	(user_visible_resume_target): New.
	(do_target_resume): Call target_async.
	(resume_1): Set target's threads_executing flag.  Consider resume
	target.
	(commit_resume_all_targets): New.
	(proceed): Also consider resume target.  Skip threads of inferiors
	with no execution.  Commit resumtion in all targets.
	(start_remote): Pass current inferior to wait_for_inferior.
	(infrun_thread_stop_requested): Consider target as well.  Pass
	thread_info pointer to clear_inline_frame_state instead of ptid.
	(infrun_thread_thread_exit): Consider target as well.
	(random_pending_event_thread): New inferior parameter.  Use it.
	(do_target_wait): Rename to ...
	(do_target_wait_1): ... this.  Add inferior parameter, and pass it
	down.
	(threads_are_resumed_pending_p, do_target_wait): New.
	(prepare_for_detach): Adjust calls.
	(wait_for_inferior): New inferior parameter.  Handle it.  Use
	do_target_wait_1 instead of do_target_wait.
	(fetch_inferior_event): Adjust.  Switch to representative
	inferior.  Pass target down.
	(set_last_target_status): Add process_stratum_target parameter.
	Save target in global.
	(get_last_target_status): Add process_stratum_target parameter and
	handle it.
	(nullify_last_target_wait_ptid): Clear 'target_last_proc_target'.
	(context_switch): Check inferior_ptid == null_ptid before calling
	inferior_thread().
	(get_inferior_stop_soon): Pass down target.
	(wait_one): Rename to ...
	(poll_one_curr_target): ... this.
	(struct wait_one_event): New.
	(wait_one): New.
	(stop_all_threads): Adjust.
	(handle_no_resumed, handle_inferior_event): Adjust to consider the
	event's target.
	(switch_back_to_stepped_thread): Also consider target.
	(print_stop_event): Update.
	(normal_stop): Update.  Also consider the resume target.
	* infrun.h (wait_for_inferior): Remove declaration.
	(user_visible_resume_target): New declaration.
	(get_last_target_status, set_last_target_status): New
	process_stratum_target parameter.
	* inline-frame.c (clear_inline_frame_state(ptid_t)): Add
	process_stratum_target parameter, and use it.
	(clear_inline_frame_state (thread_info*)): New.
	* inline-frame.c (clear_inline_frame_state(ptid_t)): Add
	process_stratum_target parameter.
	(clear_inline_frame_state (thread_info*)): Declare.
	* linux-fork.c (delete_checkpoint_command): Pass target down to
	find_thread_ptid.
	(checkpoint_command): Adjust.
	* linux-nat.c (linux_nat_target::follow_fork): Switch to thread
	instead of just tweaking inferior_ptid.
	(linux_nat_switch_fork): Pass target down to thread_change_ptid.
	(exit_lwp): Pass target down to find_thread_ptid.
	(attach_proc_task_lwp_callback): Pass target down to
	add_thread/set_running/set_executing.
	(linux_nat_target::attach): Pass target down to
	thread_change_ptid.
	(get_detach_signal): Pass target down to find_thread_ptid.
	Consider last target status's target.
	(linux_resume_one_lwp_throw, resume_lwp)
	(linux_handle_syscall_trap, linux_handle_extended_wait, wait_lwp)
	(stop_wait_callback, save_stop_reason, linux_nat_filter_event)
	(linux_nat_wait_1, resume_stopped_resumed_lwps): Pass target down.
	(linux_nat_target::async_wait_fd): New.
	(linux_nat_stop_lwp, linux_nat_target::thread_address_space): Pass
	target down.
	* linux-nat.h (linux_nat_target::async_wait_fd): Declare.
	* linux-tdep.c (get_thread_arch_regcache): Pass target down.
	* linux-thread-db.c (struct thread_db_info::process_target): New
	field.
	(add_thread_db_info): Save target.
	(get_thread_db_info): New process_stratum_target parameter.  Also
	match target.
	(delete_thread_db_info): New process_stratum_target parameter.
	Also match target.
	(thread_from_lwp): Adjust to pass down target.
	(thread_db_notice_clone): Pass down target.
	(check_thread_db_callback): Pass down target.
	(try_thread_db_load_1): Always push the thread_db target.
	(try_thread_db_load, record_thread): Pass target down.
	(thread_db_target::detach): Pass target down.  Always unpush the
	thread_db target.
	(thread_db_target::wait, thread_db_target::mourn_inferior): Pass
	target down.  Always unpush the thread_db target.
	(find_new_threads_callback, thread_db_find_new_threads_2)
	(thread_db_target::update_thread_list): Pass target down.
	(thread_db_target::pid_to_str): Pass current inferior down.
	(thread_db_target::get_thread_local_address): Pass target down.
	(thread_db_target::resume, maintenance_check_libthread_db): Pass
	target down.
	* nto-procfs.c (nto_procfs_target::update_thread_list): Adjust.
	* procfs.c (procfs_target::procfs_init_inferior): Declare.
	(proc_set_current_signal, do_attach, procfs_target::wait): Adjust.
	(procfs_init_inferior): Rename to ...
	(procfs_target::procfs_init_inferior): ... this and adjust.
	(procfs_target::create_inferior, procfs_notice_thread)
	(procfs_do_thread_registers): Adjust.
	* ppc-fbsd-tdep.c: Include "inferior.h".
	(ppcfbsd_get_thread_local_address): Pass down target.
	* proc-service.c (ps_xfer_memory): Switch current inferior and
	program space as well.
	(get_ps_regcache): Pass target down.
	* process-stratum-target.c
	(process_stratum_target::thread_address_space)
	(process_stratum_target::thread_architecture): Pass target down.
	* process-stratum-target.h
	(process_stratum_target::threads_executing): New field.
	(as_process_stratum_target): New.
	* ravenscar-thread.c
	(ravenscar_thread_target::update_inferior_ptid): Pass target down.
	(ravenscar_thread_target::wait, ravenscar_add_thread): Pass target
	down.
	* record-btrace.c (record_btrace_target::info_record): Adjust.
	(record_btrace_target::record_method)
	(record_btrace_target::record_is_replaying)
	(record_btrace_target::fetch_registers)
	(get_thread_current_frame_id, record_btrace_target::resume)
	(record_btrace_target::wait, record_btrace_target::stop): Pass
	target down.
	* record-full.c (record_full_wait_1): Switch to event thread.
	Pass target down.
	* regcache.c (regcache::regcache)
	(get_thread_arch_aspace_regcache, get_thread_arch_regcache): Add
	process_stratum_target parameter and handle it.
	(current_thread_target): New global.
	(get_thread_regcache): Add process_stratum_target parameter and
	handle it.  Switch inferior before calling target method.
	(get_thread_regcache): Pass target down.
	(get_thread_regcache_for_ptid): Pass target down.
	(registers_changed_ptid): Add process_stratum_target parameter and
	handle it.
	(registers_changed_thread, registers_changed): Pass target down.
	(test_get_thread_arch_aspace_regcache): New.
	(current_regcache_test): Define a couple local test_target_ops
	instances and use them for testing.
	(readwrite_regcache): Pass process_stratum_target parameter.
	(cooked_read_test, cooked_write_test): Pass mock_target down.
	* regcache.h (get_thread_regcache, get_thread_arch_regcache)
	(get_thread_arch_aspace_regcache): Add process_stratum_target
	parameter.
	(regcache::target): New method.
	(regcache::regcache, regcache::get_thread_arch_aspace_regcache)
	(regcache::registers_changed_ptid): Add process_stratum_target
	parameter.
	(regcache::m_target): New field.
	(registers_changed_ptid): Add process_stratum_target parameter.
	* remote.c (remote_state::supports_vCont_probed): New field.
	(remote_target::async_wait_fd): New method.
	(remote_unpush_and_throw): Add remote_target parameter.
	(get_current_remote_target): Adjust.
	(remote_target::remote_add_inferior): Push target.
	(remote_target::remote_add_thread)
	(remote_target::remote_notice_new_inferior)
	(get_remote_thread_info): Pass target down.
	(remote_target::update_thread_list): Skip threads of inferiors
	bound to other targets.  (remote_target::close): Don't discard
	inferiors.  (remote_target::add_current_inferior_and_thread)
	(remote_target::process_initial_stop_replies)
	(remote_target::start_remote)
	(remote_target::remote_serial_quit_handler): Pass down target.
	(remote_target::remote_unpush_target): New remote_target
	parameter.  Unpush the target from all inferiors.
	(remote_target::remote_unpush_and_throw): New remote_target
	parameter.  Pass it down.
	(remote_target::open_1): Check whether the current inferior has
	execution instead of checking whether any inferior is live.  Pass
	target down.
	(remote_target::remote_detach_1): Pass down target.  Use
	remote_unpush_target.
	(extended_remote_target::attach): Pass down target.
	(remote_target::remote_vcont_probe): Set supports_vCont_probed.
	(remote_target::append_resumption): Pass down target.
	(remote_target::append_pending_thread_resumptions)
	(remote_target::remote_resume_with_hc, remote_target::resume)
	(remote_target::commit_resume): Pass down target.
	(remote_target::remote_stop_ns): Check supports_vCont_probed.
	(remote_target::interrupt_query)
	(remote_target::remove_new_fork_children)
	(remote_target::check_pending_events_prevent_wildcard_vcont)
	(remote_target::remote_parse_stop_reply)
	(remote_target::process_stop_reply): Pass down target.
	(first_remote_resumed_thread): New remote_target parameter.  Pass
	it down.
	(remote_target::wait_as): Pass down target.
	(unpush_and_perror): New remote_target parameter.  Pass it down.
	(remote_target::readchar, remote_target::remote_serial_write)
	(remote_target::getpkt_or_notif_sane_1)
	(remote_target::kill_new_fork_children, remote_target::kill): Pass
	down target.
	(remote_target::mourn_inferior): Pass down target.  Use
	remote_unpush_target.
	(remote_target::core_of_thread)
	(remote_target::remote_btrace_maybe_reopen): Pass down target.
	(remote_target::pid_to_exec_file)
	(remote_target::thread_handle_to_thread_info): Pass down target.
	(remote_target::async_wait_fd): New.
	* riscv-fbsd-tdep.c: Include "inferior.h".
	(riscv_fbsd_get_thread_local_address): Pass down target.
	* sol2-tdep.c (sol2_core_pid_to_str): Pass down target.
	* sol-thread.c (sol_thread_target::wait, ps_lgetregs, ps_lsetregs)
	(ps_lgetfpregs, ps_lsetfpregs, sol_update_thread_list_callback):
	Adjust.
	* solib-spu.c (spu_skip_standalone_loader): Pass down target.
	* solib-svr4.c (enable_break): Pass down target.
	* spu-multiarch.c (parse_spufs_run): Pass down target.
	* spu-tdep.c (spu2ppu_sniffer): Pass down target.
	* target-delegates.c: Regenerate.
	* target.c (g_target_stack): Delete.
	(current_top_target): Return the current inferior's top target.
	(target_has_execution_1): Refer to the passed-in inferior's top
	target.
	(target_supports_terminal_ours): Check whether the initial
	inferior was already created.
	(decref_target): New.
	(target_stack::push): Incref/decref the target.
	(push_target, push_target, unpush_target): Adjust.
	(target_stack::unpush): Defref target.
	(target_is_pushed): Return bool.  Adjust to refer to the current
	inferior's target stack.
	(dispose_inferior): Delete, and inline parts ...
	(target_preopen): ... here.  Only dispose of the current inferior.
	(target_detach): Hold strong target reference while detaching.
	Pass target down.
	(target_thread_name): Add assertion.
	(target_resume): Pass down target.
	(target_ops::beneath, find_target_at): Adjust to refer to the
	current inferior's target stack.
	(get_dummy_target): New.
	(target_pass_ctrlc): Pass the Ctrl-C to the first inferior that
	has a thread running.
	(initialize_targets): Rename to ...
	(_initialize_target): ... this.
	* target.h: Include "gdbsupport/refcounted-object.h".
	(struct target_ops): Inherit refcounted_object.
	(target_ops::shortname, target_ops::longname): Make const.
	(target_ops::async_wait_fd): New method.
	(decref_target): Declare.
	(struct target_ops_ref_policy): New.
	(target_ops_ref): New typedef.
	(get_dummy_target): Declare function.
	(target_is_pushed): Return bool.
	* thread-iter.c (all_matching_threads_iterator::m_inf_matches)
	(all_matching_threads_iterator::all_matching_threads_iterator):
	Handle filter target.
	* thread-iter.h (struct all_matching_threads_iterator, struct
	all_matching_threads_range, class all_non_exited_threads_range):
	Filter by target too.  Remove explicit.
	* thread.c (threads_executing): Delete.
	(inferior_thread): Pass down current inferior.
	(clear_thread_inferior_resources): Pass down thread pointer
	instead of ptid_t.
	(add_thread_silent, add_thread_with_info, add_thread): Add
	process_stratum_target parameter.  Use it for thread and inferior
	searches.
	(is_current_thread): New.
	(thread_info::deletable): Use it.
	(find_thread_ptid, thread_count, in_thread_list)
	(thread_change_ptid, set_resumed, set_running): New
	process_stratum_target parameter.  Pass it down.
	(set_executing): New process_stratum_target parameter.  Pass it
	down.  Adjust reference to 'threads_executing'.
	(threads_are_executing): New process_stratum_target parameter.
	Adjust reference to 'threads_executing'.
	(set_stop_requested, finish_thread_state): New
	process_stratum_target parameter.  Pass it down.
	(switch_to_thread): Also match inferior.
	(switch_to_thread): New process_stratum_target parameter.  Pass it
	down.
	(update_threads_executing): Reimplement.
	* top.c (quit_force): Pop targets from all inferior.
	(gdb_init): Don't call initialize_targets.
	* windows-nat.c (windows_nat_target) <get_windows_debug_event>:
	Declare.
	(windows_add_thread, windows_delete_thread): Adjust.
	(get_windows_debug_event): Rename to ...
	(windows_nat_target::get_windows_debug_event): ... this.  Adjust.
	* tracefile-tfile.c (tfile_target_open): Pass down target.
	* gdbsupport/common-gdbthread.h (struct process_stratum_target):
	Forward declare.
	(switch_to_thread): Add process_stratum_target parameter.
	* mi/mi-interp.c (mi_on_resume_1): Add process_stratum_target
	parameter.  Use it.
	(mi_on_resume): Pass target down.
	* nat/fork-inferior.c (startup_inferior): Add
	process_stratum_target parameter.  Pass it down.
	* nat/fork-inferior.h (startup_inferior): Add
	process_stratum_target parameter.
	* python/py-threadevent.c (py_get_event_thread): Pass target down.

gdb/gdbserver/ChangeLog:
2020-01-10  Pedro Alves  <palves@redhat.com>

	* fork-child.c (post_fork_inferior): Pass target down to
	startup_inferior.
	* inferiors.c (switch_to_thread): Add process_stratum_target
	parameter.
	* lynx-low.c (lynx_target_ops): Now a process_stratum_target.
	* nto-low.c (nto_target_ops): Now a process_stratum_target.
	* linux-low.c (linux_target_ops): Now a process_stratum_target.
	* remote-utils.c (prepare_resume_reply): Pass the target to
	switch_to_thread.
	* target.c (the_target): Now a process_stratum_target.
	(done_accessing_memory): Pass the target to switch_to_thread.
	(set_target_ops): Ajust to use process_stratum_target.
	* target.h (struct target_ops): Rename to ...
	(struct process_stratum_target): ... this.
	(the_target, set_target_ops): Adjust.
	(prepare_to_access_memory): Adjust comment.
	* win32-low.c (child_xfer_memory): Adjust to use
	process_stratum_target.
	(win32_target_ops): Now a process_stratum_target.
2020-01-10 20:06:08 +00:00

1694 lines
45 KiB
C
Raw Blame History

/* Native-dependent code for FreeBSD.
Copyright (C) 2002-2020 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "gdbsupport/byte-vector.h"
#include "gdbcore.h"
#include "inferior.h"
#include "regcache.h"
#include "regset.h"
#include "gdbarch.h"
#include "gdbcmd.h"
#include "gdbthread.h"
#include "gdbsupport/gdb_wait.h"
#include "inf-ptrace.h"
#include <sys/types.h>
#include <sys/procfs.h>
#include <sys/ptrace.h>
#include <sys/signal.h>
#include <sys/sysctl.h>
#include <sys/user.h>
#if defined(HAVE_KINFO_GETFILE) || defined(HAVE_KINFO_GETVMMAP)
#include <libutil.h>
#endif
#if !defined(HAVE_KINFO_GETVMMAP)
#include "gdbsupport/filestuff.h"
#endif
#include "elf-bfd.h"
#include "fbsd-nat.h"
#include "fbsd-tdep.h"
#include <list>
/* Return the name of a file that can be opened to get the symbols for
the child process identified by PID. */
char *
fbsd_nat_target::pid_to_exec_file (int pid)
{
ssize_t len;
static char buf[PATH_MAX];
char name[PATH_MAX];
#ifdef KERN_PROC_PATHNAME
size_t buflen;
int mib[4];
mib[0] = CTL_KERN;
mib[1] = KERN_PROC;
mib[2] = KERN_PROC_PATHNAME;
mib[3] = pid;
buflen = sizeof buf;
if (sysctl (mib, 4, buf, &buflen, NULL, 0) == 0)
/* The kern.proc.pathname.<pid> sysctl returns a length of zero
for processes without an associated executable such as kernel
processes. */
return buflen == 0 ? NULL : buf;
#endif
xsnprintf (name, PATH_MAX, "/proc/%d/exe", pid);
len = readlink (name, buf, PATH_MAX - 1);
if (len != -1)
{
buf[len] = '\0';
return buf;
}
return NULL;
}
#ifdef HAVE_KINFO_GETVMMAP
/* Iterate over all the memory regions in the current inferior,
calling FUNC for each memory region. OBFD is passed as the last
argument to FUNC. */
int
fbsd_nat_target::find_memory_regions (find_memory_region_ftype func,
void *obfd)
{
pid_t pid = inferior_ptid.pid ();
struct kinfo_vmentry *kve;
uint64_t size;
int i, nitems;
gdb::unique_xmalloc_ptr<struct kinfo_vmentry>
vmentl (kinfo_getvmmap (pid, &nitems));
if (vmentl == NULL)
perror_with_name (_("Couldn't fetch VM map entries."));
for (i = 0, kve = vmentl.get (); i < nitems; i++, kve++)
{
/* Skip unreadable segments and those where MAP_NOCORE has been set. */
if (!(kve->kve_protection & KVME_PROT_READ)
|| kve->kve_flags & KVME_FLAG_NOCOREDUMP)
continue;
/* Skip segments with an invalid type. */
if (kve->kve_type != KVME_TYPE_DEFAULT
&& kve->kve_type != KVME_TYPE_VNODE
&& kve->kve_type != KVME_TYPE_SWAP
&& kve->kve_type != KVME_TYPE_PHYS)
continue;
size = kve->kve_end - kve->kve_start;
if (info_verbose)
{
fprintf_filtered (gdb_stdout,
"Save segment, %ld bytes at %s (%c%c%c)\n",
(long) size,
paddress (target_gdbarch (), kve->kve_start),
kve->kve_protection & KVME_PROT_READ ? 'r' : '-',
kve->kve_protection & KVME_PROT_WRITE ? 'w' : '-',
kve->kve_protection & KVME_PROT_EXEC ? 'x' : '-');
}
/* Invoke the callback function to create the corefile segment.
Pass MODIFIED as true, we do not know the real modification state. */
func (kve->kve_start, size, kve->kve_protection & KVME_PROT_READ,
kve->kve_protection & KVME_PROT_WRITE,
kve->kve_protection & KVME_PROT_EXEC, 1, obfd);
}
return 0;
}
#else
static int
fbsd_read_mapping (FILE *mapfile, unsigned long *start, unsigned long *end,
char *protection)
{
/* FreeBSD 5.1-RELEASE uses a 256-byte buffer. */
char buf[256];
int resident, privateresident;
unsigned long obj;
int ret = EOF;
/* As of FreeBSD 5.0-RELEASE, the layout is described in
/usr/src/sys/fs/procfs/procfs_map.c. Somewhere in 5.1-CURRENT a
new column was added to the procfs map. Therefore we can't use
fscanf since we need to support older releases too. */
if (fgets (buf, sizeof buf, mapfile) != NULL)
ret = sscanf (buf, "%lx %lx %d %d %lx %s", start, end,
&resident, &privateresident, &obj, protection);
return (ret != 0 && ret != EOF);
}
/* Iterate over all the memory regions in the current inferior,
calling FUNC for each memory region. OBFD is passed as the last
argument to FUNC. */
int
fbsd_nat_target::find_memory_regions (find_memory_region_ftype func,
void *obfd)
{
pid_t pid = inferior_ptid.pid ();
unsigned long start, end, size;
char protection[4];
int read, write, exec;
std::string mapfilename = string_printf ("/proc/%ld/map", (long) pid);
gdb_file_up mapfile (fopen (mapfilename.c_str (), "r"));
if (mapfile == NULL)
error (_("Couldn't open %s."), mapfilename.c_str ());
if (info_verbose)
fprintf_filtered (gdb_stdout,
"Reading memory regions from %s\n", mapfilename.c_str ());
/* Now iterate until end-of-file. */
while (fbsd_read_mapping (mapfile.get (), &start, &end, &protection[0]))
{
size = end - start;
read = (strchr (protection, 'r') != 0);
write = (strchr (protection, 'w') != 0);
exec = (strchr (protection, 'x') != 0);
if (info_verbose)
{
fprintf_filtered (gdb_stdout,
"Save segment, %ld bytes at %s (%c%c%c)\n",
size, paddress (target_gdbarch (), start),
read ? 'r' : '-',
write ? 'w' : '-',
exec ? 'x' : '-');
}
/* Invoke the callback function to create the corefile segment.
Pass MODIFIED as true, we do not know the real modification state. */
func (start, size, read, write, exec, 1, obfd);
}
return 0;
}
#endif
/* Fetch the command line for a running process. */
static gdb::unique_xmalloc_ptr<char>
fbsd_fetch_cmdline (pid_t pid)
{
size_t len;
int mib[4];
len = 0;
mib[0] = CTL_KERN;
mib[1] = KERN_PROC;
mib[2] = KERN_PROC_ARGS;
mib[3] = pid;
if (sysctl (mib, 4, NULL, &len, NULL, 0) == -1)
return nullptr;
if (len == 0)
return nullptr;
gdb::unique_xmalloc_ptr<char> cmdline ((char *) xmalloc (len));
if (sysctl (mib, 4, cmdline.get (), &len, NULL, 0) == -1)
return nullptr;
/* Join the arguments with spaces to form a single string. */
char *cp = cmdline.get ();
for (size_t i = 0; i < len - 1; i++)
if (cp[i] == '\0')
cp[i] = ' ';
cp[len - 1] = '\0';
return cmdline;
}
/* Fetch the external variant of the kernel's internal process
structure for the process PID into KP. */
static bool
fbsd_fetch_kinfo_proc (pid_t pid, struct kinfo_proc *kp)
{
size_t len;
int mib[4];
len = sizeof *kp;
mib[0] = CTL_KERN;
mib[1] = KERN_PROC;
mib[2] = KERN_PROC_PID;
mib[3] = pid;
return (sysctl (mib, 4, kp, &len, NULL, 0) == 0);
}
/* Implement the "info_proc" target_ops method. */
bool
fbsd_nat_target::info_proc (const char *args, enum info_proc_what what)
{
#ifdef HAVE_KINFO_GETFILE
gdb::unique_xmalloc_ptr<struct kinfo_file> fdtbl;
int nfd = 0;
#endif
struct kinfo_proc kp;
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
bool do_status = false;
switch (what)
{
case IP_MINIMAL:
do_cmdline = true;
do_cwd = true;
do_exe = true;
break;
#ifdef HAVE_KINFO_GETVMMAP
case IP_MAPPINGS:
do_mappings = true;
break;
#endif
case IP_STATUS:
case IP_STAT:
do_status = true;
break;
case IP_CMDLINE:
do_cmdline = true;
break;
case IP_EXE:
do_exe = true;
break;
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
do_status = true;
break;
default:
error (_("Not supported on this target."));
}
gdb_argv built_argv (args);
if (built_argv.count () == 0)
{
pid = inferior_ptid.pid ();
if (pid == 0)
error (_("No current process: you must name one."));
}
else if (built_argv.count () == 1 && isdigit (built_argv[0][0]))
pid = strtol (built_argv[0], NULL, 10);
else
error (_("Invalid arguments."));
printf_filtered (_("process %d\n"), pid);
#ifdef HAVE_KINFO_GETFILE
if (do_cwd || do_exe || do_files)
fdtbl.reset (kinfo_getfile (pid, &nfd));
#endif
if (do_cmdline)
{
gdb::unique_xmalloc_ptr<char> cmdline = fbsd_fetch_cmdline (pid);
if (cmdline != nullptr)
printf_filtered ("cmdline = '%s'\n", cmdline.get ());
else
warning (_("unable to fetch command line"));
}
if (do_cwd)
{
const char *cwd = NULL;
#ifdef HAVE_KINFO_GETFILE
struct kinfo_file *kf = fdtbl.get ();
for (int i = 0; i < nfd; i++, kf++)
{
if (kf->kf_type == KF_TYPE_VNODE && kf->kf_fd == KF_FD_TYPE_CWD)
{
cwd = kf->kf_path;
break;
}
}
#endif
if (cwd != NULL)
printf_filtered ("cwd = '%s'\n", cwd);
else
warning (_("unable to fetch current working directory"));
}
if (do_exe)
{
const char *exe = NULL;
#ifdef HAVE_KINFO_GETFILE
struct kinfo_file *kf = fdtbl.get ();
for (int i = 0; i < nfd; i++, kf++)
{
if (kf->kf_type == KF_TYPE_VNODE && kf->kf_fd == KF_FD_TYPE_TEXT)
{
exe = kf->kf_path;
break;
}
}
#endif
if (exe == NULL)
exe = pid_to_exec_file (pid);
if (exe != NULL)
printf_filtered ("exe = '%s'\n", exe);
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)
{
int nvment;
gdb::unique_xmalloc_ptr<struct kinfo_vmentry>
vmentl (kinfo_getvmmap (pid, &nvment));
if (vmentl != nullptr)
{
int addr_bit = TARGET_CHAR_BIT * sizeof (void *);
fbsd_info_proc_mappings_header (addr_bit);
struct kinfo_vmentry *kve = vmentl.get ();
for (int i = 0; i < nvment; i++, kve++)
fbsd_info_proc_mappings_entry (addr_bit, kve->kve_start,
kve->kve_end, kve->kve_offset,
kve->kve_flags, kve->kve_protection,
kve->kve_path);
}
else
warning (_("unable to fetch virtual memory map"));
}
#endif
if (do_status)
{
if (!fbsd_fetch_kinfo_proc (pid, &kp))
warning (_("Failed to fetch process information"));
else
{
const char *state;
int pgtok;
printf_filtered ("Name: %s\n", kp.ki_comm);
switch (kp.ki_stat)
{
case SIDL:
state = "I (idle)";
break;
case SRUN:
state = "R (running)";
break;
case SSTOP:
state = "T (stopped)";
break;
case SZOMB:
state = "Z (zombie)";
break;
case SSLEEP:
state = "S (sleeping)";
break;
case SWAIT:
state = "W (interrupt wait)";
break;
case SLOCK:
state = "L (blocked on lock)";
break;
default:
state = "? (unknown)";
break;
}
printf_filtered ("State: %s\n", state);
printf_filtered ("Parent process: %d\n", kp.ki_ppid);
printf_filtered ("Process group: %d\n", kp.ki_pgid);
printf_filtered ("Session id: %d\n", kp.ki_sid);
printf_filtered ("TTY: %ju\n", (uintmax_t) kp.ki_tdev);
printf_filtered ("TTY owner process group: %d\n", kp.ki_tpgid);
printf_filtered ("User IDs (real, effective, saved): %d %d %d\n",
kp.ki_ruid, kp.ki_uid, kp.ki_svuid);
printf_filtered ("Group IDs (real, effective, saved): %d %d %d\n",
kp.ki_rgid, kp.ki_groups[0], kp.ki_svgid);
printf_filtered ("Groups: ");
for (int i = 0; i < kp.ki_ngroups; i++)
printf_filtered ("%d ", kp.ki_groups[i]);
printf_filtered ("\n");
printf_filtered ("Minor faults (no memory page): %ld\n",
kp.ki_rusage.ru_minflt);
printf_filtered ("Minor faults, children: %ld\n",
kp.ki_rusage_ch.ru_minflt);
printf_filtered ("Major faults (memory page faults): %ld\n",
kp.ki_rusage.ru_majflt);
printf_filtered ("Major faults, children: %ld\n",
kp.ki_rusage_ch.ru_majflt);
printf_filtered ("utime: %jd.%06ld\n",
(intmax_t) kp.ki_rusage.ru_utime.tv_sec,
kp.ki_rusage.ru_utime.tv_usec);
printf_filtered ("stime: %jd.%06ld\n",
(intmax_t) kp.ki_rusage.ru_stime.tv_sec,
kp.ki_rusage.ru_stime.tv_usec);
printf_filtered ("utime, children: %jd.%06ld\n",
(intmax_t) kp.ki_rusage_ch.ru_utime.tv_sec,
kp.ki_rusage_ch.ru_utime.tv_usec);
printf_filtered ("stime, children: %jd.%06ld\n",
(intmax_t) kp.ki_rusage_ch.ru_stime.tv_sec,
kp.ki_rusage_ch.ru_stime.tv_usec);
printf_filtered ("'nice' value: %d\n", kp.ki_nice);
printf_filtered ("Start time: %jd.%06ld\n", kp.ki_start.tv_sec,
kp.ki_start.tv_usec);
pgtok = getpagesize () / 1024;
printf_filtered ("Virtual memory size: %ju kB\n",
(uintmax_t) kp.ki_size / 1024);
printf_filtered ("Data size: %ju kB\n",
(uintmax_t) kp.ki_dsize * pgtok);
printf_filtered ("Stack size: %ju kB\n",
(uintmax_t) kp.ki_ssize * pgtok);
printf_filtered ("Text size: %ju kB\n",
(uintmax_t) kp.ki_tsize * pgtok);
printf_filtered ("Resident set size: %ju kB\n",
(uintmax_t) kp.ki_rssize * pgtok);
printf_filtered ("Maximum RSS: %ju kB\n",
(uintmax_t) kp.ki_rusage.ru_maxrss);
printf_filtered ("Pending Signals: ");
for (int i = 0; i < _SIG_WORDS; i++)
printf_filtered ("%08x ", kp.ki_siglist.__bits[i]);
printf_filtered ("\n");
printf_filtered ("Ignored Signals: ");
for (int i = 0; i < _SIG_WORDS; i++)
printf_filtered ("%08x ", kp.ki_sigignore.__bits[i]);
printf_filtered ("\n");
printf_filtered ("Caught Signals: ");
for (int i = 0; i < _SIG_WORDS; i++)
printf_filtered ("%08x ", kp.ki_sigcatch.__bits[i]);
printf_filtered ("\n");
}
}
return true;
}
/*
* The current layout of siginfo_t on FreeBSD was adopted in SVN
* revision 153154 which shipped in FreeBSD versions 7.0 and later.
* Don't bother supporting the older layout on older kernels. The
* older format was also never used in core dump notes.
*/
#if __FreeBSD_version >= 700009
#define USE_SIGINFO
#endif
#ifdef USE_SIGINFO
/* Return the size of siginfo for the current inferior. */
#ifdef __LP64__
union sigval32 {
int sival_int;
uint32_t sival_ptr;
};
/* This structure matches the naming and layout of `siginfo_t' in
<sys/signal.h>. In particular, the `si_foo' macros defined in that
header can be used with both types to copy fields in the `_reason'
union. */
struct siginfo32
{
int si_signo;
int si_errno;
int si_code;
__pid_t si_pid;
__uid_t si_uid;
int si_status;
uint32_t si_addr;
union sigval32 si_value;
union
{
struct
{
int _trapno;
} _fault;
struct
{
int _timerid;
int _overrun;
} _timer;
struct
{
int _mqd;
} _mesgq;
struct
{
int32_t _band;
} _poll;
struct
{
int32_t __spare1__;
int __spare2__[7];
} __spare__;
} _reason;
};
#endif
static size_t
fbsd_siginfo_size ()
{
#ifdef __LP64__
struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
/* Is the inferior 32-bit? If so, use the 32-bit siginfo size. */
if (gdbarch_long_bit (gdbarch) == 32)
return sizeof (struct siginfo32);
#endif
return sizeof (siginfo_t);
}
/* Convert a native 64-bit siginfo object to a 32-bit object. Note
that FreeBSD doesn't support writing to $_siginfo, so this only
needs to convert one way. */
static void
fbsd_convert_siginfo (siginfo_t *si)
{
#ifdef __LP64__
struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
/* Is the inferior 32-bit? If not, nothing to do. */
if (gdbarch_long_bit (gdbarch) != 32)
return;
struct siginfo32 si32;
si32.si_signo = si->si_signo;
si32.si_errno = si->si_errno;
si32.si_code = si->si_code;
si32.si_pid = si->si_pid;
si32.si_uid = si->si_uid;
si32.si_status = si->si_status;
si32.si_addr = (uintptr_t) si->si_addr;
/* If sival_ptr is being used instead of sival_int on a big-endian
platform, then sival_int will be zero since it holds the upper
32-bits of the pointer value. */
#if _BYTE_ORDER == _BIG_ENDIAN
if (si->si_value.sival_int == 0)
si32.si_value.sival_ptr = (uintptr_t) si->si_value.sival_ptr;
else
si32.si_value.sival_int = si->si_value.sival_int;
#else
si32.si_value.sival_int = si->si_value.sival_int;
#endif
/* Always copy the spare fields and then possibly overwrite them for
signal-specific or code-specific fields. */
si32._reason.__spare__.__spare1__ = si->_reason.__spare__.__spare1__;
for (int i = 0; i < 7; i++)
si32._reason.__spare__.__spare2__[i] = si->_reason.__spare__.__spare2__[i];
switch (si->si_signo) {
case SIGILL:
case SIGFPE:
case SIGSEGV:
case SIGBUS:
si32.si_trapno = si->si_trapno;
break;
}
switch (si->si_code) {
case SI_TIMER:
si32.si_timerid = si->si_timerid;
si32.si_overrun = si->si_overrun;
break;
case SI_MESGQ:
si32.si_mqd = si->si_mqd;
break;
}
memcpy(si, &si32, sizeof (si32));
#endif
}
#endif
/* Implement the "xfer_partial" target_ops method. */
enum target_xfer_status
fbsd_nat_target::xfer_partial (enum target_object object,
const char *annex, gdb_byte *readbuf,
const gdb_byte *writebuf,
ULONGEST offset, ULONGEST len,
ULONGEST *xfered_len)
{
pid_t pid = inferior_ptid.pid ();
switch (object)
{
#ifdef USE_SIGINFO
case TARGET_OBJECT_SIGNAL_INFO:
{
struct ptrace_lwpinfo pl;
size_t siginfo_size;
/* FreeBSD doesn't support writing to $_siginfo. */
if (writebuf != NULL)
return TARGET_XFER_E_IO;
if (inferior_ptid.lwp_p ())
pid = inferior_ptid.lwp ();
siginfo_size = fbsd_siginfo_size ();
if (offset > siginfo_size)
return TARGET_XFER_E_IO;
if (ptrace (PT_LWPINFO, pid, (PTRACE_TYPE_ARG3) &pl, sizeof (pl)) == -1)
return TARGET_XFER_E_IO;
if (!(pl.pl_flags & PL_FLAG_SI))
return TARGET_XFER_E_IO;
fbsd_convert_siginfo (&pl.pl_siginfo);
if (offset + len > siginfo_size)
len = siginfo_size - offset;
memcpy (readbuf, ((gdb_byte *) &pl.pl_siginfo) + offset, len);
*xfered_len = len;
return TARGET_XFER_OK;
}
#endif
#ifdef KERN_PROC_AUXV
case TARGET_OBJECT_AUXV:
{
gdb::byte_vector buf_storage;
gdb_byte *buf;
size_t buflen;
int mib[4];
if (writebuf != NULL)
return TARGET_XFER_E_IO;
mib[0] = CTL_KERN;
mib[1] = KERN_PROC;
mib[2] = KERN_PROC_AUXV;
mib[3] = pid;
if (offset == 0)
{
buf = readbuf;
buflen = len;
}
else
{
buflen = offset + len;
buf_storage.resize (buflen);
buf = buf_storage.data ();
}
if (sysctl (mib, 4, buf, &buflen, NULL, 0) == 0)
{
if (offset != 0)
{
if (buflen > offset)
{
buflen -= offset;
memcpy (readbuf, buf + offset, buflen);
}
else
buflen = 0;
}
*xfered_len = buflen;
return (buflen == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
}
return TARGET_XFER_E_IO;
}
#endif
#if defined(KERN_PROC_VMMAP) && defined(KERN_PROC_PS_STRINGS)
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;
}
#endif
default:
return inf_ptrace_target::xfer_partial (object, annex,
readbuf, writebuf, offset,
len, xfered_len);
}
}
#ifdef PT_LWPINFO
static bool debug_fbsd_lwp;
static bool debug_fbsd_nat;
static void
show_fbsd_lwp_debug (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("Debugging of FreeBSD lwp module is %s.\n"), value);
}
static void
show_fbsd_nat_debug (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("Debugging of FreeBSD native target is %s.\n"),
value);
}
/*
FreeBSD's first thread support was via a "reentrant" version of libc
(libc_r) that first shipped in 2.2.7. This library multiplexed all
of the threads in a process onto a single kernel thread. This
library was supported via the bsd-uthread target.
FreeBSD 5.1 introduced two new threading libraries that made use of
multiple kernel threads. The first (libkse) scheduled M user
threads onto N (<= M) kernel threads (LWPs). The second (libthr)
bound each user thread to a dedicated kernel thread. libkse shipped
as the default threading library (libpthread).
FreeBSD 5.3 added a libthread_db to abstract the interface across
the various thread libraries (libc_r, libkse, and libthr).
FreeBSD 7.0 switched the default threading library from from libkse
to libpthread and removed libc_r.
FreeBSD 8.0 removed libkse and the in-kernel support for it. The
only threading library supported by 8.0 and later is libthr which
ties each user thread directly to an LWP. To simplify the
implementation, this target only supports LWP-backed threads using
ptrace directly rather than libthread_db.
FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS.
*/
/* Return true if PTID is still active in the inferior. */
bool
fbsd_nat_target::thread_alive (ptid_t ptid)
{
if (ptid.lwp_p ())
{
struct ptrace_lwpinfo pl;
if (ptrace (PT_LWPINFO, ptid.lwp (), (caddr_t) &pl, sizeof pl)
== -1)
return false;
#ifdef PL_FLAG_EXITED
if (pl.pl_flags & PL_FLAG_EXITED)
return false;
#endif
}
return true;
}
/* Convert PTID to a string. */
std::string
fbsd_nat_target::pid_to_str (ptid_t ptid)
{
lwpid_t lwp;
lwp = ptid.lwp ();
if (lwp != 0)
{
int pid = ptid.pid ();
return string_printf ("LWP %d of process %d", lwp, pid);
}
return normal_pid_to_str (ptid);
}
#ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
/* Return the name assigned to a thread by an application. Returns
the string in a static buffer. */
const char *
fbsd_nat_target::thread_name (struct thread_info *thr)
{
struct ptrace_lwpinfo pl;
struct kinfo_proc kp;
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
if a name has not been set explicitly. Return a NULL name in
that case. */
if (!fbsd_fetch_kinfo_proc (pid, &kp))
perror_with_name (_("Failed to fetch process information"));
if (ptrace (PT_LWPINFO, lwp, (caddr_t) &pl, sizeof pl) == -1)
perror_with_name (("ptrace"));
if (strcmp (kp.ki_comm, pl.pl_tdname) == 0)
return NULL;
xsnprintf (buf, sizeof buf, "%s", pl.pl_tdname);
return buf;
}
#endif
/* Enable additional event reporting on new processes.
To catch fork events, PTRACE_FORK is set on every traced process
to enable stops on returns from fork or vfork. Note that both the
parent and child will always stop, even if system call stops are
not enabled.
To catch LWP events, PTRACE_EVENTS is set on every traced process.
This enables stops on the birth for new LWPs (excluding the "main" LWP)
and the death of LWPs (excluding the last LWP in a process). Note
that unlike fork events, the LWP that creates a new LWP does not
report an event. */
static void
fbsd_enable_proc_events (pid_t pid)
{
#ifdef PT_GET_EVENT_MASK
int events;
if (ptrace (PT_GET_EVENT_MASK, pid, (PTRACE_TYPE_ARG3)&events,
sizeof (events)) == -1)
perror_with_name (("ptrace"));
events |= PTRACE_FORK | PTRACE_LWP;
#ifdef PTRACE_VFORK
events |= PTRACE_VFORK;
#endif
if (ptrace (PT_SET_EVENT_MASK, pid, (PTRACE_TYPE_ARG3)&events,
sizeof (events)) == -1)
perror_with_name (("ptrace"));
#else
#ifdef TDP_RFPPWAIT
if (ptrace (PT_FOLLOW_FORK, pid, (PTRACE_TYPE_ARG3)0, 1) == -1)
perror_with_name (("ptrace"));
#endif
#ifdef PT_LWP_EVENTS
if (ptrace (PT_LWP_EVENTS, pid, (PTRACE_TYPE_ARG3)0, 1) == -1)
perror_with_name (("ptrace"));
#endif
#endif
}
/* Add threads for any new LWPs in a process.
When LWP events are used, this function is only used to detect existing
threads when attaching to a process. On older systems, this function is
called to discover new threads each time the thread list is updated. */
static void
fbsd_add_threads (fbsd_nat_target *target, pid_t pid)
{
int i, nlwps;
gdb_assert (!in_thread_list (target, ptid_t (pid)));
nlwps = ptrace (PT_GETNUMLWPS, pid, NULL, 0);
if (nlwps == -1)
perror_with_name (("ptrace"));
gdb::unique_xmalloc_ptr<lwpid_t[]> lwps (XCNEWVEC (lwpid_t, nlwps));
nlwps = ptrace (PT_GETLWPLIST, pid, (caddr_t) lwps.get (), nlwps);
if (nlwps == -1)
perror_with_name (("ptrace"));
for (i = 0; i < nlwps; i++)
{
ptid_t ptid = ptid_t (pid, lwps[i], 0);
if (!in_thread_list (target, ptid))
{
#ifdef PT_LWP_EVENTS
struct ptrace_lwpinfo pl;
/* Don't add exited threads. Note that this is only called
when attaching to a multi-threaded process. */
if (ptrace (PT_LWPINFO, lwps[i], (caddr_t) &pl, sizeof pl) == -1)
perror_with_name (("ptrace"));
if (pl.pl_flags & PL_FLAG_EXITED)
continue;
#endif
if (debug_fbsd_lwp)
fprintf_unfiltered (gdb_stdlog,
"FLWP: adding thread for LWP %u\n",
lwps[i]);
add_thread (target, ptid);
}
}
}
/* Implement the "update_thread_list" target_ops method. */
void
fbsd_nat_target::update_thread_list ()
{
#ifdef PT_LWP_EVENTS
/* With support for thread events, threads are added/deleted from the
list as events are reported, so just try deleting exited threads. */
delete_exited_threads ();
#else
prune_threads ();
fbsd_add_threads (this, inferior_ptid.pid ());
#endif
}
#ifdef TDP_RFPPWAIT
/*
To catch fork events, PT_FOLLOW_FORK is set on every traced process
to enable stops on returns from fork or vfork. Note that both the
parent and child will always stop, even if system call stops are not
enabled.
After a fork, both the child and parent process will stop and report
an event. However, there is no guarantee of order. If the parent
reports its stop first, then fbsd_wait explicitly waits for the new
child before returning. If the child reports its stop first, then
the event is saved on a list and ignored until the parent's stop is
reported. fbsd_wait could have been changed to fetch the parent PID
of the new child and used that to wait for the parent explicitly.
However, if two threads in the parent fork at the same time, then
the wait on the parent might return the "wrong" fork event.
The initial version of PT_FOLLOW_FORK did not set PL_FLAG_CHILD for
the new child process. This flag could be inferred by treating any
events for an unknown pid as a new child.
In addition, the initial version of PT_FOLLOW_FORK did not report a
stop event for the parent process of a vfork until after the child
process executed a new program or exited. The kernel was changed to
defer the wait for exit or exec of the child until after posting the
stop event shortly after the change to introduce PL_FLAG_CHILD.
This could be worked around by reporting a vfork event when the
child event posted and ignoring the subsequent event from the
parent.
This implementation requires both of these fixes for simplicity's
sake. FreeBSD versions newer than 9.1 contain both fixes.
*/
static std::list<ptid_t> fbsd_pending_children;
/* Record a new child process event that is reported before the
corresponding fork event in the parent. */
static void
fbsd_remember_child (ptid_t pid)
{
fbsd_pending_children.push_front (pid);
}
/* Check for a previously-recorded new child process event for PID.
If one is found, remove it from the list and return the PTID. */
static ptid_t
fbsd_is_child_pending (pid_t pid)
{
for (auto it = fbsd_pending_children.begin ();
it != fbsd_pending_children.end (); it++)
if (it->pid () == pid)
{
ptid_t ptid = *it;
fbsd_pending_children.erase (it);
return ptid;
}
return null_ptid;
}
#ifndef PTRACE_VFORK
static std::forward_list<ptid_t> fbsd_pending_vfork_done;
/* Record a pending vfork done event. */
static void
fbsd_add_vfork_done (ptid_t pid)
{
fbsd_pending_vfork_done.push_front (pid);
}
/* Check for a pending vfork done event for a specific PID. */
static int
fbsd_is_vfork_done_pending (pid_t pid)
{
for (auto it = fbsd_pending_vfork_done.begin ();
it != fbsd_pending_vfork_done.end (); it++)
if (it->pid () == pid)
return 1;
return 0;
}
/* Check for a pending vfork done event. If one is found, remove it
from the list and return the PTID. */
static ptid_t
fbsd_next_vfork_done (void)
{
if (!fbsd_pending_vfork_done.empty ())
{
ptid_t ptid = fbsd_pending_vfork_done.front ();
fbsd_pending_vfork_done.pop_front ();
return ptid;
}
return null_ptid;
}
#endif
#endif
/* Implement the "resume" target_ops method. */
void
fbsd_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signo)
{
#if defined(TDP_RFPPWAIT) && !defined(PTRACE_VFORK)
pid_t pid;
/* Don't PT_CONTINUE a process which has a pending vfork done event. */
if (minus_one_ptid == ptid)
pid = inferior_ptid.pid ();
else
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.pid (), ptid.lwp (),
ptid.tid ());
if (ptid.lwp_p ())
{
/* If ptid is a specific LWP, suspend all other LWPs in the process. */
inferior *inf = find_inferior_ptid (this, ptid);
for (thread_info *tp : inf->non_exited_threads ())
{
int request;
if (tp->ptid.lwp () == ptid.lwp ())
request = PT_RESUME;
else
request = PT_SUSPEND;
if (ptrace (request, tp->ptid.lwp (), NULL, 0) == -1)
perror_with_name (("ptrace"));
}
}
else
{
/* If ptid is a wildcard, resume all matching threads (they won't run
until the process is continued however). */
for (thread_info *tp : all_non_exited_threads (this, ptid))
if (ptrace (PT_RESUME, tp->ptid.lwp (), NULL, 0) == -1)
perror_with_name (("ptrace"));
ptid = inferior_ptid;
}
#if __FreeBSD_version < 1200052
/* When multiple threads within a process wish to report STOPPED
events from wait(), the kernel picks one thread event as the
thread event to report. The chosen thread event is retrieved via
PT_LWPINFO by passing the process ID as the request pid. If
multiple events are pending, then the subsequent wait() after
resuming a process will report another STOPPED event after
resuming the process to handle the next thread event and so on.
A single thread event is cleared as a side effect of resuming the
process with PT_CONTINUE, PT_STEP, etc. In older kernels,
however, the request pid was used to select which thread's event
was cleared rather than always clearing the event that was just
reported. To avoid clearing the event of the wrong LWP, always
pass the process ID instead of an LWP ID to PT_CONTINUE or
PT_SYSCALL.
In the case of stepping, the process ID cannot be used with
PT_STEP since it would step the thread that reported an event
which may not be the thread indicated by PTID. For stepping, use
PT_SETSTEP to enable stepping on the desired thread before
resuming the process via PT_CONTINUE instead of using
PT_STEP. */
if (step)
{
if (ptrace (PT_SETSTEP, get_ptrace_pid (ptid), NULL, 0) == -1)
perror_with_name (("ptrace"));
step = 0;
}
ptid = ptid_t (ptid.pid ());
#endif
inf_ptrace_target::resume (ptid, step, signo);
}
#ifdef USE_SIGTRAP_SIGINFO
/* Handle breakpoint and trace traps reported via SIGTRAP. If the
trap was a breakpoint or trace trap that should be reported to the
core, return true. */
static bool
fbsd_handle_debug_trap (fbsd_nat_target *target, ptid_t ptid,
const struct ptrace_lwpinfo &pl)
{
/* Ignore traps without valid siginfo or for signals other than
SIGTRAP.
FreeBSD kernels prior to r341800 can return stale siginfo for at
least some events, but those events can be identified by
additional flags set in pl_flags. True breakpoint and
single-step traps should not have other flags set in
pl_flags. */
if (pl.pl_flags != PL_FLAG_SI || pl.pl_siginfo.si_signo != SIGTRAP)
return false;
/* Trace traps are either a single step or a hardware watchpoint or
breakpoint. */
if (pl.pl_siginfo.si_code == TRAP_TRACE)
{
if (debug_fbsd_nat)
fprintf_unfiltered (gdb_stdlog,
"FNAT: trace trap for LWP %ld\n", ptid.lwp ());
return true;
}
if (pl.pl_siginfo.si_code == TRAP_BRKPT)
{
/* Fixup PC for the software breakpoint. */
struct regcache *regcache = get_thread_regcache (target, ptid);
struct gdbarch *gdbarch = regcache->arch ();
int decr_pc = gdbarch_decr_pc_after_break (gdbarch);
if (debug_fbsd_nat)
fprintf_unfiltered (gdb_stdlog,
"FNAT: sw breakpoint trap for LWP %ld\n",
ptid.lwp ());
if (decr_pc != 0)
{
CORE_ADDR pc;
pc = regcache_read_pc (regcache);
regcache_write_pc (regcache, pc - decr_pc);
}
return true;
}
return false;
}
#endif
/* Wait for the child specified by PTID to do something. Return the
process ID of the child, or MINUS_ONE_PTID in case of error; store
the status in *OURSTATUS. */
ptid_t
fbsd_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
int target_options)
{
ptid_t wptid;
while (1)
{
#ifndef PTRACE_VFORK
wptid = fbsd_next_vfork_done ();
if (wptid != null_ptid)
{
ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
return wptid;
}
#endif
wptid = inf_ptrace_target::wait (ptid, ourstatus, target_options);
if (ourstatus->kind == TARGET_WAITKIND_STOPPED)
{
struct ptrace_lwpinfo pl;
pid_t pid;
int status;
pid = wptid.pid ();
if (ptrace (PT_LWPINFO, pid, (caddr_t) &pl, sizeof pl) == -1)
perror_with_name (("ptrace"));
wptid = ptid_t (pid, pl.pl_lwpid, 0);
if (debug_fbsd_nat)
{
fprintf_unfiltered (gdb_stdlog,
"FNAT: stop for LWP %u event %d flags %#x\n",
pl.pl_lwpid, pl.pl_event, pl.pl_flags);
if (pl.pl_flags & PL_FLAG_SI)
fprintf_unfiltered (gdb_stdlog,
"FNAT: si_signo %u si_code %u\n",
pl.pl_siginfo.si_signo,
pl.pl_siginfo.si_code);
}
#ifdef PT_LWP_EVENTS
if (pl.pl_flags & PL_FLAG_EXITED)
{
/* If GDB attaches to a multi-threaded process, exiting
threads might be skipped during post_attach that
have not yet reported their PL_FLAG_EXITED event.
Ignore EXITED events for an unknown LWP. */
thread_info *thr = find_thread_ptid (this, wptid);
if (thr != nullptr)
{
if (debug_fbsd_lwp)
fprintf_unfiltered (gdb_stdlog,
"FLWP: deleting thread for LWP %u\n",
pl.pl_lwpid);
if (print_thread_events)
printf_unfiltered (_("[%s exited]\n"),
target_pid_to_str (wptid).c_str ());
delete_thread (thr);
}
if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1)
perror_with_name (("ptrace"));
continue;
}
#endif
/* Switch to an LWP PTID on the first stop in a new process.
This is done after handling PL_FLAG_EXITED to avoid
switching to an exited LWP. It is done before checking
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 (this, 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 (this, ptid_t (pid), wptid);
}
#ifdef PT_LWP_EVENTS
if (pl.pl_flags & PL_FLAG_BORN)
{
/* If GDB attaches to a multi-threaded process, newborn
threads might be added by fbsd_add_threads that have
not yet reported their PL_FLAG_BORN event. Ignore
BORN events for an already-known LWP. */
if (!in_thread_list (this, wptid))
{
if (debug_fbsd_lwp)
fprintf_unfiltered (gdb_stdlog,
"FLWP: adding thread for LWP %u\n",
pl.pl_lwpid);
add_thread (this, wptid);
}
ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
return wptid;
}
#endif
#ifdef TDP_RFPPWAIT
if (pl.pl_flags & PL_FLAG_FORKED)
{
#ifndef PTRACE_VFORK
struct kinfo_proc kp;
#endif
ptid_t child_ptid;
pid_t child;
child = pl.pl_child_pid;
ourstatus->kind = TARGET_WAITKIND_FORKED;
#ifdef PTRACE_VFORK
if (pl.pl_flags & PL_FLAG_VFORKED)
ourstatus->kind = TARGET_WAITKIND_VFORKED;
#endif
/* Make sure the other end of the fork is stopped too. */
child_ptid = fbsd_is_child_pending (child);
if (child_ptid == null_ptid)
{
pid = waitpid (child, &status, 0);
if (pid == -1)
perror_with_name (("waitpid"));
gdb_assert (pid == child);
if (ptrace (PT_LWPINFO, child, (caddr_t)&pl, sizeof pl) == -1)
perror_with_name (("ptrace"));
gdb_assert (pl.pl_flags & PL_FLAG_CHILD);
child_ptid = ptid_t (child, pl.pl_lwpid, 0);
}
/* Enable additional events on the child process. */
fbsd_enable_proc_events (child_ptid.pid ());
#ifndef PTRACE_VFORK
/* For vfork, the child process will have the P_PPWAIT
flag set. */
if (fbsd_fetch_kinfo_proc (child, &kp))
{
if (kp.ki_flag & P_PPWAIT)
ourstatus->kind = TARGET_WAITKIND_VFORKED;
}
else
warning (_("Failed to fetch process information"));
#endif
ourstatus->value.related_pid = child_ptid;
return wptid;
}
if (pl.pl_flags & PL_FLAG_CHILD)
{
/* Remember that this child forked, but do not report it
until the parent reports its corresponding fork
event. */
fbsd_remember_child (wptid);
continue;
}
#ifdef PTRACE_VFORK
if (pl.pl_flags & PL_FLAG_VFORK_DONE)
{
ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
return wptid;
}
#endif
#endif
#ifdef PL_FLAG_EXEC
if (pl.pl_flags & PL_FLAG_EXEC)
{
ourstatus->kind = TARGET_WAITKIND_EXECD;
ourstatus->value.execd_pathname
= xstrdup (pid_to_exec_file (pid));
return wptid;
}
#endif
#ifdef USE_SIGTRAP_SIGINFO
if (fbsd_handle_debug_trap (this, wptid, pl))
return wptid;
#endif
/* Note that PL_FLAG_SCE is set for any event reported while
a thread is executing a system call in the kernel. In
particular, signals that interrupt a sleep in a system
call will report this flag as part of their event. Stops
explicitly for system call entry and exit always use
SIGTRAP, so only treat SIGTRAP events as system call
entry/exit events. */
if (pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)
&& ourstatus->value.sig == SIGTRAP)
{
#ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
if (catch_syscall_enabled ())
{
if (catching_syscall_number (pl.pl_syscall_code))
{
if (pl.pl_flags & PL_FLAG_SCE)
ourstatus->kind = TARGET_WAITKIND_SYSCALL_ENTRY;
else
ourstatus->kind = TARGET_WAITKIND_SYSCALL_RETURN;
ourstatus->value.syscall_number = pl.pl_syscall_code;
return wptid;
}
}
#endif
/* If the core isn't interested in this event, just
continue the process explicitly and wait for another
event. Note that PT_SYSCALL is "sticky" on FreeBSD
and once system call stops are enabled on a process
it stops for all system call entries and exits. */
if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1)
perror_with_name (("ptrace"));
continue;
}
}
return wptid;
}
}
#ifdef USE_SIGTRAP_SIGINFO
/* Implement the "stopped_by_sw_breakpoint" target_ops method. */
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 false;
return (pl.pl_flags == PL_FLAG_SI
&& pl.pl_siginfo.si_signo == SIGTRAP
&& pl.pl_siginfo.si_code == TRAP_BRKPT);
}
/* Implement the "supports_stopped_by_sw_breakpoint" target_ops
method. */
bool
fbsd_nat_target::supports_stopped_by_sw_breakpoint ()
{
return true;
}
#endif
#ifdef TDP_RFPPWAIT
/* Target hook for follow_fork. On entry and at return inferior_ptid is
the ptid of the followed inferior. */
int
fbsd_nat_target::follow_fork (int follow_child, int detach_fork)
{
if (!follow_child && detach_fork)
{
struct thread_info *tp = inferior_thread ();
pid_t child_pid = tp->pending_follow.value.related_pid.pid ();
/* Breakpoints have already been detached from the child by
infrun.c. */
if (ptrace (PT_DETACH, child_pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
perror_with_name (("ptrace"));
#ifndef PTRACE_VFORK
if (tp->pending_follow.kind == TARGET_WAITKIND_VFORKED)
{
/* We can't insert breakpoints until the child process has
finished with the shared memory region. The parent
process doesn't wait for the child process to exit or
exec until after it has been resumed from the ptrace stop
to report the fork. Once it has been resumed it doesn't
stop again before returning to userland, so there is no
reliable way to wait on the parent.
We can't stay attached to the child to wait for an exec
or exit because it may invoke ptrace(PT_TRACE_ME)
(e.g. if the parent process is a debugger forking a new
child process).
In the end, the best we can do is to make sure it runs
for a little while. Hopefully it will be out of range of
any breakpoints we reinsert. Usually this is only the
single-step breakpoint at vfork's return point. */
usleep (10000);
/* Schedule a fake VFORK_DONE event to report on the next
wait. */
fbsd_add_vfork_done (inferior_ptid);
}
#endif
}
return 0;
}
int
fbsd_nat_target::insert_fork_catchpoint (int pid)
{
return 0;
}
int
fbsd_nat_target::remove_fork_catchpoint (int pid)
{
return 0;
}
int
fbsd_nat_target::insert_vfork_catchpoint (int pid)
{
return 0;
}
int
fbsd_nat_target::remove_vfork_catchpoint (int pid)
{
return 0;
}
#endif
/* Implement the "post_startup_inferior" target_ops method. */
void
fbsd_nat_target::post_startup_inferior (ptid_t pid)
{
fbsd_enable_proc_events (pid.pid ());
}
/* Implement the "post_attach" target_ops method. */
void
fbsd_nat_target::post_attach (int pid)
{
fbsd_enable_proc_events (pid);
fbsd_add_threads (this, pid);
}
#ifdef PL_FLAG_EXEC
/* If the FreeBSD kernel supports PL_FLAG_EXEC, then traced processes
will always stop after exec. */
int
fbsd_nat_target::insert_exec_catchpoint (int pid)
{
return 0;
}
int
fbsd_nat_target::remove_exec_catchpoint (int pid)
{
return 0;
}
#endif
#ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
int
fbsd_nat_target::set_syscall_catchpoint (int pid, bool needed,
int any_count,
gdb::array_view<const int> syscall_counts)
{
/* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which
will catch all system call entries and exits. The system calls
are filtered by GDB rather than the kernel. */
return 0;
}
#endif
#endif
void
_initialize_fbsd_nat (void)
{
#ifdef PT_LWPINFO
add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance,
&debug_fbsd_lwp, _("\
Set debugging of FreeBSD lwp module."), _("\
Show debugging of FreeBSD lwp module."), _("\
Enables printf debugging output."),
NULL,
&show_fbsd_lwp_debug,
&setdebuglist, &showdebuglist);
add_setshow_boolean_cmd ("fbsd-nat", class_maintenance,
&debug_fbsd_nat, _("\
Set debugging of FreeBSD native target."), _("\
Show debugging of FreeBSD native target."), _("\
Enables printf debugging output."),
NULL,
&show_fbsd_nat_debug,
&setdebuglist, &showdebuglist);
#endif
}
Reference in New Issue View Git Blame Copy Permalink