1 /* Copyright (C) 2020 Free Software Foundation, Inc.
3 This file is part of GDB.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "netbsd-low.h"
21 #include "nat/netbsd-nat.h"
23 #include <sys/param.h>
24 #include <sys/types.h>
26 #include <sys/ptrace.h>
27 #include <sys/sysctl.h>
35 #include <type_traits>
37 #include "gdbsupport/eintr.h"
38 #include "gdbsupport/gdb_wait.h"
39 #include "gdbsupport/filestuff.h"
40 #include "gdbsupport/common-inferior.h"
41 #include "nat/fork-inferior.h"
44 int using_threads
= 1;
46 const struct target_desc
*netbsd_tdesc
;
48 /* Call add_process with the given parameters, and initialize
49 the process' private data. */
52 netbsd_add_process (int pid
, int attached
)
54 struct process_info
*proc
= add_process (pid
, attached
);
55 proc
->tdesc
= netbsd_tdesc
;
59 /* Callback used by fork_inferior to start tracing the inferior. */
64 /* Switch child to its own process group so that signals won't
65 directly affect GDBserver. */
66 if (setpgid (0, 0) < 0)
67 trace_start_error_with_name (("setpgid"));
69 if (ptrace (PT_TRACE_ME
, 0, nullptr, 0) < 0)
70 trace_start_error_with_name (("ptrace"));
72 /* If GDBserver is connected to gdb via stdio, redirect the inferior's
73 stdout to stderr so that inferior i/o doesn't corrupt the connection.
74 Also, redirect stdin to /dev/null. */
75 if (remote_connection_is_stdio ())
78 trace_start_error_with_name (("close"));
79 if (open ("/dev/null", O_RDONLY
) < 0)
80 trace_start_error_with_name (("open"));
82 trace_start_error_with_name (("dup2"));
83 if (write (2, "stdin/stdout redirected\n",
84 sizeof ("stdin/stdout redirected\n") - 1) < 0)
91 /* Implement the create_inferior method of the target_ops vector. */
94 netbsd_process_target::create_inferior (const char *program
,
95 const std::vector
<char *> &program_args
)
97 std::string str_program_args
= construct_inferior_arguments (program_args
);
99 pid_t pid
= fork_inferior (program
, str_program_args
.c_str (),
100 get_environ ()->envp (), netbsd_ptrace_fun
,
101 nullptr, nullptr, nullptr, nullptr);
103 netbsd_add_process (pid
, 0);
105 post_fork_inferior (pid
, program
);
110 /* Implement the post_create_inferior target_ops method. */
113 netbsd_process_target::post_create_inferior ()
115 pid_t pid
= current_process ()->pid
;
116 netbsd_nat::enable_proc_events (pid
);
121 /* Implement the attach target_ops method. */
124 netbsd_process_target::attach (unsigned long pid
)
130 /* Returns true if GDB is interested in any child syscalls. */
133 gdb_catching_syscalls_p (pid_t pid
)
135 struct process_info
*proc
= find_process_pid (pid
);
136 return !proc
->syscalls_to_catch
.empty ();
139 /* Implement the resume target_ops method. */
142 netbsd_process_target::resume (struct thread_resume
*resume_info
, size_t n
)
144 ptid_t resume_ptid
= resume_info
[0].thread
;
145 const int signal
= resume_info
[0].sig
;
146 const bool step
= resume_info
[0].kind
== resume_step
;
148 if (resume_ptid
== minus_one_ptid
)
149 resume_ptid
= ptid_of (current_thread
);
151 const pid_t pid
= resume_ptid
.pid ();
152 const lwpid_t lwp
= resume_ptid
.lwp ();
153 regcache_invalidate_pid (pid
);
160 if (ptid
.lwp () == lwp
|| n
!= 1)
162 if (ptrace (PT_SETSTEP
, pid
, NULL
, ptid
.lwp ()) == -1)
163 perror_with_name (("ptrace"));
164 if (ptrace (PT_RESUME
, pid
, NULL
, ptid
.lwp ()) == -1)
165 perror_with_name (("ptrace"));
169 if (ptrace (PT_CLEARSTEP
, pid
, NULL
, ptid
.lwp ()) == -1)
170 perror_with_name (("ptrace"));
171 if (ptrace (PT_SUSPEND
, pid
, NULL
, ptid
.lwp ()) == -1)
172 perror_with_name (("ptrace"));
177 if (ptrace (PT_CLEARSTEP
, pid
, NULL
, ptid
.lwp ()) == -1)
178 perror_with_name (("ptrace"));
179 if (ptrace (PT_RESUME
, pid
, NULL
, ptid
.lwp ()) == -1)
180 perror_with_name (("ptrace"));
184 netbsd_nat::for_each_thread (pid
, fn
);
186 int request
= gdb_catching_syscalls_p (pid
) ? PT_CONTINUE
: PT_SYSCALL
;
189 ptrace (request
, pid
, (void *)1, signal
);
191 perror_with_name (("ptrace"));
194 /* Returns true if GDB is interested in the reported SYSNO syscall. */
197 netbsd_catch_this_syscall (int sysno
)
199 struct process_info
*proc
= current_process ();
201 if (proc
->syscalls_to_catch
.empty ())
204 if (proc
->syscalls_to_catch
[0] == ANY_SYSCALL
)
207 for (int iter
: proc
->syscalls_to_catch
)
214 /* Helper function for child_wait and the derivatives of child_wait.
215 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
216 translation of that in OURSTATUS. */
219 netbsd_store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
221 if (WIFEXITED (hoststatus
))
223 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
224 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
226 else if (!WIFSTOPPED (hoststatus
))
228 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
229 ourstatus
->value
.sig
= gdb_signal_from_host (WTERMSIG (hoststatus
));
233 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
234 ourstatus
->value
.sig
= gdb_signal_from_host (WSTOPSIG (hoststatus
));
238 /* Implement a safe wrapper around waitpid(). */
241 netbsd_waitpid (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
242 target_wait_flags target_options
)
245 int options
= (target_options
& TARGET_WNOHANG
) ? WNOHANG
: 0;
248 = gdb::handle_eintr
<int> (-1, ::waitpid
, ptid
.pid (), &status
, options
);
251 perror_with_name (_("Child process unexpectedly missing"));
253 netbsd_store_waitstatus (ourstatus
, status
);
258 /* Implement the wait target_ops method.
260 Wait for the child specified by PTID to do something. Return the
261 process ID of the child, or MINUS_ONE_PTID in case of error; store
262 the status in *OURSTATUS. */
265 netbsd_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
266 target_wait_flags target_options
)
268 pid_t pid
= netbsd_waitpid (ptid
, ourstatus
, target_options
);
269 ptid_t wptid
= ptid_t (pid
);
273 gdb_assert (target_options
& TARGET_WNOHANG
);
274 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
278 gdb_assert (pid
!= -1);
280 /* If the child stopped, keep investigating its status. */
281 if (ourstatus
->kind
!= TARGET_WAITKIND_STOPPED
)
284 /* Extract the event and thread that received a signal. */
285 ptrace_siginfo_t psi
;
286 if (ptrace (PT_GET_SIGINFO
, pid
, &psi
, sizeof (psi
)) == -1)
287 perror_with_name (("ptrace"));
289 /* Pick child's siginfo_t. */
290 siginfo_t
*si
= &psi
.psi_siginfo
;
292 lwpid_t lwp
= psi
.psi_lwpid
;
294 int signo
= si
->si_signo
;
295 const int code
= si
->si_code
;
297 /* Construct PTID with a specified thread that received the event.
298 If a signal was targeted to the whole process, lwp is 0. */
299 wptid
= ptid_t (pid
, lwp
, 0);
301 /* Bail out on non-debugger oriented signals. */
302 if (signo
!= SIGTRAP
)
305 /* Stop examining non-debugger oriented SIGTRAP codes. */
306 if (code
<= SI_USER
|| code
== SI_NOINFO
)
309 /* Process state for threading events. */
310 ptrace_state_t pst
= {};
311 if (code
== TRAP_LWP
)
312 if (ptrace (PT_GET_PROCESS_STATE
, pid
, &pst
, sizeof (pst
)) == -1)
313 perror_with_name (("ptrace"));
315 if (code
== TRAP_LWP
&& pst
.pe_report_event
== PTRACE_LWP_EXIT
)
317 /* If GDB attaches to a multi-threaded process, exiting
318 threads might be skipped during post_attach that
319 have not yet reported their PTRACE_LWP_EXIT event.
320 Ignore exited events for an unknown LWP. */
321 thread_info
*thr
= find_thread_ptid (wptid
);
323 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
326 ourstatus
->kind
= TARGET_WAITKIND_THREAD_EXITED
;
327 /* NetBSD does not store an LWP exit status. */
328 ourstatus
->value
.integer
= 0;
335 if (find_thread_ptid (ptid_t (pid
)))
336 current_thread
= find_thread_ptid (wptid
);
338 if (code
== TRAP_LWP
&& pst
.pe_report_event
== PTRACE_LWP_CREATE
)
340 /* If GDB attaches to a multi-threaded process, newborn
341 threads might be added by nbsd_add_threads that have
342 not yet reported their PTRACE_LWP_CREATE event. Ignore
343 born events for an already-known LWP. */
344 if (find_thread_ptid (wptid
))
345 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
348 add_thread (wptid
, NULL
);
349 ourstatus
->kind
= TARGET_WAITKIND_THREAD_CREATED
;
354 if (code
== TRAP_EXEC
)
356 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
357 ourstatus
->value
.execd_pathname
358 = xstrdup (netbsd_nat::pid_to_exec_file (pid
));
362 if (code
== TRAP_TRACE
)
365 if (code
== TRAP_SCE
|| code
== TRAP_SCX
)
367 int sysnum
= si
->si_sysnum
;
369 if (!netbsd_catch_this_syscall(sysnum
))
371 /* If the core isn't interested in this event, ignore it. */
372 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
377 = ((code
== TRAP_SCE
) ? TARGET_WAITKIND_SYSCALL_ENTRY
:
378 TARGET_WAITKIND_SYSCALL_RETURN
);
379 ourstatus
->value
.syscall_number
= sysnum
;
383 if (code
== TRAP_BRKPT
)
385 #ifdef PTRACE_BREAKPOINT_ADJ
388 ptrace (PT_GETREGS
, pid
, &r
, psi
.psi_lwpid
);
389 pc
= PTRACE_REG_PC (&r
);
390 PTRACE_REG_SET_PC (&r
, pc
- PTRACE_BREAKPOINT_ADJ
);
391 ptrace (PT_SETREGS
, pid
, &r
, psi
.psi_lwpid
);
396 /* Unclassified SIGTRAP event. */
397 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
401 /* Implement the wait target_ops method. */
404 netbsd_process_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
405 target_wait_flags target_options
)
409 ptid_t wptid
= netbsd_wait (ptid
, ourstatus
, target_options
);
411 /* Register thread in the gdbcore if a thread was not reported earlier.
412 This is required after ::create_inferior, when the gdbcore does not
413 know about the first internal thread.
414 This may also happen on attach, when an event is registered on a thread
415 that was not fully initialized during the attach stage. */
416 if (wptid
.lwp () != 0 && !find_thread_ptid (wptid
)
417 && ourstatus
->kind
!= TARGET_WAITKIND_THREAD_EXITED
)
418 add_thread (wptid
, nullptr);
420 switch (ourstatus
->kind
)
422 case TARGET_WAITKIND_EXITED
:
423 case TARGET_WAITKIND_STOPPED
:
424 case TARGET_WAITKIND_SIGNALLED
:
425 case TARGET_WAITKIND_FORKED
:
426 case TARGET_WAITKIND_VFORKED
:
427 case TARGET_WAITKIND_EXECD
:
428 case TARGET_WAITKIND_VFORK_DONE
:
429 case TARGET_WAITKIND_SYSCALL_ENTRY
:
430 case TARGET_WAITKIND_SYSCALL_RETURN
:
431 /* Pass the result to the generic code. */
433 case TARGET_WAITKIND_THREAD_CREATED
:
434 case TARGET_WAITKIND_THREAD_EXITED
:
435 /* The core needlessly stops on these events. */
437 case TARGET_WAITKIND_SPURIOUS
:
438 /* Spurious events are unhandled by the gdbserver core. */
439 if (ptrace (PT_CONTINUE
, current_process ()->pid
, (void *) 1, 0)
441 perror_with_name (("ptrace"));
444 error (("Unknown stopped status"));
449 /* Implement the kill target_ops method. */
452 netbsd_process_target::kill (process_info
*process
)
454 pid_t pid
= process
->pid
;
455 if (ptrace (PT_KILL
, pid
, nullptr, 0) == -1)
459 if (gdb::handle_eintr
<int> (-1, ::waitpid
, pid
, &status
, 0) == -1)
465 /* Implement the detach target_ops method. */
468 netbsd_process_target::detach (process_info
*process
)
470 pid_t pid
= process
->pid
;
472 ptrace (PT_DETACH
, pid
, (void *) 1, 0);
477 /* Implement the mourn target_ops method. */
480 netbsd_process_target::mourn (struct process_info
*proc
)
482 for_each_thread (proc
->pid
, remove_thread
);
484 remove_process (proc
);
487 /* Implement the join target_ops method. */
490 netbsd_process_target::join (int pid
)
492 /* The PT_DETACH is sufficient to detach from the process.
493 So no need to do anything extra. */
496 /* Implement the thread_alive target_ops method. */
499 netbsd_process_target::thread_alive (ptid_t ptid
)
501 return netbsd_nat::thread_alive (ptid
);
504 /* Implement the fetch_registers target_ops method. */
507 netbsd_process_target::fetch_registers (struct regcache
*regcache
, int regno
)
509 const netbsd_regset_info
*regset
= get_regs_info ();
510 ptid_t inferior_ptid
= ptid_of (current_thread
);
512 while (regset
->size
>= 0)
514 std::vector
<char> buf
;
515 buf
.resize (regset
->size
);
516 int res
= ptrace (regset
->get_request
, inferior_ptid
.pid (), buf
.data (),
517 inferior_ptid
.lwp ());
519 perror_with_name (("ptrace"));
520 regset
->store_function (regcache
, buf
.data ());
525 /* Implement the store_registers target_ops method. */
528 netbsd_process_target::store_registers (struct regcache
*regcache
, int regno
)
530 const netbsd_regset_info
*regset
= get_regs_info ();
531 ptid_t inferior_ptid
= ptid_of (current_thread
);
533 while (regset
->size
>= 0)
535 std::vector
<char> buf
;
536 buf
.resize (regset
->size
);
537 int res
= ptrace (regset
->get_request
, inferior_ptid
.pid (), buf
.data (),
538 inferior_ptid
.lwp ());
540 perror_with_name (("ptrace"));
542 /* Then overlay our cached registers on that. */
543 regset
->fill_function (regcache
, buf
.data ());
544 /* Only now do we write the register set. */
545 res
= ptrace (regset
->set_request
, inferior_ptid
.pid (), buf
. data (),
546 inferior_ptid
.lwp ());
548 perror_with_name (("ptrace"));
553 /* Implement the read_memory target_ops method. */
556 netbsd_process_target::read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
,
559 struct ptrace_io_desc io
;
560 io
.piod_op
= PIOD_READ_D
;
563 pid_t pid
= current_process ()->pid
;
569 /* Zero length write always succeeds. */
574 io
.piod_offs
= (void *)(memaddr
+ bytes_read
);
575 io
.piod_addr
= myaddr
+ bytes_read
;
577 int rv
= ptrace (PT_IO
, pid
, &io
, 0);
580 if (io
.piod_len
== 0)
583 bytes_read
+= io
.piod_len
;
584 io
.piod_len
= size
- bytes_read
;
586 while (bytes_read
< size
);
591 /* Implement the write_memory target_ops method. */
594 netbsd_process_target::write_memory (CORE_ADDR memaddr
,
595 const unsigned char *myaddr
, int size
)
597 struct ptrace_io_desc io
;
598 io
.piod_op
= PIOD_WRITE_D
;
601 pid_t pid
= current_process ()->pid
;
603 int bytes_written
= 0;
607 /* Zero length write always succeeds. */
613 io
.piod_addr
= (void *)(myaddr
+ bytes_written
);
614 io
.piod_offs
= (void *)(memaddr
+ bytes_written
);
616 int rv
= ptrace (PT_IO
, pid
, &io
, 0);
619 if (io
.piod_len
== 0)
622 bytes_written
+= io
.piod_len
;
623 io
.piod_len
= size
- bytes_written
;
625 while (bytes_written
< size
);
630 /* Implement the request_interrupt target_ops method. */
633 netbsd_process_target::request_interrupt ()
635 ptid_t inferior_ptid
= ptid_of (get_first_thread ());
637 ::kill (inferior_ptid
.pid(), SIGINT
);
640 /* Read the AUX Vector for the specified PID, wrapping the ptrace(2) call
641 with the PIOD_READ_AUXV operation and using the PT_IO standard input
642 and output arguments. */
645 netbsd_read_auxv(pid_t pid
, void *offs
, void *addr
, size_t len
)
647 struct ptrace_io_desc pio
;
649 pio
.piod_op
= PIOD_READ_AUXV
;
650 pio
.piod_offs
= offs
;
651 pio
.piod_addr
= addr
;
654 if (ptrace (PT_IO
, pid
, &pio
, 0) == -1)
655 perror_with_name (("ptrace"));
660 /* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
661 to debugger memory starting at MYADDR. */
664 netbsd_process_target::read_auxv (CORE_ADDR offset
,
665 unsigned char *myaddr
, unsigned int len
)
667 pid_t pid
= pid_of (current_thread
);
669 return netbsd_read_auxv (pid
, (void *) (intptr_t) offset
, myaddr
, len
);
673 netbsd_process_target::supports_z_point_type (char z_type
)
680 case Z_PACKET_WRITE_WP
:
681 case Z_PACKET_READ_WP
:
682 case Z_PACKET_ACCESS_WP
:
684 return false; /* Not supported. */
688 /* Insert {break/watch}point at address ADDR. SIZE is not used. */
691 netbsd_process_target::insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
692 int size
, struct raw_breakpoint
*bp
)
696 case raw_bkpt_type_sw
:
697 return insert_memory_breakpoint (bp
);
698 case raw_bkpt_type_hw
:
699 case raw_bkpt_type_write_wp
:
700 case raw_bkpt_type_read_wp
:
701 case raw_bkpt_type_access_wp
:
703 return 1; /* Not supported. */
707 /* Remove {break/watch}point at address ADDR. SIZE is not used. */
710 netbsd_process_target::remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
711 int size
, struct raw_breakpoint
*bp
)
715 case raw_bkpt_type_sw
:
716 return remove_memory_breakpoint (bp
);
717 case raw_bkpt_type_hw
:
718 case raw_bkpt_type_write_wp
:
719 case raw_bkpt_type_read_wp
:
720 case raw_bkpt_type_access_wp
:
722 return 1; /* Not supported. */
726 /* Implement the stopped_by_sw_breakpoint target_ops method. */
729 netbsd_process_target::stopped_by_sw_breakpoint ()
731 ptrace_siginfo_t psi
;
732 pid_t pid
= current_process ()->pid
;
734 if (ptrace (PT_GET_SIGINFO
, pid
, &psi
, sizeof (psi
)) == -1)
735 perror_with_name (("ptrace"));
737 return psi
.psi_siginfo
.si_signo
== SIGTRAP
&&
738 psi
.psi_siginfo
.si_code
== TRAP_BRKPT
;
741 /* Implement the supports_stopped_by_sw_breakpoint target_ops method. */
744 netbsd_process_target::supports_stopped_by_sw_breakpoint ()
749 /* Implement the supports_qxfer_siginfo target_ops method. */
752 netbsd_process_target::supports_qxfer_siginfo ()
757 /* Implement the qxfer_siginfo target_ops method. */
760 netbsd_process_target::qxfer_siginfo (const char *annex
, unsigned char *readbuf
,
761 unsigned const char *writebuf
,
762 CORE_ADDR offset
, int len
)
764 if (current_thread
== nullptr)
767 pid_t pid
= current_process ()->pid
;
769 return netbsd_nat::qxfer_siginfo(pid
, annex
, readbuf
, writebuf
, offset
, len
);
772 /* Implement the supports_non_stop target_ops method. */
775 netbsd_process_target::supports_non_stop ()
780 /* Implement the supports_multi_process target_ops method. */
783 netbsd_process_target::supports_multi_process ()
788 /* Check if fork events are supported. */
791 netbsd_process_target::supports_fork_events ()
796 /* Check if vfork events are supported. */
799 netbsd_process_target::supports_vfork_events ()
804 /* Check if exec events are supported. */
807 netbsd_process_target::supports_exec_events ()
812 /* Implement the supports_disable_randomization target_ops method. */
815 netbsd_process_target::supports_disable_randomization ()
820 /* Extract &phdr and num_phdr in the inferior. Return 0 on success. */
822 template <typename T
>
823 int get_phdr_phnum_from_proc_auxv (const pid_t pid
,
824 CORE_ADDR
*phdr_memaddr
, int *num_phdr
)
826 typedef typename
std::conditional
<sizeof(T
) == sizeof(int64_t),
827 Aux64Info
, Aux32Info
>::type auxv_type
;
828 const size_t auxv_size
= sizeof (auxv_type
);
829 const size_t auxv_buf_size
= 128 * sizeof (auxv_type
);
831 std::vector
<char> auxv_buf
;
832 auxv_buf
.resize (auxv_buf_size
);
834 netbsd_read_auxv (pid
, nullptr, auxv_buf
.data (), auxv_buf_size
);
839 for (char *buf
= auxv_buf
.data ();
840 buf
< (auxv_buf
.data () + auxv_buf_size
);
843 auxv_type
*const aux
= (auxv_type
*) buf
;
848 *phdr_memaddr
= aux
->a_v
;
851 *num_phdr
= aux
->a_v
;
855 if (*phdr_memaddr
!= 0 && *num_phdr
!= 0)
859 if (*phdr_memaddr
== 0 || *num_phdr
== 0)
861 warning ("Unexpected missing AT_PHDR and/or AT_PHNUM: "
862 "phdr_memaddr = %s, phdr_num = %d",
863 core_addr_to_string (*phdr_memaddr
), *num_phdr
);
870 /* Return &_DYNAMIC (via PT_DYNAMIC) in the inferior, or 0 if not present. */
872 template <typename T
>
874 get_dynamic (netbsd_process_target
*target
, const pid_t pid
)
876 typedef typename
std::conditional
<sizeof(T
) == sizeof(int64_t),
877 Elf64_Phdr
, Elf32_Phdr
>::type phdr_type
;
878 const int phdr_size
= sizeof (phdr_type
);
880 CORE_ADDR phdr_memaddr
;
882 if (get_phdr_phnum_from_proc_auxv
<T
> (pid
, &phdr_memaddr
, &num_phdr
))
885 std::vector
<unsigned char> phdr_buf
;
886 phdr_buf
.resize (num_phdr
* phdr_size
);
888 if (target
->read_memory (phdr_memaddr
, phdr_buf
.data (), phdr_buf
.size ()))
891 /* Compute relocation: it is expected to be 0 for "regular" executables,
892 non-zero for PIE ones. */
893 CORE_ADDR relocation
= -1;
894 for (int i
= 0; relocation
== -1 && i
< num_phdr
; i
++)
896 phdr_type
*const p
= (phdr_type
*) (phdr_buf
.data() + i
* phdr_size
);
898 if (p
->p_type
== PT_PHDR
)
899 relocation
= phdr_memaddr
- p
->p_vaddr
;
902 if (relocation
== -1)
904 /* PT_PHDR is optional, but necessary for PIE in general. Fortunately
905 any real world executables, including PIE executables, have always
906 PT_PHDR present. PT_PHDR is not present in some shared libraries or
907 in fpc (Free Pascal 2.4) binaries but neither of those have a need for
908 or present DT_DEBUG anyway (fpc binaries are statically linked).
910 Therefore if there exists DT_DEBUG there is always also PT_PHDR.
912 GDB could find RELOCATION also from AT_ENTRY - e_entry. */
917 for (int i
= 0; i
< num_phdr
; i
++)
919 phdr_type
*const p
= (phdr_type
*) (phdr_buf
.data () + i
* phdr_size
);
921 if (p
->p_type
== PT_DYNAMIC
)
922 return p
->p_vaddr
+ relocation
;
928 /* Return &_r_debug in the inferior, or -1 if not present. Return value
929 can be 0 if the inferior does not yet have the library list initialized.
930 We look for DT_MIPS_RLD_MAP first. MIPS executables use this instead of
931 DT_DEBUG, although they sometimes contain an unused DT_DEBUG entry too. */
933 template <typename T
>
935 get_r_debug (netbsd_process_target
*target
, const int pid
)
937 typedef typename
std::conditional
<sizeof(T
) == sizeof(int64_t),
938 Elf64_Dyn
, Elf32_Dyn
>::type dyn_type
;
939 const int dyn_size
= sizeof (dyn_type
);
940 unsigned char buf
[sizeof (dyn_type
)]; /* The larger of the two. */
943 CORE_ADDR dynamic_memaddr
= get_dynamic
<T
> (target
, pid
);
944 if (dynamic_memaddr
== 0)
947 while (target
->read_memory (dynamic_memaddr
, buf
, dyn_size
) == 0)
949 dyn_type
*const dyn
= (dyn_type
*) buf
;
950 #if defined DT_MIPS_RLD_MAP
954 unsigned char buf
[sizeof (T
)];
958 if (dyn
->d_tag
== DT_MIPS_RLD_MAP
)
960 if (read_memory (dyn
->d_un
.d_val
,
961 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
966 #endif /* DT_MIPS_RLD_MAP */
968 if (dyn
->d_tag
== DT_DEBUG
&& map
== -1)
969 map
= dyn
->d_un
.d_val
;
971 if (dyn
->d_tag
== DT_NULL
)
974 dynamic_memaddr
+= dyn_size
;
980 /* Read one pointer from MEMADDR in the inferior. */
983 read_one_ptr (netbsd_process_target
*target
, CORE_ADDR memaddr
, CORE_ADDR
*ptr
,
986 /* Go through a union so this works on either big or little endian
987 hosts, when the inferior's pointer size is smaller than the size
988 of CORE_ADDR. It is assumed the inferior's endianness is the
989 same of the superior's. */
998 int ret
= target
->read_memory (memaddr
, &addr
.uc
, ptr_size
);
1001 if (ptr_size
== sizeof (CORE_ADDR
))
1002 *ptr
= addr
.core_addr
;
1003 else if (ptr_size
== sizeof (unsigned int))
1006 gdb_assert_not_reached ("unhandled pointer size");
1011 /* Construct qXfer:libraries-svr4:read reply. */
1013 template <typename T
>
1015 netbsd_qxfer_libraries_svr4 (netbsd_process_target
*target
,
1016 const pid_t pid
, const char *annex
,
1017 unsigned char *readbuf
,
1018 unsigned const char *writebuf
,
1019 CORE_ADDR offset
, int len
)
1021 struct link_map_offsets
1023 /* Offset and size of r_debug.r_version. */
1024 int r_version_offset
;
1026 /* Offset and size of r_debug.r_map. */
1029 /* Offset to l_addr field in struct link_map. */
1032 /* Offset to l_name field in struct link_map. */
1035 /* Offset to l_ld field in struct link_map. */
1038 /* Offset to l_next field in struct link_map. */
1041 /* Offset to l_prev field in struct link_map. */
1045 static const struct link_map_offsets lmo_32bit_offsets
=
1047 0, /* r_version offset. */
1048 4, /* r_debug.r_map offset. */
1049 0, /* l_addr offset in link_map. */
1050 4, /* l_name offset in link_map. */
1051 8, /* l_ld offset in link_map. */
1052 12, /* l_next offset in link_map. */
1053 16 /* l_prev offset in link_map. */
1056 static const struct link_map_offsets lmo_64bit_offsets
=
1058 0, /* r_version offset. */
1059 8, /* r_debug.r_map offset. */
1060 0, /* l_addr offset in link_map. */
1061 8, /* l_name offset in link_map. */
1062 16, /* l_ld offset in link_map. */
1063 24, /* l_next offset in link_map. */
1064 32 /* l_prev offset in link_map. */
1067 CORE_ADDR lm_addr
= 0, lm_prev
= 0;
1068 CORE_ADDR l_name
, l_addr
, l_ld
, l_next
, l_prev
;
1069 int header_done
= 0;
1071 const struct link_map_offsets
*lmo
1072 = ((sizeof (T
) == sizeof (int64_t))
1073 ? &lmo_64bit_offsets
: &lmo_32bit_offsets
);
1074 int ptr_size
= sizeof (T
);
1076 while (annex
[0] != '\0')
1078 const char *sep
= strchr (annex
, '=');
1082 int name_len
= sep
- annex
;
1084 if (name_len
== 5 && startswith (annex
, "start"))
1086 else if (name_len
== 4 && startswith (annex
, "prev"))
1090 annex
= strchr (sep
, ';');
1091 if (annex
== nullptr)
1097 annex
= decode_address_to_semicolon (addrp
, sep
+ 1);
1102 CORE_ADDR r_debug
= get_r_debug
<T
> (target
, pid
);
1104 /* We failed to find DT_DEBUG. Such situation will not change
1105 for this inferior - do not retry it. Report it to GDB as
1106 E01, see for the reasons at the GDB solib-svr4.c side. */
1107 if (r_debug
== (CORE_ADDR
) -1)
1112 CORE_ADDR map_offset
= r_debug
+ lmo
->r_map_offset
;
1113 if (read_one_ptr (target
, map_offset
, &lm_addr
, ptr_size
) != 0)
1114 warning ("unable to read r_map from %s",
1115 core_addr_to_string (map_offset
));
1119 std::string document
= "<library-list-svr4 version=\"1.0\"";
1122 && read_one_ptr (target
, lm_addr
+ lmo
->l_name_offset
,
1123 &l_name
, ptr_size
) == 0
1124 && read_one_ptr (target
, lm_addr
+ lmo
->l_addr_offset
,
1125 &l_addr
, ptr_size
) == 0
1126 && read_one_ptr (target
, lm_addr
+ lmo
->l_ld_offset
,
1127 &l_ld
, ptr_size
) == 0
1128 && read_one_ptr (target
, lm_addr
+ lmo
->l_prev_offset
,
1129 &l_prev
, ptr_size
) == 0
1130 && read_one_ptr (target
, lm_addr
+ lmo
->l_next_offset
,
1131 &l_next
, ptr_size
) == 0)
1133 if (lm_prev
!= l_prev
)
1135 warning ("Corrupted shared library list: 0x%lx != 0x%lx",
1136 (long) lm_prev
, (long) l_prev
);
1140 /* Ignore the first entry even if it has valid name as the first entry
1141 corresponds to the main executable. The first entry should not be
1142 skipped if the dynamic loader was loaded late by a static executable
1143 (see solib-svr4.c parameter ignore_first). But in such case the main
1144 executable does not have PT_DYNAMIC present and this function already
1145 exited above due to failed get_r_debug. */
1147 string_appendf (document
, " main-lm=\"0x%lx\"",
1148 (unsigned long) lm_addr
);
1151 unsigned char libname
[PATH_MAX
];
1153 /* Not checking for error because reading may stop before
1154 we've got PATH_MAX worth of characters. */
1156 target
->read_memory (l_name
, libname
, sizeof (libname
) - 1);
1157 libname
[sizeof (libname
) - 1] = '\0';
1158 if (libname
[0] != '\0')
1162 /* Terminate `<library-list-svr4'. */
1167 string_appendf (document
, "<library name=\"");
1168 xml_escape_text_append (&document
, (char *) libname
);
1169 string_appendf (document
, "\" lm=\"0x%lx\" "
1170 "l_addr=\"0x%lx\" l_ld=\"0x%lx\"/>",
1171 (unsigned long) lm_addr
, (unsigned long) l_addr
,
1172 (unsigned long) l_ld
);
1182 /* Empty list; terminate `<library-list-svr4'. */
1186 document
+= "</library-list-svr4>";
1188 int document_len
= document
.length ();
1189 if (offset
< document_len
)
1190 document_len
-= offset
;
1193 if (len
> document_len
)
1196 memcpy (readbuf
, document
.data () + offset
, len
);
1201 /* Return true if FILE is a 64-bit ELF file,
1202 false if the file is not a 64-bit ELF file,
1203 and error if the file is not accessible or doesn't exist. */
1206 elf_64_file_p (const char *file
)
1208 int fd
= gdb::handle_eintr
<int> (-1, ::open
, file
, O_RDONLY
);
1210 perror_with_name (("open"));
1213 ssize_t ret
= gdb::handle_eintr
<ssize_t
> (-1, ::read
, fd
, &header
, sizeof (header
));
1215 perror_with_name (("read"));
1216 gdb::handle_eintr
<int> (-1, ::close
, fd
);
1217 if (ret
!= sizeof (header
))
1218 error ("Cannot read ELF file header: %s", file
);
1220 if (header
.e_ident
[EI_MAG0
] != ELFMAG0
1221 || header
.e_ident
[EI_MAG1
] != ELFMAG1
1222 || header
.e_ident
[EI_MAG2
] != ELFMAG2
1223 || header
.e_ident
[EI_MAG3
] != ELFMAG3
)
1224 error ("Unrecognized ELF file header: %s", file
);
1226 return header
.e_ident
[EI_CLASS
] == ELFCLASS64
;
1229 /* Construct qXfer:libraries-svr4:read reply. */
1232 netbsd_process_target::qxfer_libraries_svr4 (const char *annex
,
1233 unsigned char *readbuf
,
1234 unsigned const char *writebuf
,
1235 CORE_ADDR offset
, int len
)
1237 if (writebuf
!= nullptr)
1239 if (readbuf
== nullptr)
1242 struct process_info
*proc
= current_process ();
1243 pid_t pid
= proc
->pid
;
1244 bool is_elf64
= elf_64_file_p (netbsd_nat::pid_to_exec_file (pid
));
1247 return netbsd_qxfer_libraries_svr4
<int64_t> (this, pid
, annex
, readbuf
,
1248 writebuf
, offset
, len
);
1250 return netbsd_qxfer_libraries_svr4
<int32_t> (this, pid
, annex
, readbuf
,
1251 writebuf
, offset
, len
);
1254 /* Implement the supports_qxfer_libraries_svr4 target_ops method. */
1257 netbsd_process_target::supports_qxfer_libraries_svr4 ()
1262 /* Return the name of a file that can be opened to get the symbols for
1263 the child process identified by PID. */
1266 netbsd_process_target::pid_to_exec_file (pid_t pid
)
1268 return const_cast<char *> (netbsd_nat::pid_to_exec_file (pid
));
1271 /* Implementation of the target_ops method "supports_pid_to_exec_file". */
1274 netbsd_process_target::supports_pid_to_exec_file ()
1279 /* Implementation of the target_ops method "supports_hardware_single_step". */
1281 netbsd_process_target::supports_hardware_single_step ()
1286 /* Implementation of the target_ops method "sw_breakpoint_from_kind". */
1289 netbsd_process_target::sw_breakpoint_from_kind (int kind
, int *size
)
1291 static gdb_byte brkpt
[PTRACE_BREAKPOINT_SIZE
] = {*PTRACE_BREAKPOINT
};
1293 *size
= PTRACE_BREAKPOINT_SIZE
;
1298 /* Implement the thread_name target_ops method. */
1301 netbsd_process_target::thread_name (ptid_t ptid
)
1303 return netbsd_nat::thread_name (ptid
);
1306 /* Implement the supports_catch_syscall target_ops method. */
1309 netbsd_process_target::supports_catch_syscall ()
1314 /* Implement the supports_read_auxv target_ops method. */
1317 netbsd_process_target::supports_read_auxv ()
1325 set_target_ops (the_netbsd_target
);