1 /* Copyright (C) 2009-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/>. */
23 #include <sys/ptrace.h>
24 #include <sys/piddef.h> /* Provides PIDGET, TIDGET, BUILDPID, etc. */
26 #include <sys/ioctl.h>
27 #include <sys/types.h>
28 #include "gdbsupport/gdb_wait.h"
30 #include "gdbsupport/filestuff.h"
31 #include "gdbsupport/common-inferior.h"
32 #include "nat/fork-inferior.h"
34 int using_threads
= 1;
36 const struct target_desc
*lynx_tdesc
;
38 /* Per-process private data. */
40 struct process_info_private
42 /* The PTID obtained from the last wait performed on this process.
43 Initialized to null_ptid until the first wait is performed. */
44 ptid_t last_wait_event_ptid
;
47 /* Print a debug trace on standard output if debug_threads is set. */
50 lynx_debug (char *string
, ...)
57 va_start (args
, string
);
58 fprintf (stderr
, "DEBUG(lynx): ");
59 vfprintf (stderr
, string
, args
);
60 fprintf (stderr
, "\n");
64 /* Build a ptid_t given a PID and a LynxOS TID. */
67 lynx_ptid_t (int pid
, long tid
)
69 /* brobecker/2010-06-21: It looks like the LWP field in ptids
70 should be distinct for each thread (see write_ptid where it
71 writes the thread ID from the LWP). So instead of storing
72 the LynxOS tid in the tid field of the ptid, we store it in
74 return ptid_t (pid
, tid
, 0);
77 /* Return the process ID of the given PTID.
79 This function has little reason to exist, it's just a wrapper around
80 ptid_get_pid. But since we have a getter function for the lynxos
81 ptid, it feels cleaner to have a getter for the pid as well. */
84 lynx_ptid_get_pid (ptid_t ptid
)
89 /* Return the LynxOS tid of the given PTID. */
92 lynx_ptid_get_tid (ptid_t ptid
)
94 /* See lynx_ptid_t: The LynxOS tid is stored inside the lwp field
99 /* For a given PTID, return the associated PID as known by the LynxOS
103 lynx_ptrace_pid_from_ptid (ptid_t ptid
)
105 return BUILDPID (lynx_ptid_get_pid (ptid
), lynx_ptid_get_tid (ptid
));
108 /* Return a string image of the ptrace REQUEST number. */
111 ptrace_request_to_str (int request
)
113 #define CASE(X) case X: return #X
116 CASE(PTRACE_TRACEME
);
117 CASE(PTRACE_PEEKTEXT
);
118 CASE(PTRACE_PEEKDATA
);
119 CASE(PTRACE_PEEKUSER
);
120 CASE(PTRACE_POKETEXT
);
121 CASE(PTRACE_POKEDATA
);
122 CASE(PTRACE_POKEUSER
);
125 CASE(PTRACE_SINGLESTEP
);
128 CASE(PTRACE_GETREGS
);
129 CASE(PTRACE_SETREGS
);
130 CASE(PTRACE_GETFPREGS
);
131 CASE(PTRACE_SETFPREGS
);
132 CASE(PTRACE_READDATA
);
133 CASE(PTRACE_WRITEDATA
);
134 CASE(PTRACE_READTEXT
);
135 CASE(PTRACE_WRITETEXT
);
136 CASE(PTRACE_GETFPAREGS
);
137 CASE(PTRACE_SETFPAREGS
);
138 CASE(PTRACE_GETWINDOW
);
139 CASE(PTRACE_SETWINDOW
);
140 CASE(PTRACE_SYSCALL
);
141 CASE(PTRACE_DUMPCORE
);
142 CASE(PTRACE_SETWRBKPT
);
143 CASE(PTRACE_SETACBKPT
);
144 CASE(PTRACE_CLRBKPT
);
145 CASE(PTRACE_GET_UCODE
);
164 #ifdef PTRACE_PEEKUSP
165 CASE(PTRACE_PEEKUSP
);
167 #ifdef PTRACE_POKEUSP
168 CASE(PTRACE_POKEUSP
);
170 CASE(PTRACE_PEEKTHREAD
);
171 CASE(PTRACE_THREADUSER
);
173 CASE(PTRACE_FPWRITE
);
175 CASE(PTRACE_CONT_ONE
);
176 CASE(PTRACE_KILL_ONE
);
177 CASE(PTRACE_SINGLESTEP_ONE
);
178 CASE(PTRACE_GETLOADINFO
);
179 CASE(PTRACE_GETTRACESIG
);
180 #ifdef PTRACE_GETTHREADLIST
181 CASE(PTRACE_GETTHREADLIST
);
186 return "<unknown-request>";
189 /* A wrapper around ptrace that allows us to print debug traces of
190 ptrace calls if debug traces are activated. */
193 lynx_ptrace (int request
, ptid_t ptid
, int addr
, int data
, int addr2
)
196 const int pid
= lynx_ptrace_pid_from_ptid (ptid
);
200 fprintf (stderr
, "PTRACE (%s, pid=%d(pid=%d, tid=%d), addr=0x%x, "
201 "data=0x%x, addr2=0x%x)",
202 ptrace_request_to_str (request
), pid
, PIDGET (pid
), TIDGET (pid
),
204 result
= ptrace (request
, pid
, addr
, data
, addr2
);
207 fprintf (stderr
, " -> %d (=0x%x)\n", result
, result
);
213 /* Call add_process with the given parameters, and initializes
214 the process' private data. */
216 static struct process_info
*
217 lynx_add_process (int pid
, int attached
)
219 struct process_info
*proc
;
221 proc
= add_process (pid
, attached
);
222 proc
->tdesc
= lynx_tdesc
;
223 proc
->priv
= XCNEW (struct process_info_private
);
224 proc
->priv
->last_wait_event_ptid
= null_ptid
;
229 /* Callback used by fork_inferior to start tracing the inferior. */
236 /* Switch child to its own process group so that signals won't
237 directly affect GDBserver. */
240 trace_start_error_with_name ("pgrp");
241 if (setpgid (0, pgrp
) < 0)
242 trace_start_error_with_name ("setpgid");
243 if (ioctl (0, TIOCSPGRP
, &pgrp
) < 0)
244 trace_start_error_with_name ("ioctl");
245 if (lynx_ptrace (PTRACE_TRACEME
, null_ptid
, 0, 0, 0) < 0)
246 trace_start_error_with_name ("lynx_ptrace");
249 /* Implement the create_inferior method of the target_ops vector. */
252 lynx_process_target::create_inferior (const char *program
,
253 const std::vector
<char *> &program_args
)
256 std::string str_program_args
= stringify_argv (program_args
);
258 lynx_debug ("create_inferior ()");
260 pid
= fork_inferior (program
,
261 str_program_args
.c_str (),
262 get_environ ()->envp (), lynx_ptrace_fun
,
263 NULL
, NULL
, NULL
, NULL
);
265 post_fork_inferior (pid
, program
);
267 lynx_add_process (pid
, 0);
268 /* Do not add the process thread just yet, as we do not know its tid.
269 We will add it later, during the wait for the STOP event corresponding
270 to the lynx_ptrace (PTRACE_TRACEME) call above. */
274 /* Assuming we've just attached to a running inferior whose pid is PID,
275 add all threads running in that process. */
278 lynx_add_threads_after_attach (int pid
)
280 /* Ugh! There appears to be no way to get the list of threads
281 in the program we just attached to. So get the list by calling
282 the "ps" command. This is only needed now, as we will then
283 keep the thread list up to date thanks to thread creation and
284 exit notifications. */
287 int thread_pid
, thread_tid
;
289 f
= popen ("ps atx", "r");
291 perror_with_name ("Cannot get thread list");
293 while (fgets (buf
, sizeof (buf
), f
) != NULL
)
294 if ((sscanf (buf
, "%d %d", &thread_pid
, &thread_tid
) == 2
295 && thread_pid
== pid
))
297 ptid_t thread_ptid
= lynx_ptid_t (pid
, thread_tid
);
299 if (!find_thread_ptid (thread_ptid
))
301 lynx_debug ("New thread: (pid = %d, tid = %d)",
303 add_thread (thread_ptid
, NULL
);
310 /* Implement the attach target_ops method. */
313 lynx_process_target::attach (unsigned long pid
)
315 ptid_t ptid
= lynx_ptid_t (pid
, 0);
317 if (lynx_ptrace (PTRACE_ATTACH
, ptid
, 0, 0, 0) != 0)
318 error ("Cannot attach to process %lu: %s (%d)\n", pid
,
319 safe_strerror (errno
), errno
);
321 lynx_add_process (pid
, 1);
322 lynx_add_threads_after_attach (pid
);
327 /* Implement the resume target_ops method. */
330 lynx_process_target::resume (thread_resume
*resume_info
, size_t n
)
332 ptid_t ptid
= resume_info
[0].thread
;
334 = (resume_info
[0].kind
== resume_step
335 ? (n
== 1 ? PTRACE_SINGLESTEP_ONE
: PTRACE_SINGLESTEP
)
337 const int signal
= resume_info
[0].sig
;
339 /* If given a minus_one_ptid, then try using the current_process'
340 private->last_wait_event_ptid. On most LynxOS versions,
341 using any of the process' thread works well enough, but
342 LynxOS 178 is a little more sensitive, and triggers some
343 unexpected signals (Eg SIG61) when we resume the inferior
344 using a different thread. */
345 if (ptid
== minus_one_ptid
)
346 ptid
= current_process()->priv
->last_wait_event_ptid
;
348 /* The ptid might still be minus_one_ptid; this can happen between
349 the moment we create the inferior or attach to a process, and
350 the moment we resume its execution for the first time. It is
351 fine to use the current_thread's ptid in those cases. */
352 if (ptid
== minus_one_ptid
)
353 ptid
= ptid_of (current_thread
);
355 regcache_invalidate_pid (ptid
.pid ());
358 lynx_ptrace (request
, ptid
, 1, signal
, 0);
360 perror_with_name ("ptrace");
363 /* Resume the execution of the given PTID. */
366 lynx_continue (ptid_t ptid
)
368 struct thread_resume resume_info
;
370 resume_info
.thread
= ptid
;
371 resume_info
.kind
= resume_continue
;
374 lynx_resume (&resume_info
, 1);
377 /* A wrapper around waitpid that handles the various idiosyncrasies
378 of LynxOS' waitpid. */
381 lynx_waitpid (int pid
, int *stat_loc
)
387 ret
= waitpid (pid
, stat_loc
, WNOHANG
);
390 /* An ECHILD error is not indicative of a real problem.
391 It happens for instance while waiting for the inferior
392 to stop after attaching to it. */
394 perror_with_name ("waitpid (WNOHANG)");
398 /* No event with WNOHANG. See if there is one with WUNTRACED. */
399 ret
= waitpid (pid
, stat_loc
, WNOHANG
| WUNTRACED
);
402 /* An ECHILD error is not indicative of a real problem.
403 It happens for instance while waiting for the inferior
404 to stop after attaching to it. */
406 perror_with_name ("waitpid (WNOHANG|WUNTRACED)");
415 /* Implement the wait target_ops method. */
418 lynx_wait_1 (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
425 if (ptid
== minus_one_ptid
)
426 pid
= lynx_ptid_get_pid (ptid_of (current_thread
));
428 pid
= BUILDPID (lynx_ptid_get_pid (ptid
), lynx_ptid_get_tid (ptid
));
432 ret
= lynx_waitpid (pid
, &wstat
);
433 new_ptid
= lynx_ptid_t (ret
, ((union wait
*) &wstat
)->w_tid
);
434 find_process_pid (ret
)->priv
->last_wait_event_ptid
= new_ptid
;
436 /* If this is a new thread, then add it now. The reason why we do
437 this here instead of when handling new-thread events is because
438 we need to add the thread associated to the "main" thread - even
439 for non-threaded applications where the new-thread events are not
441 if (!find_thread_ptid (new_ptid
))
443 lynx_debug ("New thread: (pid = %d, tid = %d)",
444 lynx_ptid_get_pid (new_ptid
), lynx_ptid_get_tid (new_ptid
));
445 add_thread (new_ptid
, NULL
);
448 if (WIFSTOPPED (wstat
))
450 status
->kind
= TARGET_WAITKIND_STOPPED
;
451 status
->value
.integer
= gdb_signal_from_host (WSTOPSIG (wstat
));
452 lynx_debug ("process stopped with signal: %d",
453 status
->value
.integer
);
455 else if (WIFEXITED (wstat
))
457 status
->kind
= TARGET_WAITKIND_EXITED
;
458 status
->value
.integer
= WEXITSTATUS (wstat
);
459 lynx_debug ("process exited with code: %d", status
->value
.integer
);
461 else if (WIFSIGNALED (wstat
))
463 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
464 status
->value
.integer
= gdb_signal_from_host (WTERMSIG (wstat
));
465 lynx_debug ("process terminated with code: %d",
466 status
->value
.integer
);
470 /* Not sure what happened if we get here, or whether we can
471 in fact get here. But if we do, handle the event the best
473 status
->kind
= TARGET_WAITKIND_STOPPED
;
474 status
->value
.integer
= gdb_signal_from_host (0);
475 lynx_debug ("unknown event ????");
478 /* SIGTRAP events are generated for situations other than single-step/
479 breakpoint events (Eg. new-thread events). Handle those other types
480 of events, and resume the execution if necessary. */
481 if (status
->kind
== TARGET_WAITKIND_STOPPED
482 && status
->value
.integer
== GDB_SIGNAL_TRAP
)
484 const int realsig
= lynx_ptrace (PTRACE_GETTRACESIG
, new_ptid
, 0, 0, 0);
486 lynx_debug ("(realsig = %d)", realsig
);
490 /* We just added the new thread above. No need to do anything
491 further. Just resume the execution again. */
492 lynx_continue (new_ptid
);
496 remove_thread (find_thread_ptid (new_ptid
));
497 lynx_continue (new_ptid
);
505 /* A wrapper around lynx_wait_1 that also prints debug traces when
506 such debug traces have been activated. */
509 lynx_process_target::wait (ptid_t ptid
, target_waitstatus
*status
,
514 lynx_debug ("wait (pid = %d, tid = %ld)",
515 lynx_ptid_get_pid (ptid
), lynx_ptid_get_tid (ptid
));
516 new_ptid
= lynx_wait_1 (ptid
, status
, options
);
517 lynx_debug (" -> (pid=%d, tid=%ld, status->kind = %d)",
518 lynx_ptid_get_pid (new_ptid
), lynx_ptid_get_tid (new_ptid
),
523 /* Implement the kill target_ops method. */
526 lynx_process_target::kill (process_info
*process
)
528 ptid_t ptid
= lynx_ptid_t (process
->pid
, 0);
529 struct target_waitstatus status
;
531 lynx_ptrace (PTRACE_KILL
, ptid
, 0, 0, 0);
532 lynx_wait (ptid
, &status
, 0);
537 /* Implement the detach target_ops method. */
540 lynx_process_target::detach (process_info
*process
)
542 ptid_t ptid
= lynx_ptid_t (process
->pid
, 0);
544 lynx_ptrace (PTRACE_DETACH
, ptid
, 0, 0, 0);
549 /* Implement the mourn target_ops method. */
552 lynx_process_target::mourn (struct process_info
*proc
)
554 for_each_thread (proc
->pid
, remove_thread
);
556 /* Free our private data. */
560 remove_process (proc
);
563 /* Implement the join target_ops method. */
566 lynx_process_target::join (int pid
)
568 /* The PTRACE_DETACH is sufficient to detach from the process.
569 So no need to do anything extra. */
572 /* Implement the thread_alive target_ops method. */
575 lynx_process_target::thread_alive (ptid_t ptid
)
577 /* The list of threads is updated at the end of each wait, so it
578 should be up to date. No need to re-fetch it. */
579 return (find_thread_ptid (ptid
) != NULL
);
582 /* Implement the fetch_registers target_ops method. */
585 lynx_process_target::fetch_registers (regcache
*regcache
, int regno
)
587 struct lynx_regset_info
*regset
= lynx_target_regsets
;
588 ptid_t inferior_ptid
= ptid_of (current_thread
);
590 lynx_debug ("fetch_registers (regno = %d)", regno
);
592 while (regset
->size
>= 0)
597 buf
= xmalloc (regset
->size
);
598 res
= lynx_ptrace (regset
->get_request
, inferior_ptid
, (int) buf
, 0, 0);
601 regset
->store_function (regcache
, buf
);
607 /* Implement the store_registers target_ops method. */
610 lynx_process_target::store_registers (regcache
*regcache
, int regno
)
612 struct lynx_regset_info
*regset
= lynx_target_regsets
;
613 ptid_t inferior_ptid
= ptid_of (current_thread
);
615 lynx_debug ("store_registers (regno = %d)", regno
);
617 while (regset
->size
>= 0)
622 buf
= xmalloc (regset
->size
);
623 res
= lynx_ptrace (regset
->get_request
, inferior_ptid
, (int) buf
, 0, 0);
626 /* Then overlay our cached registers on that. */
627 regset
->fill_function (regcache
, buf
);
628 /* Only now do we write the register set. */
629 res
= lynx_ptrace (regset
->set_request
, inferior_ptid
, (int) buf
,
639 /* Implement the read_memory target_ops method. */
642 lynx_process_target::read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
,
645 /* On LynxOS, memory reads needs to be performed in chunks the size
646 of int types, and they should also be aligned accordingly. */
648 const int xfer_size
= sizeof (buf
);
649 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) xfer_size
;
650 ptid_t inferior_ptid
= ptid_of (current_thread
);
652 while (addr
< memaddr
+ len
)
659 skip
= memaddr
- addr
;
660 if (addr
+ xfer_size
> memaddr
+ len
)
661 truncate
= addr
+ xfer_size
- memaddr
- len
;
662 buf
= lynx_ptrace (PTRACE_PEEKTEXT
, inferior_ptid
, addr
, 0, 0);
665 memcpy (myaddr
+ (addr
- memaddr
) + skip
, (gdb_byte
*) &buf
+ skip
,
666 xfer_size
- skip
- truncate
);
673 /* Implement the write_memory target_ops method. */
676 lynx_process_target::write_memory (CORE_ADDR memaddr
,
677 const unsigned char *myaddr
, int len
)
679 /* On LynxOS, memory writes needs to be performed in chunks the size
680 of int types, and they should also be aligned accordingly. */
682 const int xfer_size
= sizeof (buf
);
683 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) xfer_size
;
684 ptid_t inferior_ptid
= ptid_of (current_thread
);
686 while (addr
< memaddr
+ len
)
692 skip
= memaddr
- addr
;
693 if (addr
+ xfer_size
> memaddr
+ len
)
694 truncate
= addr
+ xfer_size
- memaddr
- len
;
695 if (skip
> 0 || truncate
> 0)
697 /* We need to read the memory at this address in order to preserve
698 the data that we are not overwriting. */
699 read_memory (addr
, (unsigned char *) &buf
, xfer_size
);
703 memcpy ((gdb_byte
*) &buf
+ skip
, myaddr
+ (addr
- memaddr
) + skip
,
704 xfer_size
- skip
- truncate
);
706 lynx_ptrace (PTRACE_POKETEXT
, inferior_ptid
, addr
, buf
, 0);
715 /* Implement the kill_request target_ops method. */
718 lynx_process_target::request_interrupt ()
720 ptid_t inferior_ptid
= ptid_of (get_first_thread ());
722 kill (lynx_ptid_get_pid (inferior_ptid
), SIGINT
);
726 lynx_process_target::supports_hardware_single_step ()
731 /* The LynxOS target ops object. */
733 static lynx_process_target the_lynx_target
;
735 /* The LynxOS target_ops vector. */
737 static process_stratum_target lynx_target_ops
= {
739 NULL
, /* supports_disable_randomization */
740 NULL
, /* qxfer_libraries_svr4 */
741 NULL
, /* support_agent */
742 NULL
, /* enable_btrace */
743 NULL
, /* disable_btrace */
744 NULL
, /* read_btrace */
745 NULL
, /* read_btrace_conf */
746 NULL
, /* supports_range_stepping */
747 NULL
, /* pid_to_exec_file */
748 NULL
, /* multifs_open */
749 NULL
, /* multifs_unlink */
750 NULL
, /* multifs_readlink */
751 NULL
, /* breakpoint_kind_from_pc */
752 NULL
, /* sw_breakpoint_from_kind */
753 NULL
, /* thread_name */
754 NULL
, /* breakpoint_kind_from_current_state */
755 NULL
, /* supports_software_single_step */
756 NULL
, /* supports_catch_syscall */
757 NULL
, /* get_ipa_tdesc_idx */
758 NULL
, /* thread_handle */
763 initialize_low (void)
765 set_target_ops (&lynx_target_ops
);
766 the_low_target
.arch_setup ();