binutils-gdb/gdb/gdbserver/remote-utils.c
Pedro Alves 3aee891821 [GDBserver] Multi-process + multi-arch
This patch makes GDBserver support multi-process + biarch.

Currently, if you're debugging more than one process at once with a
single gdbserver (in extended-remote mode), then all processes must
have the same architecture (e.g., 64-bit vs 32-bit).  Otherwise, you
see this:

Added inferior 2
[Switching to inferior 2 [<null>] (<noexec>)]
Reading symbols from /home/pedro/gdb/tests/main32...done.
Temporary breakpoint 2 at 0x4004cf: main. (2 locations)
Starting program: /home/pedro/gdb/tests/main32
warning: Selected architecture i386 is not compatible with reported target architecture i386:x86-64
warning: Architecture rejected target-supplied description
Remote 'g' packet reply is too long: 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000090cfffff0000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000b042f7460000000000020000230000002b0000002b0000002b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007f03000000000000ffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000801f00003b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
... etc, etc ...

Even though the process was running a 32-bit program, GDBserver sent
back to GDB a register set in 64-bit layout.

A patch (http://sourceware.org/ml/gdb-patches/2012-11/msg00228.html) a
while ago made GDB track a target_gdbarch per inferior, and as
consequence, fetch a target description per-inferior.  This patch is
the GDBserver counterpart, that makes GDBserver keep track of each
process'es XML target description and register layout.  So in the
example above, GDBserver will send the correct register set in 32-bit
layout to GDB.

A new "struct target_desc" object (tdesc for short) is added, that
holds the target description and register layout information about
each process.  Each `struct process_info' holds a pointer to a target
description.  The regcache also gains a pointer to a target
description, mainly for convenience, and parallel with GDB (and
possible future support for programs that flip processor modes).

The low target's arch_setup routines are responsible for setting the
process'es correct tdesc.  This isn't that much different to how
things were done before, except that instead of detecting the inferior
process'es architecture and calling the corresponding
init_registers_FOO routine, which would change the regcache layout
globals and recreate the threads' regcaches, the regcache.c globals
are gone, and the init_registers_$BAR routines now each initialize a
separate global struct target_desc object (one for each arch variant
GDBserver supports), and so all the init_registers_$BAR routines that
are built into GDBserver are called early at GDBserver startup time
(similarly to how GDB handles its built-in target descriptions), and
then the arch_setup routine is responsible for making
process_info->tdesc point to one of these target description globals.
The regcache module is all parameterized to get the regcache's layout
from the tdesc object instead of the old register_bytes, etc. globals.

The threads' regcaches are now created lazily.  The old scheme where
we created each of them when we added a new thread doesn't work
anymore, because we add the main thread/lwp before we see it stop for
the first time, and it is only when we see the thread stop for the
first time that we have a chance of determining the inferior's
architecture (through the_low_target.arch_setup).  Therefore when we
add the main thread we don't know which architecture/tdesc its
regcache should have.

This patch makes the gdb.multi/multi-arch.exp test now pass against
(extended-remote) GDBserver.  It currently fails, without this patch.

The IPA also uses the regcache, so it gains a new global struct
target_desc pointer, which points at the description of the process it
is loaded in.

Re. the linux-low.c & friends changes.  Since the register map
etc. may differ between processes (64-bit vs 32-bit) etc., the
linux_target_ops num_regs, regmap and regset_bitmap data fields are no
longer sufficient.  A new method is added in their place that returns
a pointer to a new struct that includes all info linux-low.c needs to
access registers of the current inferior.

The patch/discussion that originally introduced
linux-low.c:disabled_regsets mentions that the disabled_regsets set
may be different per mode (in a biarch setup), and indeed that is
cleared whenever we start a new (first) inferior, so that global is
moved as well behind the new `struct regs_info'.

On the x86 side:

I simply replaced the i387-fp.c:num_xmm_registers global with a check
for 64-bit or 32-bit process, which is equivalent to how the global
was set.  This avoided coming up with some more general mechanism that
would work for all targets that use this module (GNU/Linux, Windows,
etc.).

Tested:

  GNU/Linux IA64
  GNU/Linux MIPS64
  GNU/Linux PowerPC (Fedora 16)
  GNU/Linux s390x (Fedora 16)
  GNU/Linux sparc64 (Debian)
  GNU/Linux x86_64, -m64 and -m32 (Fedora 17)

Cross built, and smoke tested:

  i686-w64-mingw32, under Wine.
  GNU/Linux TI C6x, by Yao Qi.

Cross built but otherwise not tested:

  aarch64-linux-gnu
  arm-linux-gnu
  m68k-linux
  nios2-linux-gnu
  sh-linux-gnu
  spu
  tilegx-unknown-linux-gnu

Completely untested:

  GNU/Linux Blackfin
  GNU/Linux CRIS
  GNU/Linux CRISv32
  GNU/Linux TI Xtensa
  GNU/Linux M32R
  LynxOS
  QNX NTO

gdb/gdbserver/
2013-06-07  Pedro Alves  <palves@redhat.com>

	* Makefile.in (OBS): Add tdesc.o.
	(IPA_OBJS): Add tdesc-ipa.o.
	(tdesc-ipa.o): New rule.
	* ax.c (gdb_eval_agent_expr): Adjust register_size call to new
	interface.
	* linux-low.c (new_inferior): Delete.
	(disabled_regsets, num_regsets): Delete.
	(linux_add_process): Adjust to set the new per-process
	new_inferior flag.
	(linux_detach_one_lwp): Adjust to call regcache_invalidate_thread.
	(linux_wait_for_lwp): Adjust.  Only call arch_setup if the event
	was a stop.  When calling arch_setup, switch the current inferior
	to the thread that got an event.
	(linux_resume_one_lwp): Adjust to call regcache_invalidate_thread.
	(regsets_fetch_inferior_registers)
	(regsets_store_inferior_registers): New regsets_info parameter.
	Adjust to use it.
	(linux_register_in_regsets): New regs_info parameter.  Adjust to
	use it.
	(register_addr, fetch_register, store_register): New usrregs_info
	parameter.  Adjust to use it.
	(usr_fetch_inferior_registers, usr_store_inferior_registers): New
	parameter regs_info.  Adjust to use it.
	(linux_fetch_registers): Get the current inferior's regs_info, and
	adjust to use it.
	(linux_store_registers): Ditto.
	[HAVE_LINUX_REGSETS] (initialize_regsets_info): New.
	(initialize_low): Don't initialize the target_regsets here.  Call
	initialize_low_arch.
	* linux-low.h (target_regsets): Delete declaration.
	(struct regsets_info): New.
	(struct usrregs_info): New.
	(struct regs_info): New.
	(struct process_info_private) <new_inferior>: New field.
	(struct linux_target_ops): Delete the num_regs, regmap, and
	regset_bitmap fields.  New field regs_info.
	[HAVE_LINUX_REGSETS] (initialize_regsets_info): Declare.
	* i387-fp.c (num_xmm_registers): Delete.
	(i387_cache_to_fsave, i387_fsave_to_cache): Adjust find_regno
	calls to new interface.
	(i387_cache_to_fxsave, i387_cache_to_xsave, i387_fxsave_to_cache)
	(i387_xsave_to_cache): Adjust find_regno calls to new interface.
	Infer the number of xmm registers from the regcache's target
	description.
	* i387-fp.h (num_xmm_registers): Delete.
	* inferiors.c (add_thread): Don't install the thread's regcache
	here.
	* proc-service.c (gregset_info): Fetch the current inferior's
	regs_info.  Adjust to use it.
	* regcache.c: Include tdesc.h.
	(register_bytes, reg_defs, num_registers)
	(gdbserver_expedite_regs): Delete.
	(get_thread_regcache): If the thread doesn't have a regcache yet,
	create one, instead of aborting gdbserver.
	(regcache_invalidate_one): Rename to ...
	(regcache_invalidate_thread): ... this.
	(regcache_invalidate_one): New.
	(regcache_invalidate): Only invalidate registers of the current
	process.
	(init_register_cache): Add target_desc parameter, and use it.
	(new_register_cache): Ditto.  Assert the target description has a
	non zero registers_size.
	(regcache_cpy): Add assertions.  Adjust.
	(realloc_register_cache, set_register_cache): Delete.
	(registers_to_string, registers_from_string): Adjust.
	(find_register_by_name, find_regno, find_register_by_number)
	(register_cache_size): Add target_desc parameter, and use it.
	(free_register_cache_thread, free_register_cache_thread_one)
	(regcache_release, register_cache_size): New.
	(register_size): Add target_desc parameter, and use it.
	(register_data, supply_register, supply_register_zeroed)
	(supply_regblock, supply_register_by_name, collect_register)
	(collect_register_as_string, collect_register_by_name): Adjust.
	* regcache.h (struct target_desc): Forward declare.
	(struct regcache) <tdesc>: New field.
	(init_register_cache, new_register_cache): Add target_desc
	parameter.
	(regcache_invalidate_thread): Declare.
	(regcache_invalidate_one): Delete declaration.
	(regcache_release): Declare.
	(find_register_by_number, register_cache_size, register_size)
	(find_regno): Add target_desc parameter.
	(gdbserver_expedite_regs, gdbserver_xmltarget): Delete
	declarations.
	* remote-utils.c: Include tdesc.h.
	(outreg, prepare_resume_reply): Adjust.
	* server.c: Include tdesc.h.
	(gdbserver_xmltarget): Delete declaration.
	(get_features_xml, process_serial_event): Adjust.
	* server.h [IN_PROCESS_AGENT] (struct target_desc): Forward
	declare.
	(struct process_info) <tdesc>: New field.
	(ipa_tdesc): Declare.
	* tdesc.c: New file.
	* tdesc.h: New file.
	* tracepoint.c: Include tdesc.h.
	[IN_PROCESS_AGENT] (ipa_tdesc): Define.
	(get_context_regcache): Adjust to pass ipa_tdesc down.
	(do_action_at_tracepoint): Adjust to get the register cache size
	from the context regcache's description.
	(traceframe_walk_blocks): Adjust to get the register cache size
	from the current trace frame's description.
	(traceframe_get_pc): Adjust to get current trace frame's
	description and pass it down.
	(gdb_collect): Adjust to get the register cache size from the
	IPA's description.
	* linux-amd64-ipa.c (tdesc_amd64_linux): Declare.
	(gdbserver_xmltarget): Delete.
	(initialize_low_tracepoint): Set the ipa's target description.
	* linux-i386-ipa.c (tdesc_i386_linux): Declare.
	(initialize_low_tracepoint): Set the ipa's target description.
	* linux-x86-low.c: Include tdesc.h.
	[__x86_64__] (is_64bit_tdesc): New.
	(ps_get_thread_area, x86_get_thread_area): Use it.
	(i386_cannot_store_register): Rename to ...
	(x86_cannot_store_register): ... this.  Use is_64bit_tdesc.
	(i386_cannot_fetch_register): Rename to ...
	(x86_cannot_fetch_register): ... this.  Use is_64bit_tdesc.
	(x86_fill_gregset, x86_store_gregset): Adjust register_size calls
	to new interface.
	(target_regsets): Rename to ...
	(x86_regsets): ... this.
	(x86_get_pc, x86_set_pc): Adjust register_size calls to new
	interface.
	(x86_siginfo_fixup): Use is_64bit_tdesc.
	[__x86_64__] (tdesc_amd64_linux, tdesc_amd64_avx_linux)
	(tdesc_x32_avx_linux, tdesc_x32_linux)
	(tdesc_i386_linux, tdesc_i386_mmx_linux, tdesc_i386_avx_linux):
	Declare.
	(x86_linux_update_xmltarget): Delete.
	(I386_LINUX_XSAVE_XCR0_OFFSET): Define.
	(have_ptrace_getfpxregs, have_ptrace_getregset): New.
	(AMD64_LINUX_USER64_CS): New.
	(x86_linux_read_description): New, based on
	x86_linux_update_xmltarget.
	(same_process_callback): New.
	(x86_arch_setup_process_callback): New.
	(x86_linux_update_xmltarget): New.
	(x86_regsets_info): New.
	(amd64_linux_regs_info): New.
	(i386_linux_usrregs_info): New.
	(i386_linux_regs_info): New.
	(x86_linux_regs_info): New.
	(x86_arch_setup): Reimplement.
	(x86_install_fast_tracepoint_jump_pad): Use is_64bit_tdesc.
	(x86_emit_ops): Ditto.
	(the_low_target): Adjust.  Install x86_linux_regs_info,
	x86_cannot_fetch_register, and x86_cannot_store_register.
	(initialize_low_arch): New.
	* linux-ia64-low.c (tdesc_ia64): Declare.
	(ia64_fetch_register): Adjust.
	(ia64_usrregs_info, regs_info): New globals.
	(ia64_regs_info): New function.
	(the_low_target): Adjust.
	(initialize_low_arch): New function.
	* linux-sparc-low.c (tdesc_sparc64): Declare.
	(sparc_fill_gregset_to_stack, sparc_store_gregset_from_stack):
	Adjust.
	(sparc_arch_setup): New function.
	(sparc_regsets_info, sparc_usrregs_info, regs_info): New globals.
	(the_low_target): Adjust.
	(initialize_low_arch): New function.
	* linux-ppc-low.c (tdesc_powerpc_32l, tdesc_powerpc_altivec32l)
	(tdesc_powerpc_cell32l, tdesc_powerpc_vsx32l)
	(tdesc_powerpc_isa205_32l, tdesc_powerpc_isa205_altivec32l)
	(tdesc_powerpc_isa205_vsx32l, tdesc_powerpc_e500l)
	(tdesc_powerpc_64l, tdesc_powerpc_altivec64l)
	(tdesc_powerpc_cell64l, tdesc_powerpc_vsx64l)
	(tdesc_powerpc_isa205_64l, tdesc_powerpc_isa205_altivec64l)
	(tdesc_powerpc_isa205_vsx64l): Declare.
	(ppc_cannot_store_register, ppc_collect_ptrace_register)
	(ppc_supply_ptrace_register, parse_spufs_run, ppc_get_pc)
	(ppc_set_pc, ppc_get_hwcap): Adjust.
	(ppc_usrregs_info): Forward declare.
	(!__powerpc64__) ppc_regmap_adjusted: New global.
	(ppc_arch_setup): Adjust to the current process'es target
	description.
	(ppc_fill_vsxregset, ppc_store_vsxregset, ppc_fill_vrregset)
	(ppc_store_vrregset, ppc_fill_evrregset, ppc_store_evrregse)
	(ppc_store_evrregset): Adjust.
	(target_regsets): Rename to ...
	(ppc_regsets): ... this, and make static.
	(ppc_usrregs_info, ppc_regsets_info, regs_info): New globals.
	(ppc_regs_info): New function.
	(the_low_target): Adjust.
	(initialize_low_arch): New function.
	* linux-s390-low.c (tdesc_s390_linux32, tdesc_s390_linux32v1)
	(tdesc_s390_linux32v2, tdesc_s390_linux64, tdesc_s390_linux64v1)
	(tdesc_s390_linux64v2, tdesc_s390x_linux64, tdesc_s390x_linux64v1)
	(tdesc_s390x_linux64v2): Declare.
	(s390_collect_ptrace_register, s390_supply_ptrace_register)
	(s390_fill_gregset, s390_store_last_break): Adjust.
	(target_regsets): Rename to ...
	(s390_regsets): ... this, and make static.
	(s390_get_pc, s390_set_pc): Adjust.
	(s390_get_hwcap): New target_desc parameter, and use it.
	[__s390x__] (have_hwcap_s390_high_gprs): New global.
	(s390_arch_setup): Adjust to set the current process'es target
	description.  Don't adjust the regmap.
	(s390_usrregs_info, s390_regsets_info, regs_info): New globals.
	[__s390x__] (s390_usrregs_info_3264, s390_regsets_info_3264)
	(regs_info_3264): New globals.
	(s390_regs_info): New function.
	(the_low_target): Adjust.
	(initialize_low_arch): New function.
	* linux-mips-low.c (tdesc_mips_linux, tdesc_mips_dsp_linux)
	(tdesc_mips64_linux, tdesc_mips64_dsp_linux): Declare.
	[__mips64] (init_registers_mips_linux)
	(init_registers_mips_dsp_linux): Delete defines.
	[__mips64] (tdesc_mips_linux, tdesc_mips_dsp_linux): New defines.
	(have_dsp): New global.
	(mips_read_description): New, based on mips_arch_setup.
	(mips_arch_setup): Reimplement.
	(get_usrregs_info): New function.
	(mips_cannot_fetch_register, mips_cannot_store_register)
	(mips_get_pc, mips_set_pc, mips_fill_gregset, mips_store_gregset)
	(mips_fill_fpregset, mips_store_fpregset): Adjust.
	(target_regsets): Rename to ...
	(mips_regsets): ... this, and make static.
	(mips_regsets_info, mips_dsp_usrregs_info, mips_usrregs_info)
	(dsp_regs_info, regs_info): New globals.
	(mips_regs_info): New function.
	(the_low_target): Adjust.
	(initialize_low_arch): New function.
	* linux-arm-low.c (tdesc_arm, tdesc_arm_with_iwmmxt)
	(tdesc_arm_with_vfpv2, tdesc_arm_with_vfpv3, tdesc_arm_with_neon):
	Declare.
	(arm_fill_vfpregset, arm_store_vfpregset): Adjust.
	(arm_read_description): New, with bits factored from
	arm_arch_setup.
	(arm_arch_setup): Reimplement.
	(target_regsets): Rename to ...
	(arm_regsets): ... this, and make static.
	(arm_regsets_info, arm_usrregs_info, regs_info): New globals.
	(arm_regs_info): New function.
	(the_low_target): Adjust.
	(initialize_low_arch): New function.
	* linux-m68k-low.c (tdesc_m68k): Declare.
	(target_regsets): Rename to ...
	(m68k_regsets): ... this, and make static.
	(m68k_regsets_info, m68k_usrregs_info, regs_info): New globals.
	(m68k_regs_info): New function.
	(m68k_arch_setup): New function.
	(the_low_target): Adjust.
	(initialize_low_arch): New function.
	* linux-sh-low.c (tdesc_sharch): Declare.
	(target_regsets): Rename to ...
	(sh_regsets): ... this, and make static.
	(sh_regsets_info, sh_usrregs_info, regs_info): New globals.
	(sh_regs_info, sh_arch_setup): New functions.
	(the_low_target): Adjust.
	(initialize_low_arch): New function.
	* linux-bfin-low.c (tdesc_bfin): Declare.
	(bfin_arch_setup): New function.
	(bfin_usrregs_info, regs_info): New globals.
	(bfin_regs_info): New function.
	(the_low_target): Adjust.
	(initialize_low_arch): New function.
	* linux-cris-low.c (tdesc_cris): Declare.
	(cris_arch_setup): New function.
	(cris_usrregs_info, regs_info): New globals.
	(cris_regs_info): New function.
	(the_low_target): Adjust.
	(initialize_low_arch): New function.
	* linux-cris-low.c (tdesc_crisv32): Declare.
	(cris_arch_setup): New function.
	(cris_regsets_info, cris_usrregs_info, regs_info): New globals.
	(cris_regs_info): New function.
	(the_low_target): Adjust.
	(initialize_low_arch): New function.
	* linux-m32r-low.c (tdesc_m32r): Declare.
	(m32r_arch_setup): New function.
	(m32r_usrregs_info, regs_info): New globals.
	(m32r_regs_info): Adjust.
	(initialize_low_arch): New function.
	* linux-tic6x-low.c (tdesc_tic6x_c64xp_linux)
	(tdesc_tic6x_c64x_linux, tdesc_tic6x_c62x_linux): Declare.
	(tic6x_usrregs_info): Forward declare.
	(tic6x_read_description): New function, based on ...
	(tic6x_arch_setup): ... this.  Reimplement.
	(target_regsets): Rename to ...
	(tic6x_regsets): ... this, and make static.
	(tic6x_regsets_info, tic6x_usrregs_info, regs_info): New globals.
	(tic6x_regs_info): New function.
	(the_low_target): Adjust.
	(initialize_low_arch): New function.
	* linux-xtensa-low.c (tdesc_xtensa): Declare.
	(xtensa_fill_gregset, xtensa_store_gregset): Adjust.
	(target_regsets): Rename to ...
	(xtensa_regsets): ... this, and make static.
	(xtensa_regsets_info, xtensa_usrregs_info, regs_info): New
	globals.
	(xtensa_arch_setup, xtensa_regs_info): New functions.
	(the_low_target): Adjust.
	(initialize_low_arch): New function.
	* linux-nios2-low.c (tdesc_nios2_linux): Declare.
	(nios2_arch_setup): Set the current process'es tdesc.
	(target_regsets): Rename to ...
	(nios2_regsets): ... this.
	(nios2_regsets_info, nios2_usrregs_info, regs_info): New globals.
	(nios2_regs_info): New function.
	(the_low_target): Adjust.
	(initialize_low_arch): New function.
        * linux-aarch64-low.c (tdesc_aarch64): Declare.
        (aarch64_arch_setup): Set the current process'es tdesc.
        (target_regsets): Rename to ...
        (aarch64_regsets): ... this.
        (aarch64_regsets_info, aarch64_usrregs_info, regs_info): New globals.
        (aarch64_regs_info): New function.
        (the_low_target): Adjust.
        (initialize_low_arch): New function.
	* linux-tile-low.c (tdesc_tilegx, tdesc_tilegx32): Declare
	globals.
	(target_regsets): Rename to ...
	(tile_regsets): ... this.
	(tile_regsets_info, tile_usrregs_info, regs_info): New globals.
	(tile_regs_info): New function.
	(tile_arch_setup): Set the current process'es tdesc.
	(the_low_target): Adjust.
	(initialize_low_arch): New function.
	* spu-low.c (tdesc_spu): Declare.
	(spu_create_inferior, spu_attach): Set the new process'es tdesc.
	* win32-arm-low.c (tdesc_arm): Declare.
	(arm_arch_setup): New function.
	(the_low_target): Install arm_arch_setup instead of
	init_registers_arm.
	* win32-i386-low.c (tdesc_i386, tdesc_amd64): Declare.
	(init_windows_x86): Rename to ...
	(i386_arch_setup): ... this.  Set `win32_tdesc'.
	(the_low_target): Adjust.
	* win32-low.c (win32_tdesc): New global.
	(child_add_thread): Don't create the thread cache here.
	(do_initial_child_stuff): Set the new process'es tdesc.
	* win32-low.h (struct target_desc): Forward declare.
	(win32_tdesc): Declare.
	* lynx-i386-low.c (tdesc_i386): Declare global.
	(lynx_i386_arch_setup): Set `lynx_tdesc'.
	* lynx-low.c (lynx_tdesc): New global.
	(lynx_add_process): Set the new process'es tdesc.
	* lynx-low.h (struct target_desc): Forward declare.
	(lynx_tdesc): Declare global.
	* lynx-ppc-low.c (tdesc_powerpc_32): Declare global.
	(lynx_ppc_arch_setup): Set `lynx_tdesc'.
	* nto-low.c (nto_tdesc): New global.
	(do_attach): Set the new process'es tdesc.
	* nto-low.h (struct target_desc): Forward declare.
	(nto_tdesc): Declare.
	* nto-x86-low.c (tdesc_i386): Declare.
	(nto_x86_arch_setup): Set `nto_tdesc'.

gdb/
2013-06-07  Pedro Alves  <palves@redhat.com>

	* regformats/regdat.sh: Output #include tdesc.h.  Make globals
	static.  Output a global target description pointer.
	(init_registers_${name}): Adjust to initialize a
	target description structure.
2013-06-07 10:46:59 +00:00

1781 lines
38 KiB
C

/* Remote utility routines for the remote server for GDB.
Copyright (C) 1986-2013 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 "server.h"
#include "terminal.h"
#include "target.h"
#include "gdbthread.h"
#include "tdesc.h"
#include <stdio.h>
#include <string.h>
#if HAVE_SYS_IOCTL_H
#include <sys/ioctl.h>
#endif
#if HAVE_SYS_FILE_H
#include <sys/file.h>
#endif
#if HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#if HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#if HAVE_NETDB_H
#include <netdb.h>
#endif
#if HAVE_NETINET_TCP_H
#include <netinet/tcp.h>
#endif
#if HAVE_SYS_IOCTL_H
#include <sys/ioctl.h>
#endif
#if HAVE_SIGNAL_H
#include <signal.h>
#endif
#if HAVE_FCNTL_H
#include <fcntl.h>
#endif
#include <sys/time.h>
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#if HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
#include "gdb_stat.h"
#if HAVE_ERRNO_H
#include <errno.h>
#endif
#if USE_WIN32API
#include <winsock2.h>
#endif
#if __QNX__
#include <sys/iomgr.h>
#endif /* __QNX__ */
#ifndef HAVE_SOCKLEN_T
typedef int socklen_t;
#endif
#ifndef IN_PROCESS_AGENT
#if USE_WIN32API
# define INVALID_DESCRIPTOR INVALID_SOCKET
#else
# define INVALID_DESCRIPTOR -1
#endif
/* Extra value for readchar_callback. */
enum {
/* The callback is currently not scheduled. */
NOT_SCHEDULED = -1
};
/* Status of the readchar callback.
Either NOT_SCHEDULED or the callback id. */
static int readchar_callback = NOT_SCHEDULED;
static int readchar (void);
static void reset_readchar (void);
static void reschedule (void);
/* A cache entry for a successfully looked-up symbol. */
struct sym_cache
{
char *name;
CORE_ADDR addr;
struct sym_cache *next;
};
int remote_debug = 0;
struct ui_file *gdb_stdlog;
static int remote_is_stdio = 0;
static gdb_fildes_t remote_desc = INVALID_DESCRIPTOR;
static gdb_fildes_t listen_desc = INVALID_DESCRIPTOR;
/* FIXME headerize? */
extern int using_threads;
extern int debug_threads;
/* If true, then GDB has requested noack mode. */
int noack_mode = 0;
/* If true, then we tell GDB to use noack mode by default. */
int transport_is_reliable = 0;
#ifdef USE_WIN32API
# define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
# define write(fd, buf, len) send (fd, (char *) buf, len, 0)
#endif
int
gdb_connected (void)
{
return remote_desc != INVALID_DESCRIPTOR;
}
/* Return true if the remote connection is over stdio. */
int
remote_connection_is_stdio (void)
{
return remote_is_stdio;
}
static void
enable_async_notification (int fd)
{
#if defined(F_SETFL) && defined (FASYNC)
int save_fcntl_flags;
save_fcntl_flags = fcntl (fd, F_GETFL, 0);
fcntl (fd, F_SETFL, save_fcntl_flags | FASYNC);
#if defined (F_SETOWN)
fcntl (fd, F_SETOWN, getpid ());
#endif
#endif
}
static int
handle_accept_event (int err, gdb_client_data client_data)
{
struct sockaddr_in sockaddr;
socklen_t tmp;
if (debug_threads)
fprintf (stderr, "handling possible accept event\n");
tmp = sizeof (sockaddr);
remote_desc = accept (listen_desc, (struct sockaddr *) &sockaddr, &tmp);
if (remote_desc == -1)
perror_with_name ("Accept failed");
/* Enable TCP keep alive process. */
tmp = 1;
setsockopt (remote_desc, SOL_SOCKET, SO_KEEPALIVE,
(char *) &tmp, sizeof (tmp));
/* Tell TCP not to delay small packets. This greatly speeds up
interactive response. */
tmp = 1;
setsockopt (remote_desc, IPPROTO_TCP, TCP_NODELAY,
(char *) &tmp, sizeof (tmp));
#ifndef USE_WIN32API
signal (SIGPIPE, SIG_IGN); /* If we don't do this, then gdbserver simply
exits when the remote side dies. */
#endif
if (run_once)
{
#ifndef USE_WIN32API
close (listen_desc); /* No longer need this */
#else
closesocket (listen_desc); /* No longer need this */
#endif
}
/* Even if !RUN_ONCE no longer notice new connections. Still keep the
descriptor open for add_file_handler to wait for a new connection. */
delete_file_handler (listen_desc);
/* Convert IP address to string. */
fprintf (stderr, "Remote debugging from host %s\n",
inet_ntoa (sockaddr.sin_addr));
enable_async_notification (remote_desc);
/* Register the event loop handler. */
add_file_handler (remote_desc, handle_serial_event, NULL);
/* We have a new GDB connection now. If we were disconnected
tracing, there's a window where the target could report a stop
event to the event loop, and since we have a connection now, we'd
try to send vStopped notifications to GDB. But, don't do that
until GDB as selected all-stop/non-stop, and has queried the
threads' status ('?'). */
target_async (0);
return 0;
}
/* Prepare for a later connection to a remote debugger.
NAME is the filename used for communication. */
void
remote_prepare (char *name)
{
char *port_str;
#ifdef USE_WIN32API
static int winsock_initialized;
#endif
int port;
struct sockaddr_in sockaddr;
socklen_t tmp;
char *port_end;
remote_is_stdio = 0;
if (strcmp (name, STDIO_CONNECTION_NAME) == 0)
{
/* We need to record fact that we're using stdio sooner than the
call to remote_open so start_inferior knows the connection is
via stdio. */
remote_is_stdio = 1;
transport_is_reliable = 1;
return;
}
port_str = strchr (name, ':');
if (port_str == NULL)
{
transport_is_reliable = 0;
return;
}
port = strtoul (port_str + 1, &port_end, 10);
if (port_str[1] == '\0' || *port_end != '\0')
fatal ("Bad port argument: %s", name);
#ifdef USE_WIN32API
if (!winsock_initialized)
{
WSADATA wsad;
WSAStartup (MAKEWORD (1, 0), &wsad);
winsock_initialized = 1;
}
#endif
listen_desc = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (listen_desc == -1)
perror_with_name ("Can't open socket");
/* Allow rapid reuse of this port. */
tmp = 1;
setsockopt (listen_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp,
sizeof (tmp));
sockaddr.sin_family = PF_INET;
sockaddr.sin_port = htons (port);
sockaddr.sin_addr.s_addr = INADDR_ANY;
if (bind (listen_desc, (struct sockaddr *) &sockaddr, sizeof (sockaddr))
|| listen (listen_desc, 1))
perror_with_name ("Can't bind address");
transport_is_reliable = 1;
}
/* Open a connection to a remote debugger.
NAME is the filename used for communication. */
void
remote_open (char *name)
{
char *port_str;
port_str = strchr (name, ':');
#ifdef USE_WIN32API
if (port_str == NULL)
error ("Only <host>:<port> is supported on this platform.");
#endif
if (strcmp (name, STDIO_CONNECTION_NAME) == 0)
{
fprintf (stderr, "Remote debugging using stdio\n");
/* Use stdin as the handle of the connection.
We only select on reads, for example. */
remote_desc = fileno (stdin);
enable_async_notification (remote_desc);
/* Register the event loop handler. */
add_file_handler (remote_desc, handle_serial_event, NULL);
}
#ifndef USE_WIN32API
else if (port_str == NULL)
{
struct stat statbuf;
if (stat (name, &statbuf) == 0
&& (S_ISCHR (statbuf.st_mode) || S_ISFIFO (statbuf.st_mode)))
remote_desc = open (name, O_RDWR);
else
{
errno = EINVAL;
remote_desc = -1;
}
if (remote_desc < 0)
perror_with_name ("Could not open remote device");
#ifdef HAVE_TERMIOS
{
struct termios termios;
tcgetattr (remote_desc, &termios);
termios.c_iflag = 0;
termios.c_oflag = 0;
termios.c_lflag = 0;
termios.c_cflag &= ~(CSIZE | PARENB);
termios.c_cflag |= CLOCAL | CS8;
termios.c_cc[VMIN] = 1;
termios.c_cc[VTIME] = 0;
tcsetattr (remote_desc, TCSANOW, &termios);
}
#endif
#ifdef HAVE_TERMIO
{
struct termio termio;
ioctl (remote_desc, TCGETA, &termio);
termio.c_iflag = 0;
termio.c_oflag = 0;
termio.c_lflag = 0;
termio.c_cflag &= ~(CSIZE | PARENB);
termio.c_cflag |= CLOCAL | CS8;
termio.c_cc[VMIN] = 1;
termio.c_cc[VTIME] = 0;
ioctl (remote_desc, TCSETA, &termio);
}
#endif
#ifdef HAVE_SGTTY
{
struct sgttyb sg;
ioctl (remote_desc, TIOCGETP, &sg);
sg.sg_flags = RAW;
ioctl (remote_desc, TIOCSETP, &sg);
}
#endif
fprintf (stderr, "Remote debugging using %s\n", name);
enable_async_notification (remote_desc);
/* Register the event loop handler. */
add_file_handler (remote_desc, handle_serial_event, NULL);
}
#endif /* USE_WIN32API */
else
{
int port;
socklen_t len;
struct sockaddr_in sockaddr;
len = sizeof (sockaddr);
if (getsockname (listen_desc,
(struct sockaddr *) &sockaddr, &len) < 0
|| len < sizeof (sockaddr))
perror_with_name ("Can't determine port");
port = ntohs (sockaddr.sin_port);
fprintf (stderr, "Listening on port %d\n", port);
fflush (stderr);
/* Register the event loop handler. */
add_file_handler (listen_desc, handle_accept_event, NULL);
}
}
void
remote_close (void)
{
delete_file_handler (remote_desc);
#ifdef USE_WIN32API
closesocket (remote_desc);
#else
if (! remote_connection_is_stdio ())
close (remote_desc);
#endif
remote_desc = INVALID_DESCRIPTOR;
reset_readchar ();
}
/* Convert hex digit A to a number. */
static int
fromhex (int a)
{
if (a >= '0' && a <= '9')
return a - '0';
else if (a >= 'a' && a <= 'f')
return a - 'a' + 10;
else
error ("Reply contains invalid hex digit");
return 0;
}
#endif
static const char hexchars[] = "0123456789abcdef";
static int
ishex (int ch, int *val)
{
if ((ch >= 'a') && (ch <= 'f'))
{
*val = ch - 'a' + 10;
return 1;
}
if ((ch >= 'A') && (ch <= 'F'))
{
*val = ch - 'A' + 10;
return 1;
}
if ((ch >= '0') && (ch <= '9'))
{
*val = ch - '0';
return 1;
}
return 0;
}
#ifndef IN_PROCESS_AGENT
int
unhexify (char *bin, const char *hex, int count)
{
int i;
for (i = 0; i < count; i++)
{
if (hex[0] == 0 || hex[1] == 0)
{
/* Hex string is short, or of uneven length.
Return the count that has been converted so far. */
return i;
}
*bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
hex += 2;
}
return i;
}
void
decode_address (CORE_ADDR *addrp, const char *start, int len)
{
CORE_ADDR addr;
char ch;
int i;
addr = 0;
for (i = 0; i < len; i++)
{
ch = start[i];
addr = addr << 4;
addr = addr | (fromhex (ch) & 0x0f);
}
*addrp = addr;
}
const char *
decode_address_to_semicolon (CORE_ADDR *addrp, const char *start)
{
const char *end;
end = start;
while (*end != '\0' && *end != ';')
end++;
decode_address (addrp, start, end - start);
if (*end == ';')
end++;
return end;
}
#endif
/* Convert number NIB to a hex digit. */
static int
tohex (int nib)
{
if (nib < 10)
return '0' + nib;
else
return 'a' + nib - 10;
}
#ifndef IN_PROCESS_AGENT
int
hexify (char *hex, const char *bin, int count)
{
int i;
/* May use a length, or a nul-terminated string as input. */
if (count == 0)
count = strlen (bin);
for (i = 0; i < count; i++)
{
*hex++ = tohex ((*bin >> 4) & 0xf);
*hex++ = tohex (*bin++ & 0xf);
}
*hex = 0;
return i;
}
/* Convert BUFFER, binary data at least LEN bytes long, into escaped
binary data in OUT_BUF. Set *OUT_LEN to the length of the data
encoded in OUT_BUF, and return the number of bytes in OUT_BUF
(which may be more than *OUT_LEN due to escape characters). The
total number of bytes in the output buffer will be at most
OUT_MAXLEN. */
int
remote_escape_output (const gdb_byte *buffer, int len,
gdb_byte *out_buf, int *out_len,
int out_maxlen)
{
int input_index, output_index;
output_index = 0;
for (input_index = 0; input_index < len; input_index++)
{
gdb_byte b = buffer[input_index];
if (b == '$' || b == '#' || b == '}' || b == '*')
{
/* These must be escaped. */
if (output_index + 2 > out_maxlen)
break;
out_buf[output_index++] = '}';
out_buf[output_index++] = b ^ 0x20;
}
else
{
if (output_index + 1 > out_maxlen)
break;
out_buf[output_index++] = b;
}
}
*out_len = input_index;
return output_index;
}
/* Convert BUFFER, escaped data LEN bytes long, into binary data
in OUT_BUF. Return the number of bytes written to OUT_BUF.
Raise an error if the total number of bytes exceeds OUT_MAXLEN.
This function reverses remote_escape_output. It allows more
escaped characters than that function does, in particular because
'*' must be escaped to avoid the run-length encoding processing
in reading packets. */
static int
remote_unescape_input (const gdb_byte *buffer, int len,
gdb_byte *out_buf, int out_maxlen)
{
int input_index, output_index;
int escaped;
output_index = 0;
escaped = 0;
for (input_index = 0; input_index < len; input_index++)
{
gdb_byte b = buffer[input_index];
if (output_index + 1 > out_maxlen)
error ("Received too much data from the target.");
if (escaped)
{
out_buf[output_index++] = b ^ 0x20;
escaped = 0;
}
else if (b == '}')
escaped = 1;
else
out_buf[output_index++] = b;
}
if (escaped)
error ("Unmatched escape character in target response.");
return output_index;
}
/* Look for a sequence of characters which can be run-length encoded.
If there are any, update *CSUM and *P. Otherwise, output the
single character. Return the number of characters consumed. */
static int
try_rle (char *buf, int remaining, unsigned char *csum, char **p)
{
int n;
/* Always output the character. */
*csum += buf[0];
*(*p)++ = buf[0];
/* Don't go past '~'. */
if (remaining > 97)
remaining = 97;
for (n = 1; n < remaining; n++)
if (buf[n] != buf[0])
break;
/* N is the index of the first character not the same as buf[0].
buf[0] is counted twice, so by decrementing N, we get the number
of characters the RLE sequence will replace. */
n--;
if (n < 3)
return 1;
/* Skip the frame characters. The manual says to skip '+' and '-'
also, but there's no reason to. Unfortunately these two unusable
characters double the encoded length of a four byte zero
value. */
while (n + 29 == '$' || n + 29 == '#')
n--;
*csum += '*';
*(*p)++ = '*';
*csum += n + 29;
*(*p)++ = n + 29;
return n + 1;
}
#endif
char *
unpack_varlen_hex (char *buff, /* packet to parse */
ULONGEST *result)
{
int nibble;
ULONGEST retval = 0;
while (ishex (*buff, &nibble))
{
buff++;
retval = retval << 4;
retval |= nibble & 0x0f;
}
*result = retval;
return buff;
}
#ifndef IN_PROCESS_AGENT
/* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
char *
write_ptid (char *buf, ptid_t ptid)
{
int pid, tid;
if (multi_process)
{
pid = ptid_get_pid (ptid);
if (pid < 0)
buf += sprintf (buf, "p-%x.", -pid);
else
buf += sprintf (buf, "p%x.", pid);
}
tid = ptid_get_lwp (ptid);
if (tid < 0)
buf += sprintf (buf, "-%x", -tid);
else
buf += sprintf (buf, "%x", tid);
return buf;
}
ULONGEST
hex_or_minus_one (char *buf, char **obuf)
{
ULONGEST ret;
if (strncmp (buf, "-1", 2) == 0)
{
ret = (ULONGEST) -1;
buf += 2;
}
else
buf = unpack_varlen_hex (buf, &ret);
if (obuf)
*obuf = buf;
return ret;
}
/* Extract a PTID from BUF. If non-null, OBUF is set to the to one
passed the last parsed char. Returns null_ptid on error. */
ptid_t
read_ptid (char *buf, char **obuf)
{
char *p = buf;
char *pp;
ULONGEST pid = 0, tid = 0;
if (*p == 'p')
{
/* Multi-process ptid. */
pp = unpack_varlen_hex (p + 1, &pid);
if (*pp != '.')
error ("invalid remote ptid: %s\n", p);
p = pp + 1;
tid = hex_or_minus_one (p, &pp);
if (obuf)
*obuf = pp;
return ptid_build (pid, tid, 0);
}
/* No multi-process. Just a tid. */
tid = hex_or_minus_one (p, &pp);
/* Since the stub is not sending a process id, then default to
what's in the current inferior. */
pid = ptid_get_pid (current_ptid);
if (obuf)
*obuf = pp;
return ptid_build (pid, tid, 0);
}
/* Write COUNT bytes in BUF to the client.
The result is the number of bytes written or -1 if error.
This may return less than COUNT. */
static int
write_prim (const void *buf, int count)
{
if (remote_connection_is_stdio ())
return write (fileno (stdout), buf, count);
else
return write (remote_desc, buf, count);
}
/* Read COUNT bytes from the client and store in BUF.
The result is the number of bytes read or -1 if error.
This may return less than COUNT. */
static int
read_prim (void *buf, int count)
{
if (remote_connection_is_stdio ())
return read (fileno (stdin), buf, count);
else
return read (remote_desc, buf, count);
}
/* Send a packet to the remote machine, with error checking.
The data of the packet is in BUF, and the length of the
packet is in CNT. Returns >= 0 on success, -1 otherwise. */
static int
putpkt_binary_1 (char *buf, int cnt, int is_notif)
{
int i;
unsigned char csum = 0;
char *buf2;
char *p;
int cc;
buf2 = xmalloc (strlen ("$") + cnt + strlen ("#nn") + 1);
/* Copy the packet into buffer BUF2, encapsulating it
and giving it a checksum. */
p = buf2;
if (is_notif)
*p++ = '%';
else
*p++ = '$';
for (i = 0; i < cnt;)
i += try_rle (buf + i, cnt - i, &csum, &p);
*p++ = '#';
*p++ = tohex ((csum >> 4) & 0xf);
*p++ = tohex (csum & 0xf);
*p = '\0';
/* Send it over and over until we get a positive ack. */
do
{
if (write_prim (buf2, p - buf2) != p - buf2)
{
perror ("putpkt(write)");
free (buf2);
return -1;
}
if (noack_mode || is_notif)
{
/* Don't expect an ack then. */
if (remote_debug)
{
if (is_notif)
fprintf (stderr, "putpkt (\"%s\"); [notif]\n", buf2);
else
fprintf (stderr, "putpkt (\"%s\"); [noack mode]\n", buf2);
fflush (stderr);
}
break;
}
if (remote_debug)
{
fprintf (stderr, "putpkt (\"%s\"); [looking for ack]\n", buf2);
fflush (stderr);
}
cc = readchar ();
if (cc < 0)
{
free (buf2);
return -1;
}
if (remote_debug)
{
fprintf (stderr, "[received '%c' (0x%x)]\n", cc, cc);
fflush (stderr);
}
/* Check for an input interrupt while we're here. */
if (cc == '\003' && current_inferior != NULL)
(*the_target->request_interrupt) ();
}
while (cc != '+');
free (buf2);
return 1; /* Success! */
}
int
putpkt_binary (char *buf, int cnt)
{
return putpkt_binary_1 (buf, cnt, 0);
}
/* Send a packet to the remote machine, with error checking. The data
of the packet is in BUF, and the packet should be a NUL-terminated
string. Returns >= 0 on success, -1 otherwise. */
int
putpkt (char *buf)
{
return putpkt_binary (buf, strlen (buf));
}
int
putpkt_notif (char *buf)
{
return putpkt_binary_1 (buf, strlen (buf), 1);
}
/* Come here when we get an input interrupt from the remote side. This
interrupt should only be active while we are waiting for the child to do
something. Thus this assumes readchar:bufcnt is 0.
About the only thing that should come through is a ^C, which
will cause us to request child interruption. */
static void
input_interrupt (int unused)
{
fd_set readset;
struct timeval immediate = { 0, 0 };
/* Protect against spurious interrupts. This has been observed to
be a problem under NetBSD 1.4 and 1.5. */
FD_ZERO (&readset);
FD_SET (remote_desc, &readset);
if (select (remote_desc + 1, &readset, 0, 0, &immediate) > 0)
{
int cc;
char c = 0;
cc = read_prim (&c, 1);
if (cc != 1 || c != '\003' || current_inferior == NULL)
{
fprintf (stderr, "input_interrupt, count = %d c = %d ('%c')\n",
cc, c, c);
return;
}
(*the_target->request_interrupt) ();
}
}
/* Check if the remote side sent us an interrupt request (^C). */
void
check_remote_input_interrupt_request (void)
{
/* This function may be called before establishing communications,
therefore we need to validate the remote descriptor. */
if (remote_desc == INVALID_DESCRIPTOR)
return;
input_interrupt (0);
}
/* Asynchronous I/O support. SIGIO must be enabled when waiting, in order to
accept Control-C from the client, and must be disabled when talking to
the client. */
static void
unblock_async_io (void)
{
#ifndef USE_WIN32API
sigset_t sigio_set;
sigemptyset (&sigio_set);
sigaddset (&sigio_set, SIGIO);
sigprocmask (SIG_UNBLOCK, &sigio_set, NULL);
#endif
}
#ifdef __QNX__
static void
nto_comctrl (int enable)
{
struct sigevent event;
if (enable)
{
event.sigev_notify = SIGEV_SIGNAL_THREAD;
event.sigev_signo = SIGIO;
event.sigev_code = 0;
event.sigev_value.sival_ptr = NULL;
event.sigev_priority = -1;
ionotify (remote_desc, _NOTIFY_ACTION_POLLARM, _NOTIFY_COND_INPUT,
&event);
}
else
ionotify (remote_desc, _NOTIFY_ACTION_POLL, _NOTIFY_COND_INPUT, NULL);
}
#endif /* __QNX__ */
/* Current state of asynchronous I/O. */
static int async_io_enabled;
/* Enable asynchronous I/O. */
void
enable_async_io (void)
{
if (async_io_enabled)
return;
#ifndef USE_WIN32API
signal (SIGIO, input_interrupt);
#endif
async_io_enabled = 1;
#ifdef __QNX__
nto_comctrl (1);
#endif /* __QNX__ */
}
/* Disable asynchronous I/O. */
void
disable_async_io (void)
{
if (!async_io_enabled)
return;
#ifndef USE_WIN32API
signal (SIGIO, SIG_IGN);
#endif
async_io_enabled = 0;
#ifdef __QNX__
nto_comctrl (0);
#endif /* __QNX__ */
}
void
initialize_async_io (void)
{
/* Make sure that async I/O starts disabled. */
async_io_enabled = 1;
disable_async_io ();
/* Make sure the signal is unblocked. */
unblock_async_io ();
}
/* Internal buffer used by readchar.
These are global to readchar because reschedule_remote needs to be
able to tell whether the buffer is empty. */
static unsigned char readchar_buf[BUFSIZ];
static int readchar_bufcnt = 0;
static unsigned char *readchar_bufp;
/* Returns next char from remote GDB. -1 if error. */
static int
readchar (void)
{
int ch;
if (readchar_bufcnt == 0)
{
readchar_bufcnt = read_prim (readchar_buf, sizeof (readchar_buf));
if (readchar_bufcnt <= 0)
{
if (readchar_bufcnt == 0)
fprintf (stderr, "readchar: Got EOF\n");
else
perror ("readchar");
return -1;
}
readchar_bufp = readchar_buf;
}
readchar_bufcnt--;
ch = *readchar_bufp++;
reschedule ();
return ch;
}
/* Reset the readchar state machine. */
static void
reset_readchar (void)
{
readchar_bufcnt = 0;
if (readchar_callback != NOT_SCHEDULED)
{
delete_callback_event (readchar_callback);
readchar_callback = NOT_SCHEDULED;
}
}
/* Process remaining data in readchar_buf. */
static int
process_remaining (void *context)
{
int res;
/* This is a one-shot event. */
readchar_callback = NOT_SCHEDULED;
if (readchar_bufcnt > 0)
res = handle_serial_event (0, NULL);
else
res = 0;
return res;
}
/* If there is still data in the buffer, queue another event to process it,
we can't sleep in select yet. */
static void
reschedule (void)
{
if (readchar_bufcnt > 0 && readchar_callback == NOT_SCHEDULED)
readchar_callback = append_callback_event (process_remaining, NULL);
}
/* Read a packet from the remote machine, with error checking,
and store it in BUF. Returns length of packet, or negative if error. */
int
getpkt (char *buf)
{
char *bp;
unsigned char csum, c1, c2;
int c;
while (1)
{
csum = 0;
while (1)
{
c = readchar ();
if (c == '$')
break;
if (remote_debug)
{
fprintf (stderr, "[getpkt: discarding char '%c']\n", c);
fflush (stderr);
}
if (c < 0)
return -1;
}
bp = buf;
while (1)
{
c = readchar ();
if (c < 0)
return -1;
if (c == '#')
break;
*bp++ = c;
csum += c;
}
*bp = 0;
c1 = fromhex (readchar ());
c2 = fromhex (readchar ());
if (csum == (c1 << 4) + c2)
break;
if (noack_mode)
{
fprintf (stderr,
"Bad checksum, sentsum=0x%x, csum=0x%x, "
"buf=%s [no-ack-mode, Bad medium?]\n",
(c1 << 4) + c2, csum, buf);
/* Not much we can do, GDB wasn't expecting an ack/nac. */
break;
}
fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
(c1 << 4) + c2, csum, buf);
if (write_prim ("-", 1) != 1)
return -1;
}
if (!noack_mode)
{
if (remote_debug)
{
fprintf (stderr, "getpkt (\"%s\"); [sending ack] \n", buf);
fflush (stderr);
}
if (write_prim ("+", 1) != 1)
return -1;
if (remote_debug)
{
fprintf (stderr, "[sent ack]\n");
fflush (stderr);
}
}
else
{
if (remote_debug)
{
fprintf (stderr, "getpkt (\"%s\"); [no ack sent] \n", buf);
fflush (stderr);
}
}
return bp - buf;
}
void
write_ok (char *buf)
{
buf[0] = 'O';
buf[1] = 'K';
buf[2] = '\0';
}
void
write_enn (char *buf)
{
/* Some day, we should define the meanings of the error codes... */
buf[0] = 'E';
buf[1] = '0';
buf[2] = '1';
buf[3] = '\0';
}
#endif
void
convert_int_to_ascii (const unsigned char *from, char *to, int n)
{
int nib;
int ch;
while (n--)
{
ch = *from++;
nib = ((ch & 0xf0) >> 4) & 0x0f;
*to++ = tohex (nib);
nib = ch & 0x0f;
*to++ = tohex (nib);
}
*to++ = 0;
}
#ifndef IN_PROCESS_AGENT
void
convert_ascii_to_int (const char *from, unsigned char *to, int n)
{
int nib1, nib2;
while (n--)
{
nib1 = fromhex (*from++);
nib2 = fromhex (*from++);
*to++ = (((nib1 & 0x0f) << 4) & 0xf0) | (nib2 & 0x0f);
}
}
static char *
outreg (struct regcache *regcache, int regno, char *buf)
{
if ((regno >> 12) != 0)
*buf++ = tohex ((regno >> 12) & 0xf);
if ((regno >> 8) != 0)
*buf++ = tohex ((regno >> 8) & 0xf);
*buf++ = tohex ((regno >> 4) & 0xf);
*buf++ = tohex (regno & 0xf);
*buf++ = ':';
collect_register_as_string (regcache, regno, buf);
buf += 2 * register_size (regcache->tdesc, regno);
*buf++ = ';';
return buf;
}
void
new_thread_notify (int id)
{
char own_buf[256];
/* The `n' response is not yet part of the remote protocol. Do nothing. */
if (1)
return;
if (server_waiting == 0)
return;
sprintf (own_buf, "n%x", id);
disable_async_io ();
putpkt (own_buf);
enable_async_io ();
}
void
dead_thread_notify (int id)
{
char own_buf[256];
/* The `x' response is not yet part of the remote protocol. Do nothing. */
if (1)
return;
sprintf (own_buf, "x%x", id);
disable_async_io ();
putpkt (own_buf);
enable_async_io ();
}
void
prepare_resume_reply (char *buf, ptid_t ptid,
struct target_waitstatus *status)
{
if (debug_threads)
fprintf (stderr, "Writing resume reply for %s:%d\n",
target_pid_to_str (ptid), status->kind);
switch (status->kind)
{
case TARGET_WAITKIND_STOPPED:
{
struct thread_info *saved_inferior;
const char **regp;
struct regcache *regcache;
sprintf (buf, "T%02x", status->value.sig);
buf += strlen (buf);
saved_inferior = current_inferior;
current_inferior = find_thread_ptid (ptid);
regp = current_target_desc ()->expedite_regs;
regcache = get_thread_regcache (current_inferior, 1);
if (the_target->stopped_by_watchpoint != NULL
&& (*the_target->stopped_by_watchpoint) ())
{
CORE_ADDR addr;
int i;
strncpy (buf, "watch:", 6);
buf += 6;
addr = (*the_target->stopped_data_address) ();
/* Convert each byte of the address into two hexadecimal
chars. Note that we take sizeof (void *) instead of
sizeof (addr); this is to avoid sending a 64-bit
address to a 32-bit GDB. */
for (i = sizeof (void *) * 2; i > 0; i--)
*buf++ = tohex ((addr >> (i - 1) * 4) & 0xf);
*buf++ = ';';
}
while (*regp)
{
buf = outreg (regcache, find_regno (regcache->tdesc, *regp), buf);
regp ++;
}
*buf = '\0';
/* Formerly, if the debugger had not used any thread features
we would not burden it with a thread status response. This
was for the benefit of GDB 4.13 and older. However, in
recent GDB versions the check (``if (cont_thread != 0)'')
does not have the desired effect because of sillyness in
the way that the remote protocol handles specifying a
thread. Since thread support relies on qSymbol support
anyway, assume GDB can handle threads. */
if (using_threads && !disable_packet_Tthread)
{
/* This if (1) ought to be unnecessary. But remote_wait
in GDB will claim this event belongs to inferior_ptid
if we do not specify a thread, and there's no way for
gdbserver to know what inferior_ptid is. */
if (1 || !ptid_equal (general_thread, ptid))
{
int core = -1;
/* In non-stop, don't change the general thread behind
GDB's back. */
if (!non_stop)
general_thread = ptid;
sprintf (buf, "thread:");
buf += strlen (buf);
buf = write_ptid (buf, ptid);
strcat (buf, ";");
buf += strlen (buf);
core = target_core_of_thread (ptid);
if (core != -1)
{
sprintf (buf, "core:");
buf += strlen (buf);
sprintf (buf, "%x", core);
strcat (buf, ";");
buf += strlen (buf);
}
}
}
if (dlls_changed)
{
strcpy (buf, "library:;");
buf += strlen (buf);
dlls_changed = 0;
}
current_inferior = saved_inferior;
}
break;
case TARGET_WAITKIND_EXITED:
if (multi_process)
sprintf (buf, "W%x;process:%x",
status->value.integer, ptid_get_pid (ptid));
else
sprintf (buf, "W%02x", status->value.integer);
break;
case TARGET_WAITKIND_SIGNALLED:
if (multi_process)
sprintf (buf, "X%x;process:%x",
status->value.sig, ptid_get_pid (ptid));
else
sprintf (buf, "X%02x", status->value.sig);
break;
default:
error ("unhandled waitkind");
break;
}
}
void
decode_m_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr)
{
int i = 0, j = 0;
char ch;
*mem_addr_ptr = *len_ptr = 0;
while ((ch = from[i++]) != ',')
{
*mem_addr_ptr = *mem_addr_ptr << 4;
*mem_addr_ptr |= fromhex (ch) & 0x0f;
}
for (j = 0; j < 4; j++)
{
if ((ch = from[i++]) == 0)
break;
*len_ptr = *len_ptr << 4;
*len_ptr |= fromhex (ch) & 0x0f;
}
}
void
decode_M_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr,
unsigned char **to_p)
{
int i = 0;
char ch;
*mem_addr_ptr = *len_ptr = 0;
while ((ch = from[i++]) != ',')
{
*mem_addr_ptr = *mem_addr_ptr << 4;
*mem_addr_ptr |= fromhex (ch) & 0x0f;
}
while ((ch = from[i++]) != ':')
{
*len_ptr = *len_ptr << 4;
*len_ptr |= fromhex (ch) & 0x0f;
}
if (*to_p == NULL)
*to_p = xmalloc (*len_ptr);
convert_ascii_to_int (&from[i++], *to_p, *len_ptr);
}
int
decode_X_packet (char *from, int packet_len, CORE_ADDR *mem_addr_ptr,
unsigned int *len_ptr, unsigned char **to_p)
{
int i = 0;
char ch;
*mem_addr_ptr = *len_ptr = 0;
while ((ch = from[i++]) != ',')
{
*mem_addr_ptr = *mem_addr_ptr << 4;
*mem_addr_ptr |= fromhex (ch) & 0x0f;
}
while ((ch = from[i++]) != ':')
{
*len_ptr = *len_ptr << 4;
*len_ptr |= fromhex (ch) & 0x0f;
}
if (*to_p == NULL)
*to_p = xmalloc (*len_ptr);
if (remote_unescape_input ((const gdb_byte *) &from[i], packet_len - i,
*to_p, *len_ptr) != *len_ptr)
return -1;
return 0;
}
/* Decode a qXfer write request. */
int
decode_xfer_write (char *buf, int packet_len, CORE_ADDR *offset,
unsigned int *len, unsigned char *data)
{
char ch;
char *b = buf;
/* Extract the offset. */
*offset = 0;
while ((ch = *buf++) != ':')
{
*offset = *offset << 4;
*offset |= fromhex (ch) & 0x0f;
}
/* Get encoded data. */
packet_len -= buf - b;
*len = remote_unescape_input ((const gdb_byte *) buf, packet_len,
data, packet_len);
return 0;
}
/* Decode the parameters of a qSearch:memory packet. */
int
decode_search_memory_packet (const char *buf, int packet_len,
CORE_ADDR *start_addrp,
CORE_ADDR *search_space_lenp,
gdb_byte *pattern, unsigned int *pattern_lenp)
{
const char *p = buf;
p = decode_address_to_semicolon (start_addrp, p);
p = decode_address_to_semicolon (search_space_lenp, p);
packet_len -= p - buf;
*pattern_lenp = remote_unescape_input ((const gdb_byte *) p, packet_len,
pattern, packet_len);
return 0;
}
static void
free_sym_cache (struct sym_cache *sym)
{
if (sym != NULL)
{
free (sym->name);
free (sym);
}
}
void
clear_symbol_cache (struct sym_cache **symcache_p)
{
struct sym_cache *sym, *next;
/* Check the cache first. */
for (sym = *symcache_p; sym; sym = next)
{
next = sym->next;
free_sym_cache (sym);
}
*symcache_p = NULL;
}
/* Get the address of NAME, and return it in ADDRP if found. if
MAY_ASK_GDB is false, assume symbol cache misses are failures.
Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
int
look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb)
{
char own_buf[266], *p, *q;
int len;
struct sym_cache *sym;
struct process_info *proc;
proc = current_process ();
/* Check the cache first. */
for (sym = proc->symbol_cache; sym; sym = sym->next)
if (strcmp (name, sym->name) == 0)
{
*addrp = sym->addr;
return 1;
}
/* It might not be an appropriate time to look up a symbol,
e.g. while we're trying to fetch registers. */
if (!may_ask_gdb)
return 0;
/* Send the request. */
strcpy (own_buf, "qSymbol:");
hexify (own_buf + strlen ("qSymbol:"), name, strlen (name));
if (putpkt (own_buf) < 0)
return -1;
/* FIXME: Eventually add buffer overflow checking (to getpkt?) */
len = getpkt (own_buf);
if (len < 0)
return -1;
/* We ought to handle pretty much any packet at this point while we
wait for the qSymbol "response". That requires re-entering the
main loop. For now, this is an adequate approximation; allow
GDB to read from memory while it figures out the address of the
symbol. */
while (own_buf[0] == 'm')
{
CORE_ADDR mem_addr;
unsigned char *mem_buf;
unsigned int mem_len;
decode_m_packet (&own_buf[1], &mem_addr, &mem_len);
mem_buf = xmalloc (mem_len);
if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0)
convert_int_to_ascii (mem_buf, own_buf, mem_len);
else
write_enn (own_buf);
free (mem_buf);
if (putpkt (own_buf) < 0)
return -1;
len = getpkt (own_buf);
if (len < 0)
return -1;
}
if (strncmp (own_buf, "qSymbol:", strlen ("qSymbol:")) != 0)
{
warning ("Malformed response to qSymbol, ignoring: %s\n", own_buf);
return -1;
}
p = own_buf + strlen ("qSymbol:");
q = p;
while (*q && *q != ':')
q++;
/* Make sure we found a value for the symbol. */
if (p == q || *q == '\0')
return 0;
decode_address (addrp, p, q - p);
/* Save the symbol in our cache. */
sym = xmalloc (sizeof (*sym));
sym->name = xstrdup (name);
sym->addr = *addrp;
sym->next = proc->symbol_cache;
proc->symbol_cache = sym;
return 1;
}
/* Relocate an instruction to execute at a different address. OLDLOC
is the address in the inferior memory where the instruction to
relocate is currently at. On input, TO points to the destination
where we want the instruction to be copied (and possibly adjusted)
to. On output, it points to one past the end of the resulting
instruction(s). The effect of executing the instruction at TO
shall be the same as if executing it at OLDLOC. For example, call
instructions that implicitly push the return address on the stack
should be adjusted to return to the instruction after OLDLOC;
relative branches, and other PC-relative instructions need the
offset adjusted; etc. Returns 0 on success, -1 on failure. */
int
relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc)
{
char own_buf[266];
int len;
ULONGEST written = 0;
/* Send the request. */
strcpy (own_buf, "qRelocInsn:");
sprintf (own_buf, "qRelocInsn:%s;%s", paddress (oldloc),
paddress (*to));
if (putpkt (own_buf) < 0)
return -1;
/* FIXME: Eventually add buffer overflow checking (to getpkt?) */
len = getpkt (own_buf);
if (len < 0)
return -1;
/* We ought to handle pretty much any packet at this point while we
wait for the qRelocInsn "response". That requires re-entering
the main loop. For now, this is an adequate approximation; allow
GDB to access memory. */
while (own_buf[0] == 'm' || own_buf[0] == 'M' || own_buf[0] == 'X')
{
CORE_ADDR mem_addr;
unsigned char *mem_buf = NULL;
unsigned int mem_len;
if (own_buf[0] == 'm')
{
decode_m_packet (&own_buf[1], &mem_addr, &mem_len);
mem_buf = xmalloc (mem_len);
if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0)
convert_int_to_ascii (mem_buf, own_buf, mem_len);
else
write_enn (own_buf);
}
else if (own_buf[0] == 'X')
{
if (decode_X_packet (&own_buf[1], len - 1, &mem_addr,
&mem_len, &mem_buf) < 0
|| write_inferior_memory (mem_addr, mem_buf, mem_len) != 0)
write_enn (own_buf);
else
write_ok (own_buf);
}
else
{
decode_M_packet (&own_buf[1], &mem_addr, &mem_len, &mem_buf);
if (write_inferior_memory (mem_addr, mem_buf, mem_len) == 0)
write_ok (own_buf);
else
write_enn (own_buf);
}
free (mem_buf);
if (putpkt (own_buf) < 0)
return -1;
len = getpkt (own_buf);
if (len < 0)
return -1;
}
if (own_buf[0] == 'E')
{
warning ("An error occurred while relocating an instruction: %s\n",
own_buf);
return -1;
}
if (strncmp (own_buf, "qRelocInsn:", strlen ("qRelocInsn:")) != 0)
{
warning ("Malformed response to qRelocInsn, ignoring: %s\n",
own_buf);
return -1;
}
unpack_varlen_hex (own_buf + strlen ("qRelocInsn:"), &written);
*to += written;
return 0;
}
void
monitor_output (const char *msg)
{
char *buf = xmalloc (strlen (msg) * 2 + 2);
buf[0] = 'O';
hexify (buf + 1, msg, 0);
putpkt (buf);
free (buf);
}
#endif