1 /* Copyright (C) 2009-2012 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>
31 int using_threads
= 1;
33 /* Print a debug trace on standard output if debug_threads is set. */
36 lynx_debug (char *string
, ...)
43 va_start (args
, string
);
44 fprintf (stderr
, "DEBUG(lynx): ");
45 vfprintf (stderr
, string
, args
);
46 fprintf (stderr
, "\n");
50 /* Build a ptid_t given a PID and a LynxOS TID. */
53 lynx_ptid_build (int pid
, long tid
)
55 /* brobecker/2010-06-21: It looks like the LWP field in ptids
56 should be distinct for each thread (see write_ptid where it
57 writes the thread ID from the LWP). So instead of storing
58 the LynxOS tid in the tid field of the ptid, we store it in
60 return ptid_build (pid
, tid
, 0);
63 /* Return the process ID of the given PTID.
65 This function has little reason to exist, it's just a wrapper around
66 ptid_get_pid. But since we have a getter function for the lynxos
67 ptid, it feels cleaner to have a getter for the pid as well. */
70 lynx_ptid_get_pid (ptid_t ptid
)
72 return ptid_get_pid (ptid
);
75 /* Return the LynxOS tid of the given PTID. */
78 lynx_ptid_get_tid (ptid_t ptid
)
80 /* See lynx_ptid_build: The LynxOS tid is stored inside the lwp field
82 return ptid_get_lwp (ptid
);
85 /* For a given PTID, return the associated PID as known by the LynxOS
89 lynx_ptrace_pid_from_ptid (ptid_t ptid
)
91 return BUILDPID (lynx_ptid_get_pid (ptid
), lynx_ptid_get_tid (ptid
));
94 /* Return a string image of the ptrace REQUEST number. */
97 ptrace_request_to_str (int request
)
102 return "PTRACE_TRACEME";
104 case PTRACE_PEEKTEXT
:
105 return "PTRACE_PEEKTEXT";
107 case PTRACE_PEEKDATA
:
108 return "PTRACE_PEEKDATA";
110 case PTRACE_PEEKUSER
:
111 return "PTRACE_PEEKUSER";
113 case PTRACE_POKETEXT
:
114 return "PTRACE_POKETEXT";
116 case PTRACE_POKEDATA
:
117 return "PTRACE_POKEDATA";
119 case PTRACE_POKEUSER
:
120 return "PTRACE_POKEUSER";
123 return "PTRACE_CONT";
126 return "PTRACE_KILL";
128 case PTRACE_SINGLESTEP
:
129 return "PTRACE_SINGLESTEP";
132 return "PTRACE_ATTACH";
135 return "PTRACE_DETACH";
138 return "PTRACE_GETREGS";
141 return "PTRACE_SETREGS";
143 case PTRACE_GETFPREGS
:
144 return "PTRACE_GETFPREGS";
146 case PTRACE_SETFPREGS
:
147 return "PTRACE_SETFPREGS";
149 case PTRACE_READDATA
:
150 return "PTRACE_READDATA";
152 case PTRACE_WRITEDATA
:
153 return "PTRACE_WRITEDATA";
155 case PTRACE_READTEXT
:
156 return "PTRACE_READTEXT";
158 case PTRACE_WRITETEXT
:
159 return "PTRACE_WRITETEXT";
161 case PTRACE_GETFPAREGS
:
162 return "PTRACE_GETFPAREGS";
164 case PTRACE_SETFPAREGS
:
165 return "PTRACE_SETFPAREGS";
167 case PTRACE_GETWINDOW
:
168 return "PTRACE_GETWINDOW";
170 case PTRACE_SETWINDOW
:
171 return "PTRACE_SETWINDOW";
174 return "PTRACE_SYSCALL";
176 case PTRACE_DUMPCORE
:
177 return "PTRACE_DUMPCORE";
179 case PTRACE_SETWRBKPT
:
180 return "PTRACE_SETWRBKPT";
182 case PTRACE_SETACBKPT
:
183 return "PTRACE_SETACBKPT";
186 return "PTRACE_CLRBKPT";
188 case PTRACE_GET_UCODE
:
189 return "PTRACE_GET_UCODE";
193 return "PT_READ_GPR";
198 return "PT_WRITE_GPR";
203 return "PT_READ_FPR";
208 return "PT_WRITE_FPR";
213 return "PT_READ_VPR";
218 return "PT_WRITE_VPR";
221 #ifdef PTRACE_PEEKUSP
223 return "PTRACE_PEEKUSP";
226 #ifdef PTRACE_POKEUSP
228 return "PTRACE_POKEUSP";
231 case PTRACE_PEEKTHREAD
:
232 return "PTRACE_PEEKTHREAD";
234 case PTRACE_THREADUSER
:
235 return "PTRACE_THREADUSER";
238 return "PTRACE_FPREAD";
241 return "PTRACE_FPWRITE";
244 return "PTRACE_SETSIG";
246 case PTRACE_CONT_ONE
:
247 return "PTRACE_CONT_ONE";
249 case PTRACE_KILL_ONE
:
250 return "PTRACE_KILL_ONE";
252 case PTRACE_SINGLESTEP_ONE
:
253 return "PTRACE_SINGLESTEP_ONE";
255 case PTRACE_GETLOADINFO
:
256 return "PTRACE_GETLOADINFO";
258 #ifdef PTRACE_GETTHREADLIST
259 case PTRACE_GETTHREADLIST
:
260 return "PTRACE_GETTHREADLIST";
264 return "<unknown-request>";
267 /* A wrapper around ptrace that allows us to print debug traces of
268 ptrace calls if debug traces are activated. */
271 lynx_ptrace (int request
, ptid_t ptid
, int addr
, int data
, int addr2
)
274 const int pid
= lynx_ptrace_pid_from_ptid (ptid
);
278 fprintf (stderr
, "PTRACE (%s, pid=%d(pid=%d, tid=%d), addr=0x%x, "
279 "data=0x%x, addr2=0x%x)",
280 ptrace_request_to_str (request
), pid
, PIDGET (pid
), TIDGET (pid
),
282 result
= ptrace (request
, pid
, addr
, data
, addr2
);
285 fprintf (stderr
, " -> %d (=0x%x)\n", result
, result
);
291 /* Implement the create_inferior method of the target_ops vector. */
294 lynx_create_inferior (char *program
, char **allargs
)
296 struct process_info
*new_process
;
299 lynx_debug ("lynx_create_inferior ()");
303 perror_with_name ("fork");
309 /* Switch child to its own process group so that signals won't
310 directly affect gdbserver. */
313 ioctl (0, TIOCSPGRP
, &pgrp
);
314 lynx_ptrace (PTRACE_TRACEME
, null_ptid
, 0, 0, 0);
315 execv (program
, allargs
);
316 fprintf (stderr
, "Cannot exec %s: %s.\n", program
, strerror (errno
));
321 new_process
= add_process (pid
, 0);
322 /* Do not add the process thread just yet, as we do not know its tid.
323 We will add it later, during the wait for the STOP event corresponding
324 to the lynx_ptrace (PTRACE_TRACEME) call above. */
328 /* Implement the attach target_ops method. */
331 lynx_attach (unsigned long pid
)
333 struct process_info
*new_process
;
334 ptid_t ptid
= lynx_ptid_build (pid
, 0);
336 if (lynx_ptrace (PTRACE_ATTACH
, ptid
, 0, 0, 0) != 0)
337 error ("Cannot attach to process %lu: %s (%d)\n", pid
,
338 strerror (errno
), errno
);
340 new_process
= add_process (pid
, 1);
341 add_thread (ptid
, NULL
);
346 /* Implement the resume target_ops method. */
349 lynx_resume (struct thread_resume
*resume_info
, size_t n
)
351 ptid_t inferior_ptid
= thread_to_gdb_id (current_inferior
);
352 /* FIXME: Assume for now that n == 1. */
353 const int request
= (resume_info
[0].kind
== resume_step
354 ? PTRACE_SINGLESTEP
: PTRACE_CONT
);
355 const int signal
= resume_info
[0].sig
;
358 regcache_invalidate ();
359 ret
= lynx_ptrace (request
, inferior_ptid
, 1, signal
, 0);
362 /* Resume the execution of the given PTID. */
365 lynx_continue (ptid_t ptid
)
367 struct thread_resume resume_info
;
369 resume_info
.thread
= ptid
;
370 resume_info
.kind
= resume_continue
;
373 lynx_resume (&resume_info
, 1);
376 /* Remove all inferiors and associated threads. */
379 lynx_clear_inferiors (void)
381 /* We do not use private data, so nothing much to do except calling
386 /* A wrapper around waitpid that handles the various idiosyncrasies
387 of LynxOS' waitpid. */
390 lynx_waitpid (int pid
, int *stat_loc
)
396 ret
= waitpid (pid
, stat_loc
, WNOHANG
);
399 /* An ECHILD error is not indicative of a real problem.
400 It happens for instance while waiting for the inferior
401 to stop after attaching to it. */
403 perror_with_name ("waitpid (WNOHANG)");
407 /* No event with WNOHANG. See if there is one with WUNTRACED. */
408 ret
= waitpid (pid
, stat_loc
, WNOHANG
| WUNTRACED
);
411 /* An ECHILD error is not indicative of a real problem.
412 It happens for instance while waiting for the inferior
413 to stop after attaching to it. */
415 perror_with_name ("waitpid (WNOHANG|WUNTRACED)");
424 /* Implement the wait target_ops method. */
427 lynx_wait_1 (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
434 if (ptid_equal (ptid
, minus_one_ptid
))
435 pid
= lynx_ptid_get_pid (thread_to_gdb_id (current_inferior
));
437 pid
= BUILDPID (lynx_ptid_get_pid (ptid
), lynx_ptid_get_tid (ptid
));
441 ret
= lynx_waitpid (pid
, &wstat
);
442 new_ptid
= lynx_ptid_build (ret
, ((union wait
*) &wstat
)->w_tid
);
444 /* If this is a new thread, then add it now. The reason why we do
445 this here instead of when handling new-thread events is because
446 we need to add the thread associated to the "main" thread - even
447 for non-threaded applications where the new-thread events are not
449 if (!find_thread_ptid (new_ptid
))
450 add_thread (new_ptid
, NULL
);
452 if (WIFSTOPPED (wstat
))
454 status
->kind
= TARGET_WAITKIND_STOPPED
;
455 status
->value
.integer
= gdb_signal_from_host (WSTOPSIG (wstat
));
456 lynx_debug ("process stopped with signal: %d",
457 status
->value
.integer
);
459 else if (WIFEXITED (wstat
))
461 status
->kind
= TARGET_WAITKIND_EXITED
;
462 status
->value
.integer
= WEXITSTATUS (wstat
);
463 lynx_debug ("process exited with code: %d", status
->value
.integer
);
465 else if (WIFSIGNALED (wstat
))
467 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
468 status
->value
.integer
= gdb_signal_from_host (WTERMSIG (wstat
));
469 lynx_debug ("process terminated with code: %d",
470 status
->value
.integer
);
474 /* Not sure what happened if we get here, or whether we can
475 in fact get here. But if we do, handle the event the best
477 status
->kind
= TARGET_WAITKIND_STOPPED
;
478 status
->value
.integer
= gdb_signal_from_host (0);
479 lynx_debug ("unknown event ????");
482 /* SIGTRAP events are generated for situations other than single-step/
483 breakpoint events (Eg. new-thread events). Handle those other types
484 of events, and resume the execution if necessary. */
485 if (status
->kind
== TARGET_WAITKIND_STOPPED
486 && status
->value
.integer
== GDB_SIGNAL_TRAP
)
488 const int realsig
= lynx_ptrace (PTRACE_GETTRACESIG
, new_ptid
, 0, 0, 0);
490 lynx_debug ("(realsig = %d)", realsig
);
494 /* We just added the new thread above. No need to do anything
495 further. Just resume the execution again. */
496 lynx_continue (ptid
);
500 remove_thread (find_thread_ptid (new_ptid
));
501 lynx_continue (ptid
);
509 /* A wrapper around lynx_wait_1 that also prints debug traces when
510 such debug traces have been activated. */
513 lynx_wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
517 lynx_debug ("lynx_wait (pid = %d, tid = %ld)",
518 lynx_ptid_get_pid (ptid
), lynx_ptid_get_tid (ptid
));
519 new_ptid
= lynx_wait_1 (ptid
, status
, options
);
520 lynx_debug (" -> (pid=%d, tid=%ld, status->kind = %d)",
521 lynx_ptid_get_pid (new_ptid
), lynx_ptid_get_tid (new_ptid
),
526 /* Implement the kill target_ops method. */
531 ptid_t ptid
= lynx_ptid_build (pid
, 0);
532 struct target_waitstatus status
;
533 struct process_info
*process
;
535 process
= find_process_pid (pid
);
539 lynx_ptrace (PTRACE_KILL
, ptid
, 0, 0, 0);
540 lynx_wait (ptid
, &status
, 0);
541 the_target
->mourn (process
);
545 /* Implement the detach target_ops method. */
548 lynx_detach (int pid
)
550 ptid_t ptid
= lynx_ptid_build (pid
, 0);
551 struct process_info
*process
;
553 process
= find_process_pid (pid
);
557 lynx_ptrace (PTRACE_DETACH
, ptid
, 0, 0, 0);
558 the_target
->mourn (process
);
562 /* Implement the mourn target_ops method. */
565 lynx_mourn (struct process_info
*proc
)
567 lynx_clear_inferiors ();
570 /* Implement the join target_ops method. */
575 /* The PTRACE_DETACH is sufficient to detach from the process.
576 So no need to do anything extra. */
579 /* Implement the thread_alive target_ops method. */
582 lynx_thread_alive (ptid_t ptid
)
584 /* The list of threads is updated at the end of each wait, so it
585 should be up to date. No need to re-fetch it. */
586 return (find_thread_ptid (ptid
) != NULL
);
589 /* Implement the fetch_registers target_ops method. */
592 lynx_fetch_registers (struct regcache
*regcache
, int regno
)
594 struct lynx_regset_info
*regset
= lynx_target_regsets
;
595 ptid_t inferior_ptid
= thread_to_gdb_id (current_inferior
);
597 lynx_debug ("lynx_fetch_registers (regno = %d)", regno
);
599 while (regset
->size
>= 0)
604 buf
= xmalloc (regset
->size
);
605 res
= lynx_ptrace (regset
->get_request
, inferior_ptid
, (int) buf
, 0, 0);
608 regset
->store_function (regcache
, buf
);
614 /* Implement the store_registers target_ops method. */
617 lynx_store_registers (struct regcache
*regcache
, int regno
)
619 struct lynx_regset_info
*regset
= lynx_target_regsets
;
620 ptid_t inferior_ptid
= thread_to_gdb_id (current_inferior
);
622 lynx_debug ("lynx_store_registers (regno = %d)", regno
);
624 while (regset
->size
>= 0)
629 buf
= xmalloc (regset
->size
);
630 res
= lynx_ptrace (regset
->get_request
, inferior_ptid
, (int) buf
, 0, 0);
633 /* Then overlay our cached registers on that. */
634 regset
->fill_function (regcache
, buf
);
635 /* Only now do we write the register set. */
636 res
= lynx_ptrace (regset
->set_request
, inferior_ptid
, (int) buf
,
646 /* Implement the read_memory target_ops method. */
649 lynx_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
651 /* On LynxOS, memory reads needs to be performed in chunks the size
652 of int types, and they should also be aligned accordingly. */
654 const int xfer_size
= sizeof (buf
);
655 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) xfer_size
;
656 ptid_t inferior_ptid
= thread_to_gdb_id (current_inferior
);
658 while (addr
< memaddr
+ len
)
665 skip
= memaddr
- addr
;
666 if (addr
+ xfer_size
> memaddr
+ len
)
667 truncate
= addr
+ xfer_size
- memaddr
- len
;
668 buf
= lynx_ptrace (PTRACE_PEEKTEXT
, inferior_ptid
, addr
, 0, 0);
671 memcpy (myaddr
+ (addr
- memaddr
) + skip
, (gdb_byte
*) &buf
+ skip
,
672 xfer_size
- skip
- truncate
);
679 /* Implement the write_memory target_ops method. */
682 lynx_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
684 /* On LynxOS, memory writes needs to be performed in chunks the size
685 of int types, and they should also be aligned accordingly. */
687 const int xfer_size
= sizeof (buf
);
688 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) xfer_size
;
689 ptid_t inferior_ptid
= thread_to_gdb_id (current_inferior
);
691 while (addr
< memaddr
+ len
)
697 skip
= memaddr
- addr
;
698 if (addr
+ xfer_size
> memaddr
+ len
)
699 truncate
= addr
+ xfer_size
- memaddr
- len
;
700 if (skip
> 0 || truncate
> 0)
701 /* We need to read the memory at this address in order to preserve
702 the data that we are not overwriting. */
703 lynx_read_memory (addr
, (unsigned char *) &buf
, xfer_size
);
706 memcpy ((gdb_byte
*) &buf
+ skip
, myaddr
+ (addr
- memaddr
) + skip
,
707 xfer_size
- skip
- truncate
);
709 lynx_ptrace (PTRACE_POKETEXT
, inferior_ptid
, addr
, buf
, 0);
718 /* Implement the kill_request target_ops method. */
721 lynx_request_interrupt (void)
723 ptid_t inferior_ptid
= thread_to_gdb_id (current_inferior
);
725 kill (lynx_ptid_get_pid (inferior_ptid
), SIGINT
);
728 /* The LynxOS target_ops vector. */
730 static struct target_ops lynx_target_ops
= {
731 lynx_create_inferior
,
740 lynx_fetch_registers
,
741 lynx_store_registers
,
742 NULL
, /* prepare_to_access_memory */
743 NULL
, /* done_accessing_memory */
746 NULL
, /* look_up_symbols */
747 lynx_request_interrupt
,
748 NULL
, /* read_auxv */
749 NULL
, /* insert_point */
750 NULL
, /* remove_point */
751 NULL
, /* stopped_by_watchpoint */
752 NULL
, /* stopped_data_address */
753 NULL
, /* read_offsets */
754 NULL
, /* get_tls_address */
755 NULL
, /* qxfer_spu */
756 NULL
, /* hostio_last_error */
757 NULL
, /* qxfer_osdata */
758 NULL
, /* qxfer_siginfo */
759 NULL
, /* supports_non_stop */
761 NULL
, /* start_non_stop */
762 NULL
, /* supports_multi_process */
763 NULL
, /* handle_monitor_command */
767 initialize_low (void)
769 set_target_ops (&lynx_target_ops
);
770 the_low_target
.arch_setup ();